jeopi-agent-core 16.2.13 → 16.2.14

package/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## [Unreleased]
 
+## [16.2.14] - 2026-07-02
+
 ### Added
 
 - Added support for Anthropic fallback content blocks in agent-loop assistant messages, ensuring they are preserved across session persistence and event fanout.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "jeopi-agent-core",
-	"version": "16.2.13",
+	"version": "16.2.14",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"homepage": "https://github.com/akillness/jeopi",
 	"author": "Can Boluk",
@@ -35,18 +35,18 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"jeopi-ai": "16.2.13",
-		"jeopi-catalog": "16.2.13",
-		"jeopi-natives": "16.2.13",
-		"jeopi-utils": "16.2.13",
-		"jeopi-wire": "16.2.13",
-		"jeopi-snapcompact": "16.2.13",
-		"@opentelemetry/api": "^1.9.1"
+		"jeopi-ai": "catalog:",
+		"jeopi-catalog": "catalog:",
+		"jeopi-natives": "catalog:",
+		"jeopi-utils": "catalog:",
+		"jeopi-wire": "catalog:",
+		"jeopi-snapcompact": "catalog:",
+		"@opentelemetry/api": "catalog:"
 	},
 	"devDependencies": {
-		"@opentelemetry/context-async-hooks": "^2.7.1",
-		"@opentelemetry/sdk-trace-base": "^2.7.1",
-		"@types/bun": "^1.3.14"
+		"@opentelemetry/context-async-hooks": "catalog:",
+		"@opentelemetry/sdk-trace-base": "catalog:",
+		"@types/bun": "catalog:"
 	},
 	"engines": {
 		"bun": ">=1.3.14"

package/dist/types/agent-loop.d.ts

@@ -1,66 +0,0 @@
-/**
- * Agent loop that works with AgentMessage throughout.
- * Transforms to Message[] only at the LLM call boundary.
- */
-import { type Context, EventStream } from "jeopi-ai";
-import { type Dialect } from "jeopi-ai/dialect";
-import { type AgentRunCoverage, type AgentRunSummary } from "./run-collector";
-import type { AgentContext, AgentEvent, AgentLoopConfig, AgentMessage, StreamFn } from "./types";
-/** Stop-details marker for a provider error after assistant content/tool args already streamed. */
-export declare const STREAM_INTERRUPTED_AFTER_CONTENT_STOP_DETAIL = "stream_interrupted_after_content";
-export declare function resolveOwnedDialectFromEnv(value: string | undefined): Dialect | undefined;
-/**
- * Start an agent loop with a new prompt message.
- * The prompt is added to the context and events are emitted for it.
- */
-export declare function agentLoop(prompts: AgentMessage[], context: AgentContext, config: AgentLoopConfig, signal?: AbortSignal, streamFn?: StreamFn): EventStream<AgentEvent, AgentMessage[]>;
-/**
- * Continue an agent loop from the current context without adding a new message.
- * Used for retries - context already has user message or tool results.
- *
- * **Important:** The last message in context must convert to a `user` or `toolResult` message
- * via `convertToLlm`. If it doesn't, the LLM provider will reject the request.
- * This cannot be validated here since `convertToLlm` is only called once per turn.
- */
-export declare function agentLoopContinue(context: AgentContext, config: AgentLoopConfig, signal?: AbortSignal, streamFn?: StreamFn): EventStream<AgentEvent, AgentMessage[]>;
-/**
- * Detailed-result handle returned by {@link agentLoopDetailed}. Adds the
- * run-level telemetry/coverage rollup to the existing `AgentMessage[]`
- * payload without changing the resolved type of `stream.result()`.
- */
-export interface AgentLoopDetailedResult {
-    readonly messages: AgentMessage[];
-    readonly telemetry: AgentRunSummary | undefined;
-    readonly coverage: AgentRunCoverage | undefined;
-}
-/**
- * Convenience wrapper over {@link agentLoop} that exposes the run-level
- * summary + coverage alongside the messages. The returned `stream` is the
- * same `EventStream` callers already consume; `detailed()` awaits the
- * stream's `agent_end` event and returns the additive fields.
- *
- * Existing `stream.result()` semantics are preserved — it still resolves to
- * `AgentMessage[]`. Use {@link agentLoopDetailed} when you need the rollup;
- * use {@link agentLoop} when you do not.
- */
-export declare function agentLoopDetailed(prompts: AgentMessage[], context: AgentContext, config: AgentLoopConfig, signal?: AbortSignal, streamFn?: StreamFn): {
-    readonly stream: EventStream<AgentEvent, AgentMessage[]>;
-    readonly detailed: () => Promise<AgentLoopDetailedResult>;
-};
-/**
- * Like {@link agentLoopDetailed} but built on top of
- * {@link agentLoopContinue}.
- */
-export declare function agentLoopContinueDetailed(context: AgentContext, config: AgentLoopConfig, signal?: AbortSignal, streamFn?: StreamFn): {
-    readonly stream: EventStream<AgentEvent, AgentMessage[]>;
-    readonly detailed: () => Promise<AgentLoopDetailedResult>;
-};
-export declare function normalizeMessagesForProvider(messages: Context["messages"], model: AgentLoopConfig["model"]): Context["messages"];
-export declare function normalizeTools(tools: AgentContext["tools"], injectIntent: boolean, exampleDialect?: Dialect, pruneDescriptions?: boolean): Context["tools"];
-/** Resolve the human-readable reason an abort carried. A caller that aborts via
- *  `AbortController.abort(reason)` with a string or a non-`AbortError` `Error`
- *  (e.g. the coding agent's user-interrupt label) gets that text surfaced on the
- *  synthesized assistant message's `errorMessage`; a bare `abort()` (whose
- *  `signal.reason` is the default `AbortError` `DOMException`) falls back to the
- *  generic sentinel that downstream renderers treat as "no specific reason". */
-export declare function abortReasonText(signal: AbortSignal | undefined): string;

package/dist/types/agent.d.ts

@@ -1,427 +0,0 @@
-import { type ApiKey, type AssistantMessage, type AssistantMessageEvent, type Context, type CursorExecHandlers, type CursorToolResultHandler, type Effort, type ImageContent, type Message, type Model, type ProviderSessionState, type ServiceTier, type SimpleStreamOptions, type ThinkingBudgets, type ToolChoice } from "jeopi-ai";
-import type { Dialect } from "jeopi-ai/dialect";
-import type { HarmonyAuditEvent } from "jeopi-ai/utils/harmony-leak";
-import type { AppendOnlyContextManager } from "./append-only-context";
-import type { AgentEvent, AgentLoopConfig, AgentMessage, AgentState, AgentTool, AgentToolContext, AgentTurnEndContext, AsideMessage, StreamFn, ToolCallContext, ToolChoiceDirective } from "./types";
-export declare class AgentBusyError extends Error {
-    constructor(message?: string);
-}
-export interface AgentOptions {
-    initialState?: Partial<AgentState>;
-    /**
-     * Converts AgentMessage[] to LLM-compatible Message[] before each LLM call.
-     * Default filters to user/assistant/toolResult and converts attachments.
-     */
-    convertToLlm?: (messages: AgentMessage[]) => Message[] | Promise<Message[]>;
-    /**
-     * Optional transform applied to context before convertToLlm.
-     * Use for context pruning, injecting external context, etc.
-     */
-    transformContext?: (messages: AgentMessage[], signal?: AbortSignal) => Promise<AgentMessage[]>;
-    /**
-     * Optional transform applied after provider context assembly and before
-     * telemetry capture/provider send.
-     */
-    transformProviderContext?: (context: Context, model: Model) => Context | Promise<Context>;
-    /**
-     * Steering mode: "all" = send all steering messages at once, "one-at-a-time" = one per turn
-     */
-    steeringMode?: "all" | "one-at-a-time";
-    /**
-     * Follow-up mode: "all" = send all follow-up messages at once, "one-at-a-time" = one per turn
-     */
-    followUpMode?: "all" | "one-at-a-time";
-    /**
-     * When to interrupt tool execution for steering messages.
-     * - "immediate": check after each tool call (default)
-     * - "wait": defer steering until the current turn completes
-     */
-    interruptMode?: "immediate" | "wait";
-    /**
-     * API format for Kimi Code provider: "openai" or "anthropic" (default: "anthropic")
-     */
-    kimiApiFormat?: "openai" | "anthropic";
-    /** Hint that websocket transport should be preferred when supported by the provider implementation. */
-    preferWebsockets?: boolean;
-    /**
-     * Custom stream function (for proxy backends, etc.). Default uses streamSimple.
-     */
-    streamFn?: StreamFn;
-    /** Absolute wall-clock deadline in Unix epoch milliseconds. */
-    deadline?: number;
-    /**
-     * Optional session identifier forwarded to LLM providers.
-     * Used by providers that support session-based caching (e.g., OpenAI Codex).
-     */
-    sessionId?: string;
-    /**
-     * Optional prompt cache key forwarded to LLM providers.
-     * When omitted, providers may fall back to sessionId.
-     */
-    promptCacheKey?: string;
-    /**
-     * Shared provider state map for session-scoped transport/session caches.
-     */
-    providerSessionState?: Map<string, ProviderSessionState>;
-    /**
-     * Resolves an API key or resolver dynamically for each LLM call.
-     * Useful for expiring tokens and model-scoped credential routing.
-     */
-    getApiKey?: (model: Model) => Promise<ApiKey | undefined> | ApiKey | undefined;
-    /**
-     * Inspect or replace provider payloads before they are sent.
-     */
-    onPayload?: SimpleStreamOptions["onPayload"];
-    /**
-     * Inspect provider response metadata after headers arrive and before streaming body consumption.
-     */
-    onResponse?: SimpleStreamOptions["onResponse"];
-    /**
-     * Inspect raw Server-Sent Events from HTTP streaming providers.
-     */
-    onSseEvent?: SimpleStreamOptions["onSseEvent"];
-    /**
-     * Inspect assistant streaming events before they are emitted to subscribers.
-     * Use this when abort decisions must happen before buffered events continue flowing.
-     */
-    onAssistantMessageEvent?: (message: AssistantMessage, event: AssistantMessageEvent) => void;
-    /**
-     * Called when GPT-5 Harmony protocol leakage is detected and mitigated.
-     */
-    onHarmonyLeak?: (event: HarmonyAuditEvent) => void | Promise<void>;
-    /**
-     * Custom token budgets for thinking levels (token-based providers only).
-     */
-    thinkingBudgets?: ThinkingBudgets;
-    /**
-     * Sampling temperature for LLM calls. `undefined` uses provider default.
-     */
-    temperature?: number;
-    /** Additional sampling controls for providers that support them. */
-    topP?: number;
-    topK?: number;
-    minP?: number;
-    presencePenalty?: number;
-    repetitionPenalty?: number;
-    serviceTier?: ServiceTier;
-    /**
-     * Per-call effective service-tier resolver. When set, it authoritatively
-     * supplies the request's tier (replacing the static `serviceTier` and its
-     * telemetry) per model — used to scope a provider/model into a priority
-     * serving path without mutating the shared session `serviceTier`.
-     */
-    serviceTierResolver?: (model: Model) => ServiceTier | undefined;
-    /**
-     * If true, request that the underlying provider omit reasoning/thinking summaries
-     * from the response. The model still reasons internally; only the human-readable
-     * summary stream is suppressed. Useful when the UI hides thinking blocks anyway.
-     */
-    hideThinkingSummary?: boolean;
-    /**
-     * Maximum delay in milliseconds to wait for a retry when the server requests a long wait.
-     * If the server's requested delay exceeds this value, the request fails immediately,
-     * allowing higher-level retry logic to handle it with user visibility.
-     * Default: 60000 (60 seconds). Set to 0 to disable the cap.
-     */
-    maxRetryDelayMs?: number;
-    /**
-     * Provides tool execution context, resolved per tool call.
-     * Use for late-bound UI or session state access.
-     */
-    getToolContext?: (toolCall?: ToolCallContext) => AgentToolContext | undefined;
-    /**
-     * Optional transform applied to tool call arguments before execution.
-     * Use for deobfuscating secrets or rewriting arguments.
-     */
-    transformToolCallArguments?: (args: Record<string, unknown>, toolName: string) => Record<string, unknown>;
-    /** Enable intent tracing schema injection/stripping in the harness. */
-    intentTracing?: boolean;
-    /**
-     * Strip tool descriptions from provider-bound tool specs (top-level + nested
-     * schema annotations). Use when the full catalog is rendered into the system
-     * prompt so descriptions are not duplicated on the wire. Native tool calling only.
-     */
-    pruneToolDescriptions?: boolean;
-    /** Owned tool-calling dialect. Undefined keeps provider-native tool calling. */
-    dialect?: Dialect;
-    /**
-     * When owned tool calling is active and the model fabricates a tool result
-     * mid-turn: `true` (default) aborts the provider request immediately; `false`
-     * drains the request and discards the fabricated continuation. Forwarded to
-     * the loop's {@link AgentLoopConfig.abortOnFabricatedToolResult}.
-     */
-    abortOnFabricatedToolResult?: boolean;
-    /** Dynamic tool-choice directive (hard {@link ToolChoice} or {@link SoftToolRequirement}), resolved once per turn. */
-    getToolChoice?: () => ToolChoiceDirective | undefined;
-    /**
-     * Cursor exec handlers for local tool execution.
-     */
-    cursorExecHandlers?: CursorExecHandlers;
-    /**
-     * Cursor tool result callback for exec tool responses.
-     */
-    cursorOnToolResult?: CursorToolResultHandler;
-    /** Current working directory used by local tool execution. */
-    cwd?: string;
-    /**
-     * Resolver for the live working directory, re-read on every turn. When set, it
-     * overrides the static {@link cwd} at config-build time so a session move
-     * (`/move`, which updates the host's cwd without reconstructing the Agent) is
-     * reflected in provider options — e.g. GitLab Duo Agent namespace/project
-     * discovery keys off this cwd's git remote. Falls back to `cwd` when it returns
-     * `undefined`.
-     */
-    cwdResolver?: () => string | undefined;
-    /**
-     * Called after a tool call has been validated and is about to execute.
-     * See {@link AgentLoopConfig.beforeToolCall} for full semantics.
-     */
-    beforeToolCall?: AgentLoopConfig["beforeToolCall"];
-    /**
-     * Called after a tool finishes executing, before `tool_execution_end` and the tool-result
-     * message are emitted. See {@link AgentLoopConfig.afterToolCall} for full semantics.
-     */
-    afterToolCall?: AgentLoopConfig["afterToolCall"];
-    /**
-     * Called once an assistant message is finalized, before it reaches the
-     * context, the UI, or tool dispatch. May mutate the message in place (text +
-     * tool-call arguments). See {@link AgentLoopConfig.transformAssistantMessage}.
-     */
-    transformAssistantMessage?: AgentLoopConfig["transformAssistantMessage"];
-    /**
-     * Opt-in OpenTelemetry instrumentation. Passing `{}` enables the loop's
-     * GenAI-semantic-convention spans using the global tracer provider. See
-     * {@link AgentLoopConfig.telemetry} for the full surface.
-     */
-    telemetry?: AgentLoopConfig["telemetry"];
-    /**
-     * Immutable context mode — stabilizes system prompt + tool spec bytes
-     * across turns so DeepSeek/Anthropic prefix caches hit at maximum rate.
-     */
-    appendOnlyContext?: AppendOnlyContextManager;
-}
-export interface AgentPromptOptions {
-    toolChoice?: ToolChoice;
-}
-export declare class Agent {
-    #private;
-    streamFn: StreamFn;
-    getApiKey?: (model: Model) => Promise<ApiKey | undefined> | ApiKey | undefined;
-    /**
-     * Hook invoked after tool arguments are validated and before execution.
-     * Reassign at any time to swap the implementation (e.g. on extension reload).
-     */
-    beforeToolCall?: AgentLoopConfig["beforeToolCall"];
-    /**
-     * Hook invoked after tool execution and before `tool_execution_end` / tool-result
-     * message emission. Reassign at any time to swap the implementation.
-     */
-    afterToolCall?: AgentLoopConfig["afterToolCall"];
-    /**
-     * Hook invoked once an assistant message is finalized, before context append,
-     * UI emission, and tool dispatch. Reassign at any time to swap the implementation.
-     */
-    transformAssistantMessage?: AgentLoopConfig["transformAssistantMessage"];
-    /**
-     * Hook that peeks whether interrupting IRC asides are queued for the next boundary.
-     */
-    hasIrcInterrupts?: AgentLoopConfig["hasIrcInterrupts"];
-    constructor(opts?: AgentOptions);
-    /**
-     * Get the current session ID used for provider caching.
-     */
-    get sessionId(): string | undefined;
-    /**
-     * Set the session ID for provider caching.
-     * Call this when switching sessions (new session, branch, resume).
-     */
-    set sessionId(value: string | undefined);
-    /**
-     * Get the prompt cache key forwarded to providers.
-     */
-    get promptCacheKey(): string | undefined;
-    /**
-     * Set the prompt cache key forwarded to providers.
-     */
-    set promptCacheKey(value: string | undefined);
-    /**
-     * Static metadata forwarded to every API request when no resolver is installed
-     * (e.g. `metadata.user_id` for Anthropic session attribution). Setting this
-     * clears any installed resolver.
-     *
-     * For live/provider-aware metadata (e.g. Anthropic OAuth `account_uuid` that
-     * must reflect the credential selected per-request), use
-     * {@link setMetadataResolver} and read via {@link metadataForProvider}.
-     */
-    get metadata(): Record<string, unknown> | undefined;
-    set metadata(value: Record<string, unknown> | undefined);
-    /**
-     * Resolve request metadata for the given provider at call time. When a
-     * resolver is installed via {@link setMetadataResolver}, it is invoked with
-     * the provider string so the result can be scoped (e.g. `account_uuid` is
-     * only included for `"anthropic"` requests). Falls back to the static
-     * {@link metadata} value when no resolver is set.
-     */
-    metadataForProvider(provider: string): Record<string, unknown> | undefined;
-    /**
-     * Install a function that resolves request metadata at call time. The
-     * resolver receives the target provider string and can gate provider-specific
-     * fields (e.g. `account_uuid` only for `"anthropic"`). Invoked per LLM
-     * request by `agent-loop` after `getApiKey` selects the session-sticky
-     * credential. Pass `undefined` to clear and revert to the static
-     * {@link metadata} value.
-     */
-    setMetadataResolver(resolver: ((provider: string) => Record<string, unknown> | undefined) | undefined): void;
-    /**
-     * Read the active OpenTelemetry configuration. Returns `undefined` when
-     * instrumentation is disabled. Callers spawning child runs (e.g. subagent
-     * dispatch) forward this to the child's loop so its spans appear under the
-     * parent's active context with the subagent's own identity stamped.
-     */
-    get telemetry(): AgentLoopConfig["telemetry"] | undefined;
-    /**
-     * Replace the active OpenTelemetry configuration. Pass `undefined` to
-     * disable instrumentation. Applies to the *next* `agentLoop` invocation —
-     * in-flight loops keep the configuration they started with.
-     */
-    setTelemetry(telemetry: AgentLoopConfig["telemetry"] | undefined): void;
-    /**
-     * Get provider-scoped mutable session state store.
-     */
-    get providerSessionState(): Map<string, ProviderSessionState> | undefined;
-    /**
-     * Set provider-scoped mutable session state store.
-     */
-    set providerSessionState(value: Map<string, ProviderSessionState> | undefined);
-    /**
-     * Get the current thinking budgets.
-     */
-    get thinkingBudgets(): ThinkingBudgets | undefined;
-    /**
-     * Set custom thinking budgets for token-based providers.
-     */
-    set thinkingBudgets(value: ThinkingBudgets | undefined);
-    /**
-     * Get the current sampling temperature.
-     */
-    get temperature(): number | undefined;
-    /**
-     * Set sampling temperature for LLM calls. `undefined` uses provider default.
-     */
-    set temperature(value: number | undefined);
-    get topP(): number | undefined;
-    set topP(value: number | undefined);
-    get topK(): number | undefined;
-    set topK(value: number | undefined);
-    get minP(): number | undefined;
-    set minP(value: number | undefined);
-    get presencePenalty(): number | undefined;
-    set presencePenalty(value: number | undefined);
-    get repetitionPenalty(): number | undefined;
-    set repetitionPenalty(value: number | undefined);
-    get serviceTier(): ServiceTier | undefined;
-    set serviceTier(value: ServiceTier | undefined);
-    get serviceTierResolver(): ((model: Model) => ServiceTier | undefined) | undefined;
-    set serviceTierResolver(value: ((model: Model) => ServiceTier | undefined) | undefined);
-    get hideThinkingSummary(): boolean | undefined;
-    set hideThinkingSummary(value: boolean | undefined);
-    /**
-     * Get the current max retry delay in milliseconds.
-     */
-    get maxRetryDelayMs(): number | undefined;
-    /**
-     * Set the maximum delay to wait for server-requested retries.
-     * Set to 0 to disable the cap.
-     */
-    set maxRetryDelayMs(value: number | undefined);
-    get state(): AgentState;
-    get appendOnlyContext(): AppendOnlyContextManager | undefined;
-    setAppendOnlyContext(manager?: AppendOnlyContextManager): void;
-    /**
-     * Assemble the provider Context for a side-channel (no-loop) request, mirroring
-     * the main loop's prefix (system + normalized tools) so it shares the prompt
-     * cache. Never touches the append-only log or the tool-choice queue. Owned/
-     * in-band dialect sessions stay tools-less (matching their no-native-tools wire
-     * shape and avoiding tool-markup leakage). `llmMessages` is already converted
-     * (and, in production, obfuscated) by the caller.
-     *
-     * `systemPrompt` defaults to the live agent prompt so the side request hits the
-     * same cached prefix as the main loop. Callers that must pin a different prompt
-     * (e.g. handoff generation, which uses the base prompt rather than a per-turn
-     * `before_agent_start` hook override) pass it explicitly.
-     */
-    buildSideRequestContext(llmMessages: Message[], systemPrompt?: string[]): Promise<Context>;
-    subscribe(fn: (e: AgentEvent) => void): () => void;
-    setProviderResponseInterceptor(fn: SimpleStreamOptions["onResponse"] | undefined): void;
-    setRawSseEventInterceptor(fn: SimpleStreamOptions["onSseEvent"] | undefined): void;
-    setAssistantMessageEventInterceptor(fn: ((message: AssistantMessage, event: AssistantMessageEvent) => void) | undefined): void;
-    setOnBeforeYield(fn: (() => Promise<void> | void) | undefined): void;
-    setOnTurnEnd(fn: ((messages: AgentMessage[], signal?: AbortSignal, context?: AgentTurnEndContext) => Promise<void> | void) | undefined): void;
-    /**
-     * Provide a source of non-interrupting "aside" messages (e.g. background-job
-     * completions, late LSP diagnostics) drained at each step boundary. Never
-     * aborts in-flight tools. See `AgentLoopConfig.getAsideMessages`.
-     */
-    setAsideMessageProvider(fn: (() => AsideMessage[] | Promise<AsideMessage[]>) | undefined): void;
-    emitExternalEvent(event: AgentEvent): void;
-    setSystemPrompt(v: string[] | string): void;
-    setModel(m: Model): void;
-    setThinkingLevel(l: Effort | undefined): void;
-    setDisableReasoning(disabled: boolean): void;
-    setSteeringMode(mode: "all" | "one-at-a-time"): void;
-    getSteeringMode(): "all" | "one-at-a-time";
-    setFollowUpMode(mode: "all" | "one-at-a-time"): void;
-    getFollowUpMode(): "all" | "one-at-a-time";
-    setInterruptMode(mode: "immediate" | "wait"): void;
-    getInterruptMode(): "immediate" | "wait";
-    setTools(t: AgentTool<any>[]): void;
-    replaceMessages(ms: AgentMessage[]): void;
-    replaceQueues(steering: AgentMessage[], followUp: AgentMessage[]): void;
-    appendMessage(m: AgentMessage): void;
-    popMessage(): AgentMessage | undefined;
-    /**
-     * Queue a steering message to interrupt the agent mid-run.
-     * Delivered after current tool execution, skips remaining tools.
-     */
-    steer(m: AgentMessage): void;
-    /**
-     * Queue a follow-up message to be processed after the agent finishes.
-     * Delivered only when agent has no more tool calls or steering messages.
-     */
-    followUp(m: AgentMessage): void;
-    clearSteeringQueue(): void;
-    clearFollowUpQueue(): void;
-    clearAllQueues(): void;
-    hasQueuedMessages(): boolean;
-    /** Non-consuming view of the pending steering queue (insertion order, newest
-     *  last). The session layer derives its queued-message display/count from
-     *  this live view instead of a mirror, so the agent-core queue stays the
-     *  single source of truth. */
-    peekSteeringQueue(): readonly AgentMessage[];
-    /** Non-consuming view of the pending follow-up queue. See
-     *  {@link peekSteeringQueue}. */
-    peekFollowUpQueue(): readonly AgentMessage[];
-    get isAborting(): boolean;
-    /**
-     * Remove and return the last steering message from the queue (LIFO).
-     * Used by dequeue keybinding.
-     */
-    popLastSteer(): AgentMessage | undefined;
-    /**
-     * Remove and return the last follow-up message from the queue (LIFO).
-     * Used by dequeue keybinding.
-     */
-    popLastFollowUp(): AgentMessage | undefined;
-    clearMessages(): void;
-    abort(reason?: unknown): void;
-    waitForIdle(): Promise<void>;
-    reset(): void;
-    /** Send a prompt with an AgentMessage */
-    prompt(message: AgentMessage | AgentMessage[], options?: AgentPromptOptions): Promise<void>;
-    prompt(input: string, options?: AgentPromptOptions): Promise<void>;
-    prompt(input: string, images?: ImageContent[], options?: AgentPromptOptions): Promise<void>;
-    /**
-     * Continue from current context (used for retries and resuming queued messages).
-     */
-    continue(): Promise<void>;
-}

package/dist/types/append-only-context.d.ts

@@ -1,133 +0,0 @@
-/**
- * Append-only context mode — stabilizes the byte prefix sent to the LLM
- * across turns so provider prefix caches (DeepSeek, Anthropic, etc.)
- * hit at the maximum possible rate.
- *
- * Two mechanisms:
- *
- * 1. **StablePrefix** — system prompt + tool specs are computed once
- *    and frozen. Subsequent turns reuse the exact same byte sequence
- *    unless `invalidate()` is called (e.g. after MCP reconnect).
- *
- * 2. **AppendOnlyLog** — messages only grow; prior turns are never
- *    re-serialized. Combined with a stable prefix, only the user's new
- *    message delta is a cache miss each turn.
- */
-import type { Context, Message, Tool } from "jeopi-ai";
-import type { Dialect } from "jeopi-ai/dialect";
-import type { AgentContext } from "./types";
-/** Frozen system prompt + tool spec snapshot. */
-export interface StablePrefixSnapshot {
-    systemPrompt: string[];
-    tools: Tool[];
-    fingerprint: string;
-}
-/** Options threaded through `build()` so the snapshot reflects loop-time settings. */
-export interface BuildOptions {
-    /** Inject the `i` intent field into tool schemas (must match agent-loop's normalizeTools). */
-    intentTracing: boolean;
-    exampleDialect?: Dialect;
-    /** Strip tool descriptions from the provider-bound specs (must match normalizeTools). */
-    pruneToolDescriptions?: boolean;
-}
-/**
- * A frozen prefix (system prompt + tools) that produces stable byte
- * sequences across `build()` calls.
- *
- * The first `build()` snapshots the live state. Subsequent calls reuse
- * the cached copy until `invalidate()` is called or the live state's
- * fingerprint changes.
- */
-export declare class StablePrefix {
-    #private;
-    get fingerprint(): string;
-    get version(): number;
-    get built(): boolean;
-    /**
-     * Build or rebuild from live context.
-     * Returns `true` if the prefix actually changed (cache miss imminent).
-     */
-    build(context: AgentContext, options: BuildOptions): boolean;
-    /** Force rebuild on the next `build()` call. */
-    invalidate(): void;
-    /**
-     * Returns the cached prefix.
-     * @throws if `build()` was never called.
-     */
-    toContext(): {
-        systemPrompt: string[];
-        tools: Tool[];
-    };
-}
-/**
- * Append-only message log at the `Message[]` (provider-level) layer.
- *
- * The only mutation path is `replaceTail()`, reserved for compaction.
- * Every other operation is append-only.
- */
-export declare class AppendOnlyLog {
-    #private;
-    get length(): number;
-    append(message: any): void;
-    extend(messages: any[]): void;
-    /** Replace the last entry — only legal for compaction. */
-    replaceTail(replacement: any): void;
-    /** Returns a shallow copy of all entries. */
-    toMessages(): Message[];
-    /** Direct readonly access for in-place inspection. */
-    entries(): readonly Message[];
-    /** Drop entries past index `count`, keeping the first `count` byte-stable.
-     * Used by {@link AppendOnlyContextManager.syncMessages} to preserve the
-     * already-on-the-wire prefix when a later message diverges. */
-    truncate(count: number): void;
-    clear(): void;
-}
-/**
- * Manages a stable prefix + append-only log for the agent loop.
- *
- * Call `build(context)` each turn to get a `Context` with stable
- * `systemPrompt` and `tools` and append-only messages. Call
- * `syncMessages(normalizedMessages)` after `convertToLlm` each
- * turn to keep the log in sync.
- *
- * Example:
- * ```
- * const mgr = new AppendOnlyContextManager();
- * const ctx = mgr.build(context);  // first call snapshots prefix
- * mgr.syncMessages(normalized);    // grow the log
- * ctx = mgr.build(context);        // subsequent calls use cache
- * ```
- */
-export declare class AppendOnlyContextManager {
-    #private;
-    readonly prefix: StablePrefix;
-    readonly log: AppendOnlyLog;
-    build(context: AgentContext, options: BuildOptions): Context;
-    /**
-     * Sync normalized (provider-level) messages into the append-only log.
-     *
-     * Three cases:
-     *
-     * 1. **Append**: same prefix, new tail → push the new entries.
-     * 2. **Compaction**: shorter array → clear the log and replay.
-     * 3. **In-place rewrite** (per-turn pruning, transformContext re-render,
-     *    image strip, etc.): find the longest byte-stable prefix between
-     *    the previously-synced messages and the new ones, drop the log
-     *    down to that prefix, then append the diverged tail. Earlier
-     *    revisions cleared the whole log on any digest change, which on
-     *    llama.cpp / local backends forced a full ~40k-token re-prefill
-     *    every turn that an extension, prune pass, or steering re-wrap
-     *    rewrote a single message (#3406). Preserving the stable prefix
-     *    lets the provider's KV cache stay warm up to the divergence
-     *    point — the model only re-prefills from the changed message on.
-     */
-    syncMessages(normalizedMessages: any[]): void;
-    /** Reset prefix + log for a model/provider switch while mode stays active. */
-    invalidateForModelChange(): void;
-    /** Reset the sync cursor AND clear the log. */
-    resetSyncCursor(): void;
-    appendMessage(message: any): void;
-    replaceTailMessage(message: any): void;
-    invalidate(): void;
-    reset(context: AgentContext, options: BuildOptions): void;
-}