@aparte/engine 0.2.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 aparté
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,20 @@
+# @aparte/engine
+
+The **headless agent loop** behind `@aparte/*` — framework-agnostic, zero runtime
+dependencies, runs in the browser or Node.
+
+Its core export is **`runStreamAgent`**: a DOM-free structured-stream loop that turns a
+transport's token stream into high-level run events (text, thinking, tool calls, artifacts),
+drives the tool-calling loop (with optional human-in-the-loop approval), and reports usage.
+
+`@aparte/core` embeds the same loop inline (`AparteClient._streamLoop`) so **core works
+without this package**. `@aparte/engine` is the *recommended path*: inject `runStreamAgent`
+via `AparteClientOptions.streamRunner` and core renders its events through
+`createStreamAdapter`. Parity between the two is proven by this package's `stream-parity`
+suite (it drives core's real `_streamLoop` and `runStreamAgent` against the same scripted
+transport and asserts identical output).
+
+`@aparte/core` is an **optional peer** — `runStreamAgent` and its parsers import nothing from
+it; the orchestrator/memory helpers use core's config/types when present.
+
+> Part of the [aparté](https://github.com/apartejs/aparte) monorepo. ESM-only.

package/dist/agent/parsers/artifact-xml-state-machine.d.ts

@@ -0,0 +1,86 @@
+/**
+ * artifact-xml-state-machine.ts — streaming `<artifact>` XML parser (pure).
+ *
+ * The framework-free extraction of the XML-artifact branch inside
+ * `AparteClient._streamLoop` (aparte-client.ts :1268-1392 + finalize :1658-1669).
+ * Small models emit artifacts as `…chat text… <artifact mimeType="…" title="…">
+ * BODY</artifact> …more text…`, streamed in arbitrary chunks that can split the
+ * opening tag, the body, or the closing tag across delta boundaries.
+ *
+ * This module owns only the PARSING (state + buffering); it emits DOM-free
+ * micro-events. The `@aparte/core` adapter turns them into segment/lifecycle calls
+ * (addSegment / updateSegment / _dispatchArtifactLifecycle) exactly as
+ * `_streamLoop` does — so no DOM, no `@aparte/core` import here.
+ *
+ * Ported faithfully, including quirks: a `<artifact` split as `<arti`+`fact`
+ * (so `indexOf('<artifact')` misses it) is treated as chat text, matching the
+ * source. Providers emit the tag atomically in practice.
+ */
+/** Where the streaming parser is between artifacts. */
+export type XmlArtifactState = 'normal' | 'scanning' | 'in-artifact';
+/** Fallback mime/kind for an artifact whose open tag omits the attribute. */
+export interface XmlArtifactHint {
+    mimeType: string;
+    kind: string;
+}
+/** DOM-free micro-events the machine emits; the adapter renders them. */
+export type XmlArtifactEvent = {
+    type: 'chat-text';
+    text: string;
+    reduced?: boolean;
+} | {
+    type: 'artifact-open';
+    id: string;
+    mimeType: string;
+    kind: string;
+    title: string;
+} | {
+    type: 'artifact-chunk';
+    id: string;
+    content: string;
+} | {
+    type: 'artifact-close';
+    id: string;
+    content: string;
+    inline: boolean;
+};
+/**
+ * Map an artifact mimeType to a renderer kind. Byte-identical copy of core's
+ * canonical `deriveArtifactKind` (parsers/aparte-stream-parser.ts) — the
+ * duplicate stays because `@aparte/core` is an OPTIONAL peer of the engine, so
+ * no runtime import is possible. Kept in sync mechanically by
+ * `__tests__/derive-artifact-kind-parity.test.ts`.
+ */
+export declare function deriveArtifactKind(mimeType: string, fallback?: string): string;
+/**
+ * A stateful streaming parser for one turn's `<artifact>` blocks. Feed it each
+ * text delta; drain the returned events. Call {@link finalize} when the stream
+ * ends to flush a truncated (unclosed) artifact.
+ */
+export declare class ArtifactXmlStateMachine {
+    private readonly hint;
+    private state;
+    /** Buffers the opening tag until its `>` arrives (may span deltas). */
+    private scanBuf;
+    /** Buffers the tail that might be the start of a split `</artifact>`. */
+    private closeBuf;
+    private segId;
+    private content;
+    private mime;
+    private kind;
+    private title;
+    private seq;
+    private readonly idGen;
+    constructor(hint: XmlArtifactHint, idGen?: () => string);
+    /** Feed one text delta; returns the ordered micro-events it produced. */
+    feed(delta: string): XmlArtifactEvent[];
+    /**
+     * Flush a truncated artifact: if the stream ended mid-body (model cut off
+     * before `</artifact>`), emit a close with whatever was buffered. Mirrors
+     * `_streamLoop`'s finalize block (:1658-1669).
+     */
+    finalize(): XmlArtifactEvent[];
+    /** Current parser state (for the adapter to decide finalize routing). */
+    get currentState(): XmlArtifactState;
+}
+//# sourceMappingURL=artifact-xml-state-machine.d.ts.map

package/dist/agent/parsers/artifact-xml-state-machine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-xml-state-machine.d.ts","sourceRoot":"","sources":["../../../src/agent/parsers/artifact-xml-state-machine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,uDAAuD;AACvD,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,UAAU,GAAG,aAAa,CAAC;AAErE,6EAA6E;AAC7E,MAAM,WAAW,eAAe;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,yEAAyE;AACzE,MAAM,MAAM,gBAAgB,GAMtB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GACtD;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACpF;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACvD;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,CAAC;AAO/E;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,SAAY,GAAG,MAAM,CAqBjF;AAED;;;;GAIG;AACH,qBAAa,uBAAuB;IAcpB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAbjC,OAAO,CAAC,KAAK,CAA8B;IAC3C,uEAAuE;IACvE,OAAO,CAAC,OAAO,CAAM;IACrB,yEAAyE;IACzE,OAAO,CAAC,QAAQ,CAAM;IACtB,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,OAAO,CAAM;IACrB,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,KAAK,CAAM;IACnB,OAAO,CAAC,GAAG,CAAK;IAChB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;gBAER,IAAI,EAAE,eAAe,EAAE,KAAK,CAAC,EAAE,MAAM,MAAM;IAIxE,yEAAyE;IACzE,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB,EAAE;IA4DvC;;;;OAIG;IACH,QAAQ,IAAI,gBAAgB,EAAE;IAY9B,yEAAyE;IACzE,IAAI,YAAY,IAAI,gBAAgB,CAEnC;CACJ"}

package/dist/agent/stream-events.contract.d.ts

@@ -0,0 +1,55 @@
+/**
+ * stream-events.contract.ts — COMPILE-TIME guard for the core↔engine run-event mirror.
+ *
+ * `StreamRunEvent` (this package) and `AparteStreamRunEvent` (@aparte/core's adapter)
+ * are hand-mirrored across the zero-import boundary: core is the zero-dep leaf and must
+ * never import engine, and engine keeps its stream contract standalone (see
+ * `stream-events.ts`). That leaves the two unions synced BY HAND — the seam's one
+ * unguarded soft spot. A silent drift here (a renamed/added variant, a changed payload
+ * field) would corrupt streaming with no CI signal.
+ *
+ * This file makes that drift a TYPECHECK ERROR. It ships nothing: it only declares
+ * type aliases (erased) and `import type`s core (erased → no runtime dep, so the
+ * runtime zero-import rule still holds; core is present as engine's dev/peer dep at
+ * typecheck time). It is not imported by the barrel, so it stays out of the bundle.
+ *
+ * The ONE intentional difference is `run-done.usage`: core carries the rich
+ * `AparteUsage` (named provider-timing fields — ttft/decode/phases/…), engine an
+ * opaque `StreamUsage` passthrough (five common fields + an index signature). We
+ * normalize that single field to compare the rest of the contract for EXACT equality,
+ * and separately assert the usage stays forwardable engine→core (the seam direction:
+ * core's adapter consumes engine's `run-done` and forwards its usage to `setUsage`).
+ */
+import type { AparteStreamRunEvent, AparteStreamRunEmitter } from '@aparte/core';
+import type { StreamRunEvent, StreamRunEmitter } from './stream-events.js';
+/** Invariant type-equality — distinguishes optional vs required and index signatures. */
+type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
+/** Compiles only when its argument is exactly `true`. */
+type Expect<T extends true> = T;
+/** Distributes over a union `A`: `true` iff every member is assignable to `B`. */
+type Assignable<A, B> = A extends B ? true : false;
+/** Erase the sole intentional difference (run-done.usage) before the equality check. */
+type NormalizeRunDone<E> = E extends {
+    type: 'run-done';
+} ? {
+    type: 'run-done';
+    usage?: unknown;
+} : E;
+/**
+ * Each element compiles only if its contract holds; a drift turns one into a
+ * `false`, which fails `Expect<...>` and breaks the typecheck. Exported so it isn't
+ * flagged as unused — this file is not re-exported by the barrel, so it never reaches
+ * `@aparte/engine`'s public surface.
+ *
+ * 1. Every variant except `run-done.usage` is structurally identical (exact equality).
+ * 2. The `run-done` usage stays forwardable engine→core (lets core's adapter treat it
+ *    as `AparteUsage`).
+ * 3. The emitter core injects into `runStreamAgent` satisfies engine's emitter contract.
+ */
+export type StreamEventContract = [
+    Expect<Equal<NormalizeRunDone<StreamRunEvent>, NormalizeRunDone<AparteStreamRunEvent>>>,
+    Expect<Assignable<StreamRunEvent, AparteStreamRunEvent>>,
+    Expect<Assignable<AparteStreamRunEmitter, StreamRunEmitter>>
+];
+export {};
+//# sourceMappingURL=stream-events.contract.d.ts.map

package/dist/agent/stream-events.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-events.contract.d.ts","sourceRoot":"","sources":["../../src/agent/stream-events.contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACjF,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3E,yFAAyF;AACzF,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC,IACX,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC;AACzF,yDAAyD;AACzD,KAAK,MAAM,CAAC,CAAC,SAAS,IAAI,IAAI,CAAC,CAAC;AAChC,kFAAkF;AAClF,KAAK,UAAU,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC;AAEnD,wFAAwF;AACxF,KAAK,gBAAgB,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,CAAC,CAAC;AAEtG;;;;;;;;;;GAUG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAC9B,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAAC,cAAc,CAAC,EAAE,gBAAgB,CAAC,oBAAoB,CAAC,CAAC,CAAC;IACvF,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,oBAAoB,CAAC,CAAC;IACxD,MAAM,CAAC,UAAU,CAAC,sBAAsB,EAAE,gBAAgB,CAAC,CAAC;CAC/D,CAAC"}

package/dist/agent/stream-events.d.ts

@@ -0,0 +1,209 @@
+/**
+ * stream-events.ts — contract for the framework-free structured-stream agent loop.
+ *
+ * `runStreamAgent` ({@link ./stream-run}) is the cloud-structured sibling of
+ * `runAgent` ({@link ./agent-loop}): where `runAgent` drives a text-only
+ * provider (`chat → string`, tool calls re-parsed from text), `runStreamAgent`
+ * consumes a **structured** `AsyncIterable<StreamChatEvent>` (text / thinking /
+ * tool_use / done / error) — the exact stream `AparteClient._streamLoop` reads
+ * today. It is the extraction target for that 700-line DOM-coupled loop.
+ *
+ * DOM stays out of here. The loop emits high-level {@link StreamRunEvent}s in the
+ * exact order `_streamLoop` performs its `targetElement.*` calls; a thin adapter
+ * (in `@aparte/core`, where the parser and renderers live) translates each event
+ * into the imperative viewport surface. So this module — and {@link ./stream-run}
+ * — import **nothing** from `@aparte/core`: the types below structurally mirror the
+ * core types (`AparteStreamEvent`, `AparteUsage`, `AparteChatMessage`, `AparteToolCall`)
+ * so the adapter passes the real objects through with zero runtime conversion.
+ *
+ * SCOPE: text · thinking · tool_use (+ HITL approval) · done · error · artifacts
+ * (raw / XML state machine / create_artifact) · multi-phase pipeline · synthetic
+ * toolChoice bypass. Code-fence promotion is the only `_streamLoop` mechanism
+ * left out here — it is adapter-side (it needs the core parser).
+ */
+/**
+ * Token usage. Structurally a superset-compatible mirror of `AparteUsage`: the
+ * five common fields plus an index signature that carries the provider-specific
+ * rest (ttft/decode/phases/…) opaquely — the loop transports usage, never reads
+ * past these five.
+ */
+export interface StreamUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens?: number;
+    cacheReadTokens?: number;
+    durationMs?: number;
+    [key: string]: unknown;
+}
+/** One tool call as surfaced by the provider stream (mirrors `AparteToolCall`). */
+export interface StreamToolCall {
+    id: string;
+    name: string;
+    input: unknown;
+}
+/**
+ * A structured stream event from the transport (mirrors `AparteStreamEvent`). The
+ * `tool_use` variant spreads {@link StreamToolCall} exactly like core's does.
+ */
+export type StreamChatEvent = {
+    type: 'text';
+    delta: string;
+} | {
+    type: 'thinking';
+    delta: string;
+} | {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: unknown;
+} | {
+    type: 'error';
+    message: string;
+} | {
+    type: 'done';
+    usage?: StreamUsage;
+};
+/**
+ * A conversation message (mirrors `AparteChatMessage`). `role` is left open
+ * (`string`) so the loop can push the `'tool_call'` / `'tool_result'` envelope
+ * roles `_streamLoop` uses without importing core's union.
+ */
+export interface StreamAgentMessage {
+    role: string;
+    content: string;
+    /** Present on a `'tool_call'` envelope — the whole turn's calls, grouped. */
+    toolCalls?: StreamToolCall[];
+    /** Present on a `'tool_result'` message — which call it answers. */
+    toolCallId?: string;
+    /** Assistant text that preceded the tool call(s) this turn. */
+    precedingText?: string;
+    [key: string]: unknown;
+}
+/** The request handed to the transport each turn (mirrors `AparteChatRequest`). */
+export interface StreamChatRequest {
+    messages: StreamAgentMessage[];
+    [key: string]: unknown;
+}
+/** A tool handler (mirrors the resolved `AparteToolHandler`). */
+export type StreamToolHandler = (call: StreamToolCall, signal: AbortSignal) => Promise<{
+    content: string;
+}>;
+/** Per-tool loop configuration (mirrors the `AparteTool` subset the loop reads). */
+export interface StreamToolConfig {
+    maxTurns?: number;
+    needsApproval?: boolean;
+}
+/**
+ * Resolves a human-in-the-loop approval (mirrors core's
+ * `AparteToolApprovalResolver`). Injected so the loop stays headless.
+ */
+export type StreamApprovalResolver = (toolCallId: string, signal: AbortSignal) => Promise<{
+    approved: boolean;
+    payload?: unknown;
+}>;
+/**
+ * High-level, DOM-free events isomorphic to `_streamLoop`'s `targetElement.*`
+ * call sequence. Emitted **synchronously and in order** (see {@link StreamRunEmitter})
+ * so the adapter reproduces the exact streaming update order.
+ *
+ * Mapping to `_streamLoop` (aparte-client.ts) for the adapter:
+ * - `run-start`       → updateMessage(status:'streaming') once at loop entry (the leading write before turn 1)
+ * - `turn-start`      → reset the per-turn parser / thinking / streaming-segment state (no DOM); one per turn
+ * - `text-delta`      → parser-driven addSegment/updateSegment, else typeName/updateLastMessage
+ * - `text-flush`      → textParser.finalize() then addSegment/updateSegment the finalized segments;
+ *                       one per turn, after the inner SSE loop ends (surfaced by the spike — a turn-boundary flush)
+ * - `thinking-delta`  → addSegment('thinking') then updateSegment(content); first `text-delta` after
+ *                       thinking collapses it (updateSegment collapsed:true)
+ * - `tool-start`      → renderer lookup + per-tool-name CSS inject into document.head + addSegment
+ * - `tool-awaiting-approval` → updateSegment('awaiting-approval') + dispatch `aparte-tool-approval-request`
+ * - `tool-approved`   → updateSegment('pending')
+ * - `tool-rejected`   → updateSegment('rejected', result)
+ * - `tool-resolved`   → updateSegment('resolved', result)
+ * - `tool-aborted`    → updateSegment('aborted') (no-handler path, timeout/abort path, or per-tool maxTurns path)
+ * - `turn-limit-exceeded` scope:'global' → addSegment(error 'MAX_TURNS_EXCEEDED');
+ *                         scope:'tool'   → updateSegment('aborted')
+ * - `phase-advance`   → addSegment({type:'pipeline-waiting'}); the loop has already
+ *                       pushed the phase's reply into history and bumped the phase index
+ * - `run-aborted`     → dispatch `aparte-message-aborted` (from the inner-loop abort check or the outer turn-boundary abort check)
+ * - `run-done`        → updateMessage(status:'completed') always + setUsage if usage
+ */
+export type StreamRunEvent = {
+    type: 'run-start';
+} | {
+    type: 'turn-start';
+} | {
+    type: 'text-delta';
+    delta: string;
+    reduced?: boolean;
+} | {
+    type: 'text-flush';
+} | {
+    type: 'thinking-delta';
+    delta: string;
+} | {
+    type: 'artifact-open';
+    id: string;
+    mimeType: string;
+    kind: string;
+    title: string;
+} | {
+    type: 'artifact-chunk';
+    id: string;
+    content: string;
+} | {
+    type: 'artifact-close';
+    id: string;
+    content: string;
+    inline: boolean;
+} | {
+    type: 'artifact-ready';
+    id: string;
+    mimeType: string;
+    kind: string;
+    title: string;
+    content: string;
+} | {
+    type: 'tool-start';
+    toolCallId: string;
+    name: string;
+    input: unknown;
+} | {
+    type: 'tool-awaiting-approval';
+    toolCallId: string;
+    name: string;
+    input: unknown;
+} | {
+    type: 'tool-approved';
+    toolCallId: string;
+} | {
+    type: 'tool-rejected';
+    toolCallId: string;
+    reason: string;
+} | {
+    type: 'tool-resolved';
+    toolCallId: string;
+    result: string;
+} | {
+    type: 'tool-aborted';
+    toolCallId: string;
+} | {
+    type: 'turn-limit-exceeded';
+    scope: 'global' | 'tool';
+    limit: number;
+    toolCallId?: string;
+} | {
+    type: 'phase-advance';
+    index: number;
+} | {
+    type: 'run-aborted';
+} | {
+    type: 'run-done';
+    usage?: StreamUsage;
+};
+/**
+ * Synchronous event sink — mirrors `AGUIEmitter`. Synchronous by contract: the
+ * loop must never yield between emitting an event and its ordered successor, or
+ * the adapter's streaming updates would interleave out of order.
+ */
+export type StreamRunEmitter = (event: StreamRunEvent) => void;
+//# sourceMappingURL=stream-events.d.ts.map

package/dist/agent/stream-events.d.ts.map

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

package/dist/agent/stream-run.d.ts

@@ -0,0 +1,59 @@
+/**
+ * stream-run.ts — framework-free structured-stream agent loop.
+ *
+ * The headless extraction of `AparteClient._streamLoop`: a `while(tool_use)` loop
+ * that consumes a structured `AsyncIterable<StreamChatEvent>` from a transport,
+ * runs approved tools, feeds their results back into the history, and re-calls
+ * the transport until the model stops asking for tools. It performs **no DOM
+ * work** — it emits {@link StreamRunEvent}s (in `_streamLoop`'s exact order) that
+ * an adapter in `@aparte/core` turns into `targetElement.*` calls.
+ *
+ * Parity target: `@aparte/core`'s `AparteClient._streamLoop`.
+ * Scope: text · thinking · tool_use (+ HITL) · done · error · artifacts (raw /
+ * XML / create_artifact) · multi-phase pipeline · synthetic toolChoice bypass.
+ * Code-fence promotion stays adapter-side (it needs the core parser).
+ */
+import type { StreamRunEmitter, StreamChatEvent, StreamChatRequest, StreamToolHandler, StreamToolConfig, StreamApprovalResolver, StreamUsage } from './stream-events.js';
+export interface StreamRunOptions {
+    /** Id of the assistant message being streamed (opaque; carried in events). */
+    messageId: string;
+    /** Turn-1 request; the loop clones its `messages` and enriches them per turn. */
+    baseRequest: StreamChatRequest;
+    /**
+     * Calls the transport with the (possibly enriched) request. Returns the
+     * structured stream, or a plain string for a non-streaming provider. Mirrors
+     * `getTransport().chat(provider, request, auth, ctx)` with provider/auth/ctx
+     * closed over by the adapter.
+     */
+    transportCall: (request: StreamChatRequest) => Promise<AsyncIterable<StreamChatEvent> | string>;
+    /** Resolves a tool's handler by name (mirrors `AparteConfig.getToolHandler`). */
+    toolLookup: (name: string) => StreamToolHandler | undefined;
+    /** Resolves a tool's loop config by name (maxTurns / needsApproval). */
+    toolConfigLookup?: (name: string) => StreamToolConfig | undefined;
+    /** HITL approval resolver for `needsApproval` tools (default: never called). */
+    approvalResolver?: StreamApprovalResolver;
+    /** Synchronous, ordered event sink consumed by the adapter. */
+    emitter: StreamRunEmitter;
+    /** Single abort signal composing `_isAborted` + the stream controller. */
+    signal: AbortSignal;
+    /** Global turn cap. @default 10 */
+    maxTurns?: number;
+    /** Per-tool-call handler timeout in ms. @default 300000 */
+    toolTimeoutMs?: number;
+    /**
+     * Generates artifact segment ids (`prefix` is e.g. `'artifact-raw'`). The
+     * default is a deterministic per-run counter; the adapter injects a
+     * crypto-based one to match `_streamLoop`'s `artifact-*-<uuid>`. (Tool ids
+     * still flow from the stream; only artifacts need generated ids.)
+     */
+    idGen?: (prefix: string) => string;
+}
+/**
+ * Run the structured-stream agent loop. Resolves the last turn's usage (the
+ * `done{usage}` last-write-wins, mirroring `_streamLoop`'s return), or
+ * `undefined`. Throws on a stream `error` event or a non-abort tool failure —
+ * the caller (adapter) routes that to its lifecycle-error handler, exactly as
+ * `_handleSend`/`_handleRetry`/`_handleEdit` catch `_streamLoop`.
+ */
+export declare function runStreamAgent(opts: StreamRunOptions): Promise<StreamUsage | undefined>;
+//# sourceMappingURL=stream-run.d.ts.map

package/dist/agent/stream-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-run.d.ts","sourceRoot":"","sources":["../../src/agent/stream-run.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EACR,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EAGjB,iBAAiB,EACjB,gBAAgB,EAChB,sBAAsB,EACtB,WAAW,EACd,MAAM,oBAAoB,CAAC;AAmB5B,MAAM,WAAW,gBAAgB;IAC7B,8EAA8E;IAC9E,SAAS,EAAE,MAAM,CAAC;IAClB,iFAAiF;IACjF,WAAW,EAAE,iBAAiB,CAAC;IAC/B;;;;;OAKG;IACH,aAAa,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,aAAa,CAAC,eAAe,CAAC,GAAG,MAAM,CAAC,CAAC;IAChG,iFAAiF;IACjF,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,iBAAiB,GAAG,SAAS,CAAC;IAC5D,wEAAwE;IACxE,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,gBAAgB,GAAG,SAAS,CAAC;IAClE,gFAAgF;IAChF,gBAAgB,CAAC,EAAE,sBAAsB,CAAC;IAC1C,+DAA+D;IAC/D,OAAO,EAAE,gBAAgB,CAAC;IAC1B,0EAA0E;IAC1E,MAAM,EAAE,WAAW,CAAC;IACpB,mCAAmC;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2DAA2D;IAC3D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;CACtC;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAmU7F"}

package/dist/conversation/compactor.d.ts

@@ -0,0 +1,175 @@
+/**
+ * conversation/compactor.ts — adaptive budgeting + context-window assembly.
+ *
+ * Conversation history budgeting and sliding-window assembly —
+ * framework-free and tokenizer-free (char-count heuristic).
+ *
+ * Pattern (cf. Claude Code /context, OpenAI Agents SDK TrimmingSession):
+ *   Budget = CONTEXT_WINDOW − systemPrompt − tools − reservedThinking
+ *                          − reservedGeneration − autocompactBuffer − safetyMargin
+ *
+ * The history budget is then split into:
+ *   - summary    (global summary, LLM-generated, ~10%)
+ *   - ragHist    (older turns retrieved by cosine similarity, ~25%)
+ *   - window     (verbatim sliding window, the rest)
+ *
+ * Drop priority on overflow:
+ *   1. summary    (async-regenerable)
+ *   2. ragHist    (retrievable on the next turn)
+ *   3. window oldest turns
+ *   X. NEVER dropped: currentUser + lastAssistant (absolute working memory)
+ *
+ * Browser-portable: zero deps, just an estimateTokens heuristic.
+ */
+export interface CompactionMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+}
+export interface RetrievedTurn {
+    role: 'user' | 'assistant';
+    content: string;
+    score?: number;
+}
+export interface CompactionConfig {
+    /** Total context window of the active model, in tokens. */
+    contextWindow: number;
+    /** Reserved budget for the model's thinking/reasoning block, in tokens. */
+    reservedThinking: number;
+    /** Reserved budget for the assistant response (max_new_tokens cap). */
+    reservedGeneration: number;
+    /** Fraction of context_window kept as autocompact buffer (0..1). */
+    autocompactBufferPct: number;
+    /** Hard safety margin in tokens. */
+    safetyMargin: number;
+    /** Floor for history budget — never compact below this. */
+    minHistoryBudget: number;
+    /** Ratio of history budget allocated to the summary block. */
+    summaryRatio: number;
+    /** Hard cap for summary tokens. */
+    summaryMaxTokens: number;
+    /** Ratio of history budget allocated to the RAG-retrieved old turns. */
+    ragHistRatio: number;
+    /** Hard cap for ragHist tokens. */
+    ragHistMaxTokens: number;
+    /** Trigger summarization once history usage reaches this % of the budget. */
+    triggerSummaryThresholdPct: number;
+    /** Re-run summarization every N user turns. */
+    summarizeEveryNTurns: number;
+    /** Header prepended to the summary block injected into the model context. English
+     *  by default — override to localise (the compactor ships no locale system). */
+    summaryLabel: string;
+    /** Header prepended to the RAG-retrieved old turns injected into the context. */
+    ragIntroLabel: string;
+}
+export interface BudgetBreakdown {
+    contextWindow: number;
+    systemPrompt: number;
+    tools: number;
+    reservedThinking: number;
+    reservedGeneration: number;
+    autocompactBuffer: number;
+    safetyMargin: number;
+    historyAvailable: number;
+}
+export interface BudgetResult {
+    historyBudget: number;
+    breakdown: BudgetBreakdown;
+    config: CompactionConfig;
+}
+export interface SplitBudget {
+    summary: number;
+    ragHist: number;
+    window: number;
+}
+export interface UsageBreakdown {
+    system: number;
+    summary: number;
+    ragHist: number;
+    window: number;
+}
+export interface DroppedBreakdown {
+    ragHits: number;
+    oldTurns: number;
+    summary: boolean;
+}
+export interface FullBreakdown extends BudgetBreakdown {
+    historyAllocated: SplitBudget;
+    historyUsed: UsageBreakdown;
+    totalUsed: number;
+    /** Free tokens left in the context window after all reservations + actual use. */
+    free: number;
+    dropped: DroppedBreakdown;
+}
+export interface CompactionInput {
+    messages: CompactionMessage[];
+    systemPrompt: string;
+    /** Tools array passed to apply_chat_template (or null/undefined when no tools). */
+    toolsArray?: unknown;
+    /** Running summary text (regenerable). */
+    summary?: string;
+    /** RAG-retrieved old turns (older than the sliding window). */
+    retrievedTurns?: RetrievedTurn[];
+    /** Partial override of the default config. */
+    config?: Partial<CompactionConfig>;
+}
+export interface CompactionResult {
+    compactedMessages: CompactionMessage[];
+    breakdown: FullBreakdown;
+}
+export declare const DEFAULT_COMPACTION_CONFIG: CompactionConfig;
+/**
+ * Token heuristic (FR ~3.5 chars/tok, EN ~4 chars/tok).
+ * Accurate to ±10% — enough for budgeting, and it avoids `tokenizer.encode()`,
+ * which costs ~5ms per message × N (too slow to run on every turn).
+ */
+export declare function estimateTokens(text: string | null | undefined): number;
+/**
+ * Estimate tokens for a JSON-serializable structure (e.g. tools array).
+ */
+export declare function estimateTokensJson(obj: unknown): number;
+/**
+ * Compute the available history budget after subtracting fixed costs.
+ */
+export declare function computeHistoryBudget(input: {
+    systemPrompt: string;
+    toolsArray?: unknown;
+    config?: Partial<CompactionConfig>;
+}): BudgetResult;
+/**
+ * Split history budget into summary / ragHist / window slots.
+ */
+export declare function splitHistoryBudget(historyBudget: number, cfg?: CompactionConfig): SplitBudget;
+interface AssembleParams {
+    messages: CompactionMessage[];
+    summary?: string;
+    retrievedTurns?: RetrievedTurn[];
+    windowBudget: number;
+    summaryBudget: number;
+    ragBudget: number;
+    systemContent?: string;
+    /** Context-injection headers; default to English (DEFAULT_COMPACTION_CONFIG). */
+    summaryLabel?: string;
+    ragIntroLabel?: string;
+}
+interface AssembleResult {
+    compactedMessages: CompactionMessage[];
+    used: UsageBreakdown;
+    dropped: DroppedBreakdown;
+}
+/**
+ * Assemble compacted message list given a budget and conversation state.
+ *
+ * Output order:
+ *   [system?] → [summary system msg?] → [ragHist system msg?] → window verbatim
+ *
+ * Always keeps the last 2 non-system messages verbatim (working memory),
+ * regardless of windowBudget — these are the floor that can never be dropped.
+ */
+export declare function assembleCompacted(params: AssembleParams): AssembleResult;
+/**
+ * Compute budget + assemble in one call. The primary entry point for
+ * consumers (a browser request interceptor, mobile, Node tests).
+ */
+export declare function compactConversation(input: CompactionInput): CompactionResult;
+export {};
+//# sourceMappingURL=compactor.d.ts.map

package/dist/conversation/compactor.d.ts.map

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