@aparte/core 0.19.2 → 0.20.0

package/README.md

@@ -2,9 +2,14 @@
 
 [![Published on webcomponents.org](https://img.shields.io/badge/webcomponents.org-published-blue.svg)](https://www.webcomponents.org/element/@aparte/core)
 
-Framework-agnostic AI chat UI as **vanilla Web Components, with the agent loop inside** —
+AI chat and agent UI components as **vanilla Web Components, with the agent loop inside** —
 zero third-party dependencies, ESM-only, usable in any framework or none.
 
+The conversation, messages, reasoning, tool calls a human approves, the questions an agent
+asks, the composer, the layout around the chat (app shell, sidebar, conversation list) and a
+UI kit for the rest of the app — each one [shown live with its variants](https://apartejs.dev/components/),
+and assembled into [templates](https://apartejs.dev/templates/) you can copy.
+
 > **Beta.** On npm, released in lockstep with every other `@aparte/*` package — the
 > version number is a plain `0.x`, and the declared surface is
 > [frozen as of 0.17.0](https://apartejs.dev/reference/stability/): it leaves only

package/dist/client/aparte-client.d.ts

@@ -22,8 +22,8 @@ export type AparteToolApprovalResolver = (call: {
      * What the user said to do instead, on a refusal.
      *
      * It becomes the `tool` message the model reads, which is possible at all only
-     * because a refusal now hands the model a turn. Optional and additive: a resolver
-     * that returns a bare `{ approved }` behaves exactly as before.
+     * because a refusal hands the model a turn. Optional: a resolver that returns a
+     * bare `{ approved }` is valid.
      */
     instruction?: string;
     /**
@@ -91,7 +91,7 @@ export interface AparteClientOptions {
      *                          that cutoff; a turn a host seeded with NO `status` counts
      *                          as answered, so a restored or server-rendered transcript
      *                          goes out as history without inventing a status for it.
-     * - 'none'               — sends only the current message (original behavior)
+     * - 'none'               — sends only the current message
      * - function             — custom: receives viewport messages, returns AparteChatMessage[]
      */
     history?: 'viewport' | 'none' | ((viewportMessages: AparteMessage[]) => AparteChatMessage[]);
@@ -133,10 +133,9 @@ export interface AparteClientOptions {
     /**
      * Whether a send appends the optimistic USER bubble before the reply streams.
      *
-     * Default `true` — and opt-OUT on purpose: the bubble used to be the host's job
-     * on every path, everyone wrote the same `aparte-send` handler, and whoever
-     * forgot shipped a chat where the person cannot see what they typed. It
-     * compiles, it streams, and nothing errors.
+     * Default `true` — and opt-OUT on purpose: if the host had to append the bubble,
+     * whoever forgot would ship a chat where the person cannot see what they typed.
+     * It compiles, it streams, and nothing errors.
      *
      * Pass `false` when the host owns its transcript and appends the user message
      * itself — the four framework wrappers do (their ConversationController is
@@ -155,8 +154,7 @@ export interface AparteClientOptions {
      *   types (including images) are routed to the application layer. Used
      *   when images go through a captioning pipeline before RAG ingest, so
      *   the chat context only ever sees retrieved text — never raw image
-     *   bytes. Saves bytes on every turn and matches the offline-first
-     *   intent (read file once at upload, retrieve text-only forever after).
+     *   bytes. Saves bytes on every turn.
      *
      * Set `'images-only'` when a `requestInterceptor` retrieves relevant
      * document chunks and injects them as a system message instead, to avoid
@@ -214,15 +212,13 @@ export declare class AparteClient {
     /**
      * Does this window event belong to this client?
      *
-     * One rule for all four handlers, because it used to be near-copies and
-     * one omission: `aparte-compact` (answered here until 0.16.0) had no guard at all, so in the two-client
-     * layout the JSDoc documents, a single compact event made BOTH clients run —
-     * two paid summarisation calls against whichever chat the DOM scan found
-     * first, and a global reset that wiped the other conversation.
+     * One rule for all the window-event handlers, so none of them can lack the guard:
+     * in a two-client layout an unguarded event would make BOTH clients run — two paid
+     * calls against whichever chat the DOM scan found first.
      *
-     * A scoped client also answers only events ADDRESSED to it. The old guard let
-     * an untargeted event through to every scoped client, which turned one
-     * broadcast into an action on every chat on the page.
+     * A scoped client also answers only events ADDRESSED to it; an untargeted event is
+     * not let through to every scoped client, or one broadcast would act on every chat
+     * on the page.
      */
     private _isForThisInstance;
     /** Aborts the in-flight vendor/transport fetch when the user stops a stream. */
@@ -230,31 +226,33 @@ export declare class AparteClient {
     private options;
     /** Config read by this client — an instance config, or the global default. */
     private readonly _config;
+    /**
+     * A `keyResolver` becomes a key source on the client's config at once, before `start()`,
+     * so everything that needs a key can use it — the model selector's list included.
+     * `autoRegister` (on by default) installs core's built-in renderers on that config.
+     */
     constructor(options?: AparteClientOptions);
     /**
      * What every fresh user action does before it starts a turn.
      *
-     * Clearing the abort flag has to happen at the START of the action rather than inside
+     * Clearing the abort flag happens at the START of the action rather than inside
      * `_streamTurn`, which runs after the auth and file-reading awaits — a reset there
-     * erased an abort that arrived while the user was still waiting for a large attachment
-     * to be read.
+     * would erase an abort that arrived while the user was still waiting for a large
+     * attachment to be read.
      *
      * The superseded turn's TOOL handlers are not cancelled here, and do not need a
      * registry of their own: `_streamTurn` aborts the previous `_streamController`, and
      * the engine links every tool handler's controller to that run signal
-     * (`invokeToolHandler`), so cutting the stream cuts its tools. A `Set<AbortController>`
-     * used to sit here for that job and was never added to — three lines of loop over an
-     * empty set, plus a paragraph describing a cancellation the method did not perform.
+     * (`invokeToolHandler`), so cutting the stream cuts its tools.
      */
     private _beginUserTurn;
     /**
      * Put this client's `keyResolver` on its config, and hold the teardown so
      * `stop()` can take it back off.
      *
-     * The registration used to be fire-and-forget, so it outlived the client that
-     * made it: a stopped client kept signing model-list requests, and a remount —
-     * the way the wrappers document swapping options — added a source behind the
-     * one it meant to replace instead of replacing it. Idempotent, so the usual
+     * The teardown means a stopped client stops signing model-list requests, and a
+     * remount — the way the wrappers document swapping options — replaces the source
+     * instead of adding one behind it. Idempotent, so the usual
      * `new AparteClient({…}).start()` registers once.
      */
     private _registerKeyResolver;
@@ -264,11 +262,14 @@ export declare class AparteClient {
      */
     private _setupListeners;
     /**
-     * Start listening for aparte-send events on the window.
+     * Answer the chats: listen on `window` for `aparte-send`, `aparte-retry`, `aparte-edit`,
+     * `aparte-abort` and `aparte-conversation-loaded`. Nothing streams before this is
+     * called. Starting a stopped client puts its `keyResolver` back on the config.
      */
     start(): void;
     /**
-     * Stop listening.
+     * Stop answering: abort the reply in flight, take this client's `keyResolver` off the
+     * config, and remove the listeners.
      */
     stop(): void;
     /**
@@ -279,27 +280,21 @@ export declare class AparteClient {
     /**
      * Ask the human at the COMPOSER, and report what they decided.
      *
-     * The default channel, replacing a `document` listener for `aparte-tool-decision`
-     * that existed only because the buttons lived in a segment renderer with no
-     * reference to this client. Routing through `requestUserInput` puts the decision
+     * The default channel. Routing through `requestUserInput` puts the decision
      * where every other request for the user already goes, which is the whole point:
      * one queue, one panel slot, one teardown, and the same behaviour whether the
      * request came from a tool handler or from this gate.
      *
      * The tool NAME is the question and its ARGUMENTS are the body, because the
      * arguments are what is being approved — a decision surface that names the act and
-     * hides its subject asks for a signature on a blank page. This paragraph used to
-     * say the opposite ("the arguments stay in the transcript"), and the guide beside
-     * it had always promised what the panel did not do. The transcript row stays the
-     * anchor; it is no longer the only place the call can be read. The panel is capped
+     * hides its subject asks for a signature on a blank page. The transcript row stays the
+     * anchor, but it is not the only place the call can be read. The panel is capped
      * at 50vh and the block inside it scrolls, so a long input cannot push the options
      * off the surface they are asked on.
      *
-     * `aparte-tool-decision` is GONE with the buttons that dispatched it, and so is the
-     * `document` listener that answered it. It existed only because a segment renderer
-     * has no reference to this client; two seams that can disagree about who answers a
-     * decision are one seam too many, and the ratified elicitation rule already said so
-     * — "a typed presenter registered per config instance, never window events". A host
+     * There is no `aparte-tool-decision` event and no `document` listener that answers
+     * one: a decision is answered by a typed presenter registered per config instance,
+     * never by a window event. A host
      * that wants to answer programmatically registers an `approvalResolver` (headless,
      * no DOM) or its own presenter, both strictly more capable than an id on an event.
      */
@@ -340,29 +335,21 @@ export declare class AparteClient {
     /**
      * The registered tools, unless the current model says it cannot call one.
      *
-     * Single source for the gate, so send / retry / edit cannot drift — that drift
-     * is what once shipped `tools` on the initial send while retry and edit omitted
-     * them.
-     *
-     * The gate used to be "the model DECLARES function_calling", defaulting to
-     * stripping — and that made the whole tool surface unreachable on the primary
-     * documented path. Three things had to line up for a tool to be sent, and one
-     * never did: the app sets a model id by hand (`setModelConfig`) or a selector
-     * sets it from a fetched list, and in both cases the model's declared
-     * capabilities are commonly unknown. `undefined` capabilities then read as "no
-     * function calling", so `tools: []` went on the wire while `getTools()` held
-     * the tool the app had explicitly registered. The model answered, correctly,
-     * that it had no such tool, and nothing anywhere said why.
-     *
-     * So the question is now "did this model say it cannot", not "did it say it
-     * can". Registering a tool is an explicit act by the app; silently dropping it
+     * Single source for the gate, so send / retry / edit cannot drift.
+     *
+     * The question is "did this model say it cannot", not "did it say it can": the
+     * app sets a model id by hand (`setModelConfig`) or a selector sets it from a
+     * fetched list, and in both cases the model's declared capabilities are commonly
+     * unknown. `undefined` capabilities read as "can", or `tools: []` would go on
+     * the wire while `getTools()` held the tool the app had explicitly registered,
+     * and the model would answer that it had no such tool. Registering a tool is an explicit act by the app; silently dropping it
      * because a `/models` listing is terse is the library second-guessing the
      * developer. A model that declares its capabilities and omits function calling
      * is still honoured — that is a statement, and it is respected.
      *
      * Failure modes, both ways round: over-sending means a model that cannot use
      * tools does not call one, or its own endpoint rejects the array with an error
-     * the developer can read. Under-sending was silent, total, and looked like a
+     * the developer can read. Under-sending would be silent, total, and look like a
      * lying model.
      */
     private _toolsForCurrentModel;
@@ -371,10 +358,9 @@ export declare class AparteClient {
      * The system messages a turn opens with: the app's own template, then the registered
      * tools' `systemPrompt`s.
      *
-     * A helper rather than three copies. The two lines it replaces were written out at each
-     * of the three turn entry points (send, retry, edit), which is exactly how the tool half
-     * would have been added to two of them and forgotten in the third — the same shape as
-     * the abort-flag asymmetry `_beginUserTurn` exists to prevent.
+     * One helper for the three turn entry points (send, retry, edit), so the tool half
+     * cannot be added to two of them and forgotten in the third — the same shape as the
+     * abort-flag asymmetry `_beginUserTurn` exists to prevent.
      */
     private _systemMessages;
     /**
@@ -396,11 +382,11 @@ export declare class AparteClient {
      * The trees a lookup must search, the one the gesture came from FIRST.
      *
      * `document.getElementById` and `document.querySelectorAll` cannot see into a shadow
-     * root, so a chat mounted in one — the arrangement the theming guide endorses — was
-     * invisible to both: alone, the send was dropped with a warning; on a page that also
-     * holds a chat in the light DOM, the scan answered with the WRONG chat, so the
-     * person's message AND the model's reply landed in a transcript they never typed
-     * into. Nearest tree first is what keeps it from swapping the other way round.
+     * root, so a chat mounted in one — the arrangement the theming guide endorses — is
+     * invisible to both: alone, the send would be dropped with a warning; on a page that
+     * also holds a chat in the light DOM, the scan would answer with the WRONG chat, and
+     * the person's message AND the model's reply would land in a transcript they never
+     * typed into. Nearest tree first keeps it from swapping the other way round.
      */
     private _rootsFor;
     /** The element an id names, looked up in the gesture's own tree before the document. */
@@ -442,8 +428,8 @@ export declare class AparteClient {
      * The SLICE is each caller's own business — retry cuts before the reply it is
      * regenerating, edit cuts after the message being reworded, send cuts at the last
      * answered turn. What a message CONTRIBUTES to the wire is not: send, retry and
-     * edit must not disagree about it, and they did. This one had no filter at all,
-     * so a failed turn and a turn stopped before its first token both went out as
+     * edit must not disagree about it. A failed turn and a turn stopped before its
+     * first token are filtered out rather than sent as
      * `{ role: 'assistant', content: '' }` — a claim the assistant said nothing, which
      * some providers reject outright and the rest read as an empty reply worth
      * imitating.
@@ -472,12 +458,12 @@ export declare class AparteClient {
      * the question the history gates can ask is "is this still in flight?", never
      * "is this completed?".
      *
-     * The gates below used to ask the second one, and a host that SEEDS a transcript
+     * The gates below ask the first, because a host that SEEDS a transcript
      * — restoring a saved conversation, hydrating a server-rendered one — has no
-     * reason to invent a status for turns that are already over. With none, the
-     * cutoff never advanced past 0 and the whole transcript was sliced away: the
-     * model got the new question with no context, and nothing in the UI said so,
-     * because the viewport still showed every message.
+     * reason to invent a status for turns that are already over. Asking "is this
+     * completed?" would leave the cutoff at 0 and slice away the whole transcript: the
+     * model would get the new question with no context, and nothing in the UI would say
+     * so, because the viewport still shows every message.
      */
     private static _inFlight;
     private _toHistoryMessages;
@@ -492,23 +478,9 @@ export declare class AparteClient {
      * What the model is told it said last turn — reconstructed from what was
      * RENDERED, not from the raw-text field.
      *
-     * The order used to be the other way round, and it silently corrupted the
-     * context on the most common opening in a coding chat: a reply starting with a
-     * code fence was sent back as three backticks and nothing else. Three
-     * correct-in-isolation decisions composed into it:
-     *
-     *  1. the parser withholds an ambiguous prefix (``` ``` ```, `` ` ``, `<`)
-     *     waiting for the next delta, and creates no active segment while it waits;
-     *  2. so `_streamLoop` sees zero segments, concludes the parser produced
-     *     nothing, and appends the raw delta straight to `message.content`;
-     *  3. and this method preferred `content`.
-     *
-     * The bubble hides its content element as soon as segments exist, so the UI was
-     * perfect and only the NEXT request showed it. No unit test, no example and
-     * no browser test could see it.
-     *
-     * `content` stays as the fallback, and that is not vestigial: a non-streaming
-     * transport writes the whole reply there and creates no segments at all.
+     * The segments are what the reader saw, so they come first. `content` is the
+     * fallback, and that is not vestigial: a non-streaming transport writes the whole
+     * reply there and creates no segments at all.
      */
     private _extractText;
     /**
@@ -521,10 +493,9 @@ export declare class AparteClient {
      * A type core does not know — a registered block grammar's (an artifact, a
      * citation, a file), a consumer's custom segment — follows one rule: its
      * `content` if it has one, else its `fallback`, else nothing. Dropping such a
-     * segment made a document the model had just produced invisible on the very next
-     * turn, so it could not be asked to change the thing it had built; there used to
-     * be an `artifact` branch here for exactly that, and the rule is what replaces it
-     * now that the artifact is a plugin's type like any other.
+     * segment would make a document the model had just produced invisible on the very
+     * next turn, so it could not be asked to change the thing it had built. An artifact
+     * is a plugin's type like any other and follows this rule.
      *
      * `thinking` and `tool_call` stay out on purpose — the first is the model's own
      * scratchpad, and most APIs neither want it back nor bill for it kindly; the
@@ -597,6 +568,14 @@ export declare class AparteClient {
      * resume. A channel that CRASHES fails the turn, as it does for a run in the page.
      */
     private _answerDeferred;
+    /**
+     * Whether a browser tool a paused run asked for may run, decided as a run in the page
+     * decides it. With a host `approvalResolver`, the tool's own `needsApproval` says whether
+     * to ask and the resolver answers; without one, the approval policy and `needsApproval`
+     * rule (`ruleOnToolCall`) and the default channel asks. `null` when nothing gates the
+     * call, the decision when something did, `undefined` when nobody answered.
+     */
+    private _gateBrowserTool;
     /**
      * The ticket is spent the moment the resume leaves: the server answers these calls
      * now, so a pause saved from here on — the conversation manager saves before it cuts a
@@ -608,8 +587,8 @@ export declare class AparteClient {
      * Close the reply's calls that can no longer finish — paused, queued, or running on a
      * server the page stopped listening to: each says it stopped, and forgets the pause.
      * A cut connection carries none of their last events, so nothing else would: the rows
-     * spun, and a queued call kept its ticket, which a reload then resumed against a
-     * server that had moved on. By the reply's id, not the chat's head — a retry during
+     * would spin, and a queued call would keep its ticket, which a reload would then
+     * resume against a server that had moved on. By the reply's id, not the chat's head — a retry during
      * the wait moves the head. A run in the page ends every call itself: nothing to do.
      */
     private _closeOpenCalls;

package/dist/client/aparte-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aparte-client.d.ts","sourceRoot":"","sources":["../../src/client/aparte-client.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"aparte-client.d.ts","sourceRoot":"","sources":["../../src/client/aparte-client.ts"],"names":[],"mappings":"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"}

package/dist/client/stream-adapter.d.ts

@@ -3,18 +3,15 @@
  *
  * `@aparte/engine`'s `runStreamAgent` is the headless loop: it emits high-level,
  * DOM-free run events. This adapter is the other half — it turns each event into
- * the exact `targetElement.*` calls + CustomEvents that core's inline loop
- * performed, using the **real** `AparteStreamParser` and tool renderers. So
- * `runStreamAgent` (engine, pure Node) + this adapter (core, DOM) reproduce that
- * loop byte-for-byte — and have replaced it (audit 2026-08-28, D1).
+ * the `targetElement.*` calls + CustomEvents the transcript needs, using the
+ * **real** `AparteStreamParser` and tool renderers. `runStreamAgent` (engine, pure
+ * Node) + this adapter (core, DOM) are the one agent loop `AparteClient` runs.
  *
  * DEPENDENCY DIRECTION: `@aparte/core` depends on `@aparte/engine` — first-party, so
  * the zero-third-party-dependency promise is untouched — never the reverse. The
  * run-event contract is engine's: {@link AparteStreamRunEvent} and its siblings below
  * are `StreamRunEvent` & co under core's names, so there is nothing to keep in sync by
- * hand any more. The hand-mirrored union this file used to carry, and the compile-time
- * guard in engine that policed it, went with the mirror (audit 2026-08-28, D1). A
- * consumer wires a runner through `AparteClientOptions.streamRunner` — the same
+ * hand. A consumer wires a runner through `AparteClientOptions.streamRunner` — the same
  * pattern as `approvalResolver` (HITL).
  */
 import type { AparteConfig } from '../config/aparte-config.js';
@@ -24,7 +21,7 @@ import type { StreamRunEvent, StreamRunEmitter, StreamRunOptions, StreamUsage }
 /**
  * The DOM-free run events `@aparte/engine`'s `runStreamAgent` emits — engine's
  * `StreamRunEvent`, under core's name. See `packages/engine/src/agent/stream-events.ts`
- * for the per-event `_streamLoop` mapping notes.
+ * for the per-event documentation.
  */
 export type AparteStreamRunEvent = StreamRunEvent;
 /** Synchronous, ordered event sink — engine's `StreamRunEmitter`. */
@@ -42,11 +39,8 @@ export type AparteStreamRunOptions = StreamRunOptions;
  * — the seam by which a host wraps or replaces the loop `AparteClient` runs,
  * which is `@aparte/engine`'s `runStreamAgent` by default.
  *
- * `runStreamAgent` IS this type — pass it, do not cast it. An earlier version of this
- * comment advised a cast "if the duck-typed shapes don't line up", which is how the
- * two packages' message types drifted apart unnoticed and shipped a
- * `streamRunner: runStreamAgent` that did not compile on five docs pages and a
- * README. The alias makes that drift a typecheck error in the composition itself.
+ * `runStreamAgent` IS this type — pass it, do not cast it. The alias makes any drift
+ * between the two packages' message types a typecheck error in the composition itself.
  */
 export type AparteStreamRunner = (opts: AparteStreamRunOptions) => Promise<StreamUsage | undefined>;
 /**

package/dist/client/stream-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream-adapter.d.ts","sourceRoot":"","sources":["../../src/client/stream-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAKzF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAKtG;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG,cAAc,CAAC;AAElD,qEAAqE;AACrE,MAAM,MAAM,sBAAsB,GAAG,gBAAgB,CAAC;AAEtD;;;;;;GAMG;AACH,MAAM,MAAM,sBAAsB,GAAG,gBAAgB,CAAC;AAEtD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,IAAI,EAAE,sBAAsB,KAAK,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAAC;AAEpG;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAChC,aAAa,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC;IAClE,iBAAiB,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IAC1E,UAAU,CAAC,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAAC;IAC1C,aAAa,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC;IACzE,QAAQ,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;IAChD,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC;CACxC;AAED,MAAM,WAAW,0BAA0B;IACvC,4DAA4D;IAC5D,MAAM,EAAE,mBAAmB,CAAC;IAC5B,kEAAkE;IAClE,MAAM,EAAE,YAAY,CAAC;IACrB,qEAAqE;IACrE,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,0BAA0B,GAAG,sBAAsB,CAmN5F;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACnC,MAAM,EAAE,cAAc,CAAC,iBAAiB,CAAC,EACzC,MAAM,EAAE,WAAW,GACpB,aAAa,CAAC,iBAAiB,CAAC,CAkClC"}
+{"version":3,"file":"stream-adapter.d.ts","sourceRoot":"","sources":["../../src/client/stream-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAKzF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAMtG;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG,cAAc,CAAC;AAElD,qEAAqE;AACrE,MAAM,MAAM,sBAAsB,GAAG,gBAAgB,CAAC;AAEtD;;;;;;GAMG;AACH,MAAM,MAAM,sBAAsB,GAAG,gBAAgB,CAAC;AAEtD;;;;;;;GAOG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,IAAI,EAAE,sBAAsB,KAAK,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAAC;AAEpG;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAChC,aAAa,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC;IAClE,iBAAiB,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IAC1E,UAAU,CAAC,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAAC;IAC1C,aAAa,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC;IACzE,QAAQ,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;IAChD,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC;CACxC;AAED,MAAM,WAAW,0BAA0B;IACvC,4DAA4D;IAC5D,MAAM,EAAE,mBAAmB,CAAC;IAC5B,kEAAkE;IAClE,MAAM,EAAE,YAAY,CAAC;IACrB,qEAAqE;IACrE,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,0BAA0B,GAAG,sBAAsB,CA2N5F;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACnC,MAAM,EAAE,cAAc,CAAC,iBAAiB,CAAC,EACzC,MAAM,EAAE,WAAW,GACpB,aAAa,CAAC,iBAAiB,CAAC,CAkClC"}

package/dist/client/wire-history.d.ts

@@ -1,11 +1,10 @@
 /**
  * What one message contributes to the history a turn sends — its tool calls included.
  *
- * The history used to carry user and assistant TEXT only, so a tool's result was on
- * screen and gone from the model's context one turn later: "what did the file say?" had
- * no answer. A reply now goes out in the order it was shown: the text before some calls
- * and those calls as an assistant envelope, each call's answer as a `tool` message, the
- * text after them as the next envelope.
+ * A reply goes out in the order it was shown, so a tool's result stays in the model's
+ * context on later turns: the text before some calls and those calls as an assistant
+ * envelope, each call's answer as a `tool` message, the text after them as the next
+ * envelope.
  *
  * Every call is answered, because a provider rejects a request that declares a call
  * with no `tool` message after it: a refusal sends its reason, a crash its error line,

package/dist/client/wire-history.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wire-history.d.ts","sourceRoot":"","sources":["../../src/client/wire-history.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAEhH,6DAA6D;AAC7D,eAAO,MAAM,iBAAiB,6CAA6C,CAAC;AAE5E,0GAA0G;AAC1G,eAAO,MAAM,eAAe,iCAAiC,CAAC;AAU9D,gGAAgG;AAChG,eAAO,MAAM,cAAc,YAAa,aAAa,KAAG,OAAO,IAAI,qBAGkE,CAAC;AAEtI;;;;GAIG;AACH,wBAAgB,SAAS,CACrB,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,CAAC,QAAQ,EAAE,aAAa,EAAE,KAAK,MAAM,EAC7C,OAAO,GAAE;IACL;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACrB,GACP,iBAAiB,EAAE,CA2CrB"}
+{"version":3,"file":"wire-history.d.ts","sourceRoot":"","sources":["../../src/client/wire-history.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAEhH,6DAA6D;AAC7D,eAAO,MAAM,iBAAiB,6CAA6C,CAAC;AAE5E,0GAA0G;AAC1G,eAAO,MAAM,eAAe,iCAAiC,CAAC;AAU9D,gGAAgG;AAChG,eAAO,MAAM,cAAc,YAAa,aAAa,KAAG,OAAO,IAAI,qBAGkE,CAAC;AAEtI;;;;GAIG;AACH,wBAAgB,SAAS,CACrB,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,CAAC,QAAQ,EAAE,aAAa,EAAE,KAAK,MAAM,EAC7C,OAAO,GAAE;IACL;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACrB,GACP,iBAAiB,EAAE,CA2CrB"}