v0.106.0

What's Changed

• docs(changelog): date 0.106.0 on its tag day
• fix(turns): a request the Redis backend cannot write leaves no owner link waiting for its turn (RMK-848)
• fix(turns): an OSError rebuilt as a stand-in keeps its errno, its strerror and its file names (RMK-856)
• fix(turns): a request or channel call a closing process refused is no longer handed, so a failure placing it again leaves the room's previous turn (RMK-857)
• docs(changelog): a turn backend marks a request or channel call handed as it gives it to an executor (RMK-857)
• fix(turns): an OSError keeps its file names across the turn backend, and a rebuilt built-in is kept only when it gives its message back (RMK-856)
• fix(turns): a Redis executor's process names a turn whose end is being written for heartbeat_timeout at most (RMK-852)
• fix(turns): the backend marks a turn or channel call handed as it gives it to an executor, and only one it handed stays the room's previous turn (RMK-857)
• fix(turns): a Redis executor's process that closes mid-turn cuts the turn and writes its end, so its owner learns it within the cancel bound (RMK-853)
• fix(turns): a Redis executor's process names a turn running until its end is written, so a stall right after it ends loses no completed turn (RMK-852)
• fix(turns): a built-in error keeps the message its fields make, and a class that cannot give its message back still reads as itself (RMK-856)
• fix(turns): a declared class nested in a class or defined in a function comes back as itself (RMK-855)
• fix(turns): a class name off the wire never evaluates a lazy proxy a module holds under that name (RMK-854)
• docs(changelog): a value JSON has no form for in a request's room data crosses as its text, as the record's does (RMK-848)
• fix(turns): a turn the owner stopped submitting once it was taken stays the room's previous turn, and a channel call refused before it is sent leaves it (RMK-857)
• fix(acp): each room's agent updates and permission requests run under that room's turn (RMK-846)
• fix(acp): a channel call that runs across a detach keeps no session and no value for the room (RMK-858)
• fix(turns): a channel call the host stopped waiting for stays the room's previous turn (RMK-857)
• fix(turns): an executor closed while a turn's end waits for a host verb still ends the turn (RMK-851)
• fix(turns): the end of a turn lets go of a detached human-input request instead of withdrawing it (RMK-850)
• fix(hooks): a room hook enabled before it is defined, or defined again, runs on the kit's executor outside a turn (RMK-849)
• fix(turns): a room's value JSON has no form for crosses in a turn's request as its text, as the record's does (RMK-848)
• fix(turns): a host verb made outside the tool loop crosses at least as deep as the turn's response (RMK-847)
• docs(changelog): promote 0.106.0, and mark the error-class and ACP detach changes BREAKING
• perf(conference): read the room context for a conference's voice hooks only when one is registered, per review (RMK-797)
• fix(voice): an utterance goes on when its ON_SPEECH_END observers cannot read the room's context, per review (RMK-797)
• refactor(voice): tidy RoomHooks' docstring, the stale guard comments and the bench's rooms, and count reads on the turn wait and barge-in, per review (RMK-797)
• feat(benchmarks): measure the voice frame cost on PostgresStore with --dsn, the backlog drained before close (RMK-797)
• perf(voice): read the room context for a voice event's hooks only when one is registered, once per event (RMK-797)
• perf(store): InMemoryStore answers binding_exists without copying the binding (RMK-797)
• test(acp): wait for streamed text by time, not by loop turns, so the suite across Redis stops failing on it (RMK-841)
• docs(turns): the record counts its writes, in its docstring, the executor's and the CHANGELOG's Added, per review (RMK-841)
• fix(turns): a record a channel left a bare dict is compared before every item, as before, and a change inside a value reaches the owner however its stream stops, per review (RMK-841)
• refactor(turns): one definition of a delta, on the codec's item kinds, for the executor and the owner, per review (RMK-841)
• feat(benchmarks): measure RTP calls per core, aiortp against a native engine (RMK-794)
• perf(turns): copy a turn's record before a delta only once one of its keys was written (RMK-841)
• feat(benchmarks): measure the CPU RoomKit spends per inbound voice frame (RMK-796)
• perf(voice): rms_db sums with the int64 dot Sherpa's VAD and WebRTC's AEC use, in one place (RMK-796)
• refactor(voice): drop the simple AGC's empty-frame guard that its rms check already covers, per review (RMK-796)
• docs(voice): name which NumPy method outruns the stdlib sum and list Speex's statistics, per review (RMK-796)
• docs(examples): files an application keeps beside a message's words, read by an attached_media reader (RMK-805)
• perf(voice): square a frame's samples with math.sumprod, in one place (RMK-796)
• fix(turns): a class name off the wire never loads a lazy module, a declaration reaches both sides, and an error crossing twice keeps its arguments, per review (RMK-838)
• feat(turns): an application's error classes cross the turn backend as themselves, and any other keeps its attributes and its nearest rebuilt ancestor (RMK-838)
• refactor(core): extract the setup of the kit's turn client from RoomKit.init (RMK-838)
• refactor(turns): move what an exception becomes on the wire into a module of its own (RMK-838)
• fix(router): a transport absent from the process is skipped without a warning (RMK-828)
• fix(hooks): the kit's engine runs the turn observers registered through it, and a failed call no hook covers builds no context (RMK-833)
• fix(hooks): the refusal reads a turn hook's type filter as the engine does, and a filtered hook neither denies nor withholds another agent's call (RMK-833)
• fix(hooks): a turn hook's channel filters hold, and the kit's engine reads the turn hooks it registered (RMK-833)
• feat(hooks): a turn hook on the kit is its own executor's again, refused only where a declared agent could fire it (RMK-833)
• fix(ci): the Redis-mode run unsets the Postgres DSN, and the delta cost is measured against a direct read (RMK-813, RMK-823)
• fix(turns): a closed executor refuses a channel control, and an event held for an unheld room goes where its next turn goes (RMK-813)
• fix(turns): a channel control a closing Redis process refuses is placed again, and a hung read fails from its start (RMK-813)
• fix(turns): a closing Redis process refuses what still reaches it, and a failed read is dated when it fails (RMK-813)
• fix(turns): a closing Redis process beats undeclared until it answered what it was doing, and a slow read is not the others' silence (RMK-813)
• fix(turns): a closing Redis process refuses the turns still reaching it, and answers and work after a turn are written in order until they are (RMK-813)
• fix(turns): a Redis turn written twice runs once, and reading the others costs the same however many turns they run (RMK-813)
• fix(turns): Redis turns are alive per turn and per process, written in order, and handed over once (RMK-813)
• feat(turns): RedisTurnBackend carries an agent's turns to an executor in another process (RMK-813)
• fix(turns): a reader that stops after its turn ended reads the turn's last record, and a second cut lets the first one's close finish (RMK-823)
• refactor(turns): a turn's pulls, its channel's changes, its steering, its stream copies and its publisher in modules of their own (RMK-823)
• fix(turns): a pull sent before its reader read a call's start grants nothing past it, and a cut while waiting for a pull closes the stream (RMK-823)
• perf(turns): a pull grants a window and text deltas cross by burst, and a cancelled delivery reports its cleanup only once its turns ended (RMK-823)
• fix(turns): a turn's work after it is the turn's from its acceptance, and a thinker reports under the turn that asked, per review (RMK-827)
• feat(turns): work a turn began reaches the room owner after the turn ended (RMK-827)
• feat(turns): a discussion hands its agents' memories each committed message through the turn backend (RMK-827)
• fix(orchestration): a declaration says whether its turns take the owner's tools, unregistering drops them, per review (RMK-826)
• feat(orchestration): strategies and the owner's tools take an agent the kit holds by its declaration, named by id (RMK-826)
• refactor(turns): the room's owner keeps the tools orchestration sets up, never the live agent (RMK-826)
• fix(turns): a declaration reads as an AI channel by default, registration and strategy refusals leave nothing half set up, per review (RMK-822)
• feat(turns): the kit holds an agent by its declaration alone, and a host's executor builds it (RMK-822)
• fix(tasks): cancel_task holds to the room's posted tasks, set up whole, per review (RMK-825)
• feat(tasks): the room's task tools are served by the owner, and cancel_task cancels only the room's own tasks (RMK-825)
• fix(turns): a turn runs the room hooks its request named, scoped to it, and never overwrites the room's set (RMK-821)
• fix(turns): a turn's publications are published off its frame reader, room hooks reach every door at once, and an executor's channels never leak, per review (RMK-821)
• fix(webrtc): vendored headers name fastrtc's MIT license (RMK-824)
• refactor(webrtc): tidy the 3.13 fix per review (RMK-824)
• fix(webrtc): drop an oversized media frame, like the other websocket transports (RMK-824)
• fix(vui): narrow the clip branch with an assert, keep the preset branch typed (RMK-824)
• feat(turns): an executor wires the channels it runs, its turns' publications cross as frames, and room hooks go by name (RMK-821)
• ci: install the fastrtc extra alone on Python 3.13 (RMK-824)
• fix(webrtc): roomkit[fastrtc] imports on Python 3.13 (RMK-824)
• refactor(webrtc): extract the media-event decode from handle_websocket (RMK-824)
• fix(vui): branch a voice's prompt on its clip, which ty can narrow (RMK-824)
• fix(turns): a turn's host posts no task status, which the room's task tools read as the room's tasks (RMK-820)
• fix(turns): a status post through TurnHost names its turn's room, a detach during a standalone turn closes the room's ACP session, and a read stores no object-held value (RMK-820)
• fix(turns): an ACP agent's room state holds across steering, detaches and stale records, and only the host sets it, per review (RMK-812)
• feat(turns): an ACP agent's room state crosses the turn backend: channel calls, the previous turn, placement (RMK-812)
• fix(turns): the kit's answer to a human-input request says whether the tool read it, and a request open at its turn's end is withdrawn (RMK-811)
• fix(turns): a human-input request settles where its tool waits, first come first served, and its owner's record follows (RMK-811)
• test(steering): the two-room stop waits for both loops by time, not by a count of loop turns (RMK-811)
• feat(turns): a turn's human-input requests are answered on the room owner, and the steering review is fixed (RMK-811)
• feat(turns): the owner steers a turn and tells it why it is cancelled, across the turn backend (RMK-811)
• fix(turns): a host's verb runs under its turn's call context and for its turn's room only (RMK-811)
• feat(turns): TurnHost, how a host's tool or hook on a turn's executor reaches a room (RMK-811)
• fix(turns): an owner-served call is withdrawn at its bound, runs under its turn, and the kit's close waits for it (RMK-811)
• feat(turns): RoomKit's own tools are served by the room owner, each call a tool_call through the turn backend (RMK-811)
• fix(orchestration): a strategy's generation enters through the channel's on_event, and the review's tests prove the move (RMK-814)
• feat(orchestration): a strategy's runner takes an agent's turns on the room owner, each generation a turn of its own (RMK-814)
• fix(hooks): take back a strategy's executor hooks, wire both engines alike, and name each door (RMK-810)
• feat(hooks)!: the hooks of a turn register on the turn executor, and the kit refuses them (RMK-810)
• fix(turns): close the streams nobody reads, keep where an error was raised, refuse what cannot cross (RMK-809)
• feat(turns): every intelligence turn runs through a turn backend, in memory by default, on serialized messages (RMK-809)
• fix(discussion): the default rules say a bare "your turn" hands nothing over (RMK-806)
• feat(discussion): the host gives a discussion's turns its own rules, and the default asks for a handle (RMK-806)
• feat(ai): the media an application keeps beside a message's content, read as the message's own, and an image a model cannot see said so (RMK-805)
• Begin 0.106.0.dev0 development

Full Changelog: v0.105.0...v0.106.0