@arnilo/prism 0.0.8 → 0.0.11

package/dist/input.js

@@ -3,22 +3,12 @@ import { assertMessagesSupportModelCapabilities } from "./content.js";
 import { loadTextResource } from "./resources.js";
 import { composeSystemPrompt } from "./system-prompts.js";
 import { runInstructionInjectors } from "./instruction-injection.js";
+import { applyContextBudget, CONTEXT_BUDGET_REPORT_METADATA_KEY, } from "./context-budget.js";
 export function createDefaultInputBuilder() {
     return {
         name: "default-input",
         async build(input, context = {}) {
-            const groups = {
-                instructions: [
-                    ...instructionMessages(context.systemInstructions, "System instruction"),
-                    ...instructionMessages(context.developerInstructions, "Developer instruction"),
-                    ...customInstructionMessages(context.instructions),
-                ],
-                summaries: summaryMessages(context.summaries),
-                history: [...(context.history ?? [])],
-                input: inputMessages(input),
-                attachments: await attachmentMessages(context),
-                toolResults: toolResultMessages(context.toolResults),
-            };
+            const groups = await buildDefaultInputMessageGroups(input, context);
             const messages = flattenInputGroups(groups, context.inputLayout ?? "legacy");
             return context.middleware ? context.middleware.run("input_assembly", messages) : messages;
         },
@@ -65,7 +55,6 @@ export function renderPromptTemplate(template, variables, options = {}) {
     });
 }
 export async function assembleProviderInput(options) {
-    const inputBuilder = options.inputBuilder ?? createDefaultInputBuilder();
     const baseContext = {
         sessionId: options.sessionId,
         runId: options.runId,
@@ -92,44 +81,98 @@ export async function assembleProviderInput(options) {
         ? composeSystemPrompt(injectorContribs.instructions, { base: options.systemInstructions })
         : options.systemInstructions;
     const buildContext = { ...options, ...baseContext, systemInstructions };
-    const messages = await inputBuilder.build(options.input, buildContext);
-    const context = await resolveContextProviders({
-        providers: options.contextProviders,
-        messages,
-        injectedBlocks: injectorContribs.contextBlocks.length ? injectorContribs.contextBlocks : undefined,
-        middleware: options.middleware,
-        ...baseContext,
-    });
+    const layout = buildContext.inputLayout ?? "legacy";
+    let messages;
+    let context;
+    let skills = options.skills;
+    let tools = options.tools;
+    let budgetReport;
+    if (options.contextBudget) {
+        // ponytail: budget path always uses default groups so eviction kinds stay deterministic;
+        // custom inputBuilder still honored when contextBudget is absent.
+        const groups = await buildDefaultInputMessageGroups(options.input, buildContext);
+        context = await resolveContextProviders({
+            providers: options.contextProviders,
+            messages: flattenInputGroups(groups, layout),
+            injectedBlocks: injectorContribs.contextBlocks.length ? injectorContribs.contextBlocks : undefined,
+            middleware: options.middleware,
+            ...baseContext,
+        });
+        const applied = applyContextBudget({
+            groups,
+            context,
+            skills: skills ?? [],
+            tools,
+            budget: options.contextBudget,
+            layout,
+        });
+        messages = flattenInputGroups(applied.groups, layout);
+        if (buildContext.middleware)
+            messages = await buildContext.middleware.run("input_assembly", messages);
+        context = applied.context;
+        skills = applied.skills;
+        tools = applied.tools;
+        if (options.contextBudget.reportOmissions)
+            budgetReport = applied.report;
+    }
+    else {
+        const inputBuilder = options.inputBuilder ?? createDefaultInputBuilder();
+        messages = await inputBuilder.build(options.input, buildContext);
+        context = await resolveContextProviders({
+            providers: options.contextProviders,
+            messages,
+            injectedBlocks: injectorContribs.contextBlocks.length ? injectorContribs.contextBlocks : undefined,
+            middleware: options.middleware,
+            ...baseContext,
+        });
+    }
     const promptBuilder = options.promptBuilder ?? createDefaultPromptBuilder();
     const promptRequest = options.middleware
         ? await options.middleware.run("prompt_build", {
             messages,
             context,
-            skills: options.skills,
-            tools: options.tools,
+            skills,
+            tools,
             metadata: options.metadata,
             signal: options.signal,
         })
         : {
             messages,
             context,
-            skills: options.skills,
-            tools: options.tools,
+            skills,
+            tools,
             metadata: options.metadata,
             signal: options.signal,
         };
-    const providerMessages = await promptBuilder.build({ ...promptRequest, tools: options.tools });
+    const providerMessages = await promptBuilder.build({ ...promptRequest, tools });
     assertMessagesSupportModelCapabilities(options.model, providerMessages);
+    const metadata = budgetReport
+        ? { ...options.metadata, [CONTEXT_BUDGET_REPORT_METADATA_KEY]: budgetReport }
+        : options.metadata;
     return {
         model: options.model,
         messages: providerMessages,
-        tools: options.tools,
+        tools,
         context,
         options: options.providerOptions,
-        metadata: options.metadata,
+        metadata,
         signal: options.signal,
     };
 }
+async function buildDefaultInputMessageGroups(input, context) {
+    return {
+        instructions: [
+            ...instructionMessages(context.systemInstructions, "System instruction"),
+            ...instructionMessages(context.developerInstructions, "Developer instruction"),
+            ...customInstructionMessages(context.instructions),
+        ],
+        summaries: summaryMessages(context.summaries),
+        history: [...(context.history ?? [])],
+        input: inputMessages(input),
+        attachments: await attachmentMessages(context),
+        toolResults: toolResultMessages(context.toolResults),
+    };
+}
 function flattenInputGroups(groups, layout) {
     switch (layout) {
         case "cache_aware":

package/dist/node/session-store-jsonl.js

@@ -1,6 +1,6 @@
 import { mkdir, readFile, appendFile } from "node:fs/promises";
 import { dirname } from "node:path";
-import { SESSION_APPEND_CONFLICT_CODE, SessionAppendConflictError, isSessionEntryKind, SESSION_ENTRY_SCHEMA_VERSION } from "../contracts.js";
+import { SESSION_APPEND_CONFLICT_CODE, SessionAppendConflictError, SessionSearchUnsupportedError, isSessionEntryKind, SESSION_ENTRY_SCHEMA_VERSION, } from "../contracts.js";
 import { isNodeErrorCode } from "./config.js";
 export function createJsonlSessionStore(pathOrOptions) {
     const options = typeof pathOrOptions === "string" ? { path: pathOrOptions, createDirectory: true } : pathOrOptions;
@@ -46,6 +46,9 @@ export function createJsonlSessionStore(pathOrOptions) {
         async get(id) {
             return findEntry(path, id);
         },
+        async searchSessions() {
+            throw new SessionSearchUnsupportedError("JSONL session store does not support searchSessions");
+        },
     };
 }
 /** Read a JSONL session file and return both valid entries and per-line parse errors. */

package/dist/provider-events.d.ts

@@ -15,3 +15,5 @@ export declare function providerUsage(usage: Usage): ProviderEvent;
 export declare function providerDone(usage?: Usage): ProviderEvent;
 export declare function providerError(error: unknown, secrets?: readonly (string | undefined)[]): ProviderEvent;
 export declare function toolCallContent(id: string, name: string, args?: JsonObject): ToolCallContent;
+/** Build a tool call from streamed arguments text; malformed JSON becomes a blocked call (no throw). */
+export declare function toolCallFromArgumentsText(id: string, name: string, argumentsText: string): ToolCallContent;

package/dist/provider-events.js

@@ -1,3 +1,4 @@
+import { ProviderTransportError, tryParseJsonObjectArguments } from "./providers/transport.js";
 import { errorToErrorInfo } from "./redaction.js";
 export function providerTextDelta(text) {
     return { type: "content_delta", content: { type: "text", text } };
@@ -32,9 +33,10 @@ export function reconstructToolCallDeltas(events) {
         partials.set(event.index, partial);
     }
     return [...partials.entries()].sort(([a], [b]) => a - b).map(([index, partial]) => {
-        if (!partial.id || !partial.name)
-            throw new Error(`Incomplete tool call delta at index ${index}`);
-        return toolCallContent(partial.id, partial.name, parseToolCallArguments(partial.argumentsText, index));
+        if (!partial.id || !partial.name) {
+            throw new ProviderTransportError("incomplete_delta", `Incomplete tool call delta at index ${index}`);
+        }
+        return toolCallFromArgumentsText(partial.id, partial.name, partial.argumentsText);
     });
 }
 export function providerUsage(usage) {
@@ -50,15 +52,21 @@ export function providerError(error, secrets = []) {
 export function toolCallContent(id, name, args = {}) {
     return { type: "tool_call", id, name, arguments: args };
 }
-function parseToolCallArguments(text, index) {
-    try {
-        const value = text ? JSON.parse(text) : {};
-        if (!value || typeof value !== "object" || Array.isArray(value))
-            throw new Error("not object");
-        return value;
-    }
-    catch (error) {
-        throw new Error(`Invalid tool call arguments at index ${index}: ${error instanceof Error ? error.message : String(error)}`);
-    }
+/** Build a tool call from streamed arguments text; malformed JSON becomes a blocked call (no throw). */
+export function toolCallFromArgumentsText(id, name, argumentsText) {
+    const parsed = tryParseJsonObjectArguments(argumentsText, { toolName: name });
+    if (parsed.ok)
+        return toolCallContent(id, name, parsed.value);
+    return {
+        type: "tool_call",
+        id,
+        name,
+        arguments: {},
+        argumentsError: {
+            name: parsed.error.name,
+            message: parsed.error.message,
+            code: parsed.error.code,
+        },
+    };
 }
 //# sourceMappingURL=provider-events.js.map

package/dist/providers/openai-compatible.js

@@ -1,7 +1,7 @@
 import { resolveCredentialValue } from "../credentials.js";
-import { providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, toolCallContent, } from "../provider-events.js";
+import { providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, toolCallFromArgumentsText, } from "../provider-events.js";
 import { assertOpenAIChatMessage, applyOpenAIChatStructuredOutput, mapOpenAIChatUsage, serializeOpenAIChatMessage, serializeOpenAITool, } from "./openai-primitives.js";
-import { parseJsonObjectArguments, readBoundedResponseText, readSseData, } from "./transport.js";
+import { ProviderTransportError, readBoundedResponseText, readSseData, } from "./transport.js";
 import { assertStructuredOutputRequestSupported } from "../structured-output.js";
 export function createOpenAICompatibleProvider(options) {
     const providerId = options.id ?? "openai-compatible";
@@ -64,10 +64,13 @@ export function createOpenAICompatibleProvider(options) {
                         }
                     }
                 }
+                const incomplete = [...tools.entries()].find(([, call]) => !call.id || !call.name);
+                if (incomplete) {
+                    yield providerError(new ProviderTransportError("incomplete_delta", `Incomplete tool call delta at index ${incomplete[0]}`), secrets);
+                    return;
+                }
                 for (const call of tools.values()) {
-                    if (call.id && call.name) {
-                        yield providerToolCall(toolCallContent(call.id, call.name, parseJsonObjectArguments(call.argumentsText, { toolName: call.name })));
-                    }
+                    yield providerToolCall(toolCallFromArgumentsText(call.id, call.name, call.argumentsText));
                 }
                 yield providerDone();
             }

package/dist/providers/transport.d.ts

@@ -14,7 +14,7 @@ export interface SseEvent {
     readonly data: string;
     readonly comments?: readonly string[];
 }
-export type ProviderTransportErrorCode = "sse_buffer_overflow" | "sse_event_overflow" | "response_body_overflow" | "aborted" | "invalid_json_arguments";
+export type ProviderTransportErrorCode = "sse_buffer_overflow" | "sse_event_overflow" | "response_body_overflow" | "aborted" | "invalid_json_arguments" | "incomplete_delta";
 export declare class ProviderTransportError extends Error {
     readonly code: ProviderTransportErrorCode;
     readonly limitBytes?: number;
@@ -36,5 +36,14 @@ export declare function readSseEvents(body: ReadableStream<Uint8Array>, options?
 export declare function readSseData(body: ReadableStream<Uint8Array>, options?: ReadSseEventsOptions): AsyncGenerator<string>;
 /** Read a response body with a hard byte ceiling; redacts optional secrets. */
 export declare function readBoundedResponseText(response: Response, options?: ReadBoundedResponseTextOptions): Promise<string>;
+export type ParseJsonObjectArgumentsResult = {
+    readonly ok: true;
+    readonly value: JsonObject;
+} | {
+    readonly ok: false;
+    readonly error: ProviderTransportError;
+};
+/** Parse streamed tool arguments without throwing; prefer this for recoverable tool-call recovery. */
+export declare function tryParseJsonObjectArguments(text: string, options?: ParseJsonObjectArgumentsOptions): ParseJsonObjectArgumentsResult;
 /** Parse streamed tool arguments as a JSON object; throws {@link ProviderTransportError} on invalid input. */
 export declare function parseJsonObjectArguments(text: string, options?: ParseJsonObjectArgumentsOptions): JsonObject;

package/dist/providers/transport.js

@@ -197,25 +197,41 @@ export async function readBoundedResponseText(response, options) {
         }
     }
 }
-/** Parse streamed tool arguments as a JSON object; throws {@link ProviderTransportError} on invalid input. */
-export function parseJsonObjectArguments(text, options) {
+/** Parse streamed tool arguments without throwing; prefer this for recoverable tool-call recovery. */
+export function tryParseJsonObjectArguments(text, options) {
     const maxBytes = options?.maxBytes ?? DEFAULT_MAX_ARGUMENT_BYTES;
     const suffix = options?.toolName ? ` for tool ${options.toolName}` : "";
     if (!text)
-        return {};
+        return { ok: true, value: {} };
     if (byteLength(text) > maxBytes) {
-        throw new ProviderTransportError("invalid_json_arguments", `Tool arguments${suffix} exceeded ${maxBytes} bytes`, maxBytes);
+        return {
+            ok: false,
+            error: new ProviderTransportError("invalid_json_arguments", `Tool arguments${suffix} exceeded ${maxBytes} bytes`, maxBytes),
+        };
     }
     let parsed;
     try {
         parsed = JSON.parse(text);
     }
-    catch (error) {
-        throw new ProviderTransportError("invalid_json_arguments", `Invalid tool arguments JSON${suffix}`);
+    catch {
+        return {
+            ok: false,
+            error: new ProviderTransportError("invalid_json_arguments", `Invalid tool arguments JSON${suffix}`),
+        };
     }
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        throw new ProviderTransportError("invalid_json_arguments", `Tool arguments${suffix} must be a JSON object`);
+        return {
+            ok: false,
+            error: new ProviderTransportError("invalid_json_arguments", `Tool arguments${suffix} must be a JSON object`),
+        };
     }
-    return parsed;
+    return { ok: true, value: parsed };
+}
+/** Parse streamed tool arguments as a JSON object; throws {@link ProviderTransportError} on invalid input. */
+export function parseJsonObjectArguments(text, options) {
+    const result = tryParseJsonObjectArguments(text, options);
+    if (!result.ok)
+        throw result.error;
+    return result.value;
 }
 //# sourceMappingURL=transport.js.map

package/dist/rpc.js

@@ -82,8 +82,19 @@ async function handleRequest(request, state, stdout, activeRuns) {
             activeRuns.set(session.id, { requestId: request.id, promise });
             break;
         }
-        case "steer":
-            throw new Error("steer is not supported by the current AgentSession runtime");
+        case "steer": {
+            const input = stringParam(request.params, "input") ?? stringParam(request.params, "prompt");
+            if (!input)
+                throw new Error("steer requires params.input");
+            const softInterrupt = request.params?.softInterrupt === true;
+            state.current.steer(input, softInterrupt ? { softInterrupt: true } : undefined);
+            write(stdout, {
+                id: request.id,
+                ok: true,
+                result: { sessionId: state.current.id },
+            });
+            break;
+        }
         case "abort":
             state.current.abort(stringParam(request.params, "reason"));
             write(stdout, { id: request.id, ok: true, result: { sessionId: state.current.id } });

package/dist/session-stores.d.ts

@@ -1,4 +1,4 @@
-import type { Message, SessionBranchRead, BranchReader, SessionEntry, SessionStore } from "./contracts.js";
+import { type Message, type SessionBranchRead, type BranchReader, type SessionEntry, type SessionStore } from "./contracts.js";
 export interface CreateSessionEntryOptions extends Omit<SessionEntry, "id" | "timestamp"> {
     readonly id?: string;
     readonly timestamp?: string;
@@ -24,4 +24,9 @@ export declare function getSessionBranchEntries(entries: readonly SessionEntry[]
 export declare function listSessionBranches(entries: readonly SessionEntry[]): readonly SessionBranch[];
 export declare function rebuildSessionContext(reader: BranchReader, query: SessionBranchRead): Promise<SessionContextSnapshot>;
 export declare function rebuildSessionContext(entries: readonly SessionEntry[], options?: SessionBranchOptions): SessionContextSnapshot;
-export declare function createMemorySessionStore(initialEntries?: readonly SessionEntry[]): SessionStore;
+export type MemorySessionSearchMode = "linear" | "unsupported";
+export interface CreateMemorySessionStoreOptions {
+    /** Default `"linear"`: capped in-process scan. `"unsupported"`: typed throw. */
+    readonly sessionSearchMode?: MemorySessionSearchMode;
+}
+export declare function createMemorySessionStore(initialEntries?: readonly SessionEntry[], options?: CreateMemorySessionStoreOptions): SessionStore;

package/dist/session-stores.js

@@ -1,4 +1,4 @@
-import { SESSION_APPEND_CONFLICT_CODE, SessionAppendConflictError } from "./contracts.js";
+import { DEFAULT_MAX_SESSION_SEARCH_LINEAR_BYTES, DEFAULT_MAX_SESSION_SEARCH_LINEAR_ENTRIES, DEFAULT_MAX_SESSION_SEARCH_LINEAR_SESSIONS, DEFAULT_MAX_SESSION_SEARCH_SNIPPET_BYTES, SESSION_APPEND_CONFLICT_CODE, SESSION_SEARCH_WORKSPACE_METADATA_KEY, SessionAppendConflictError, SessionSearchUnsupportedError, resolveSessionSearchQuery, } from "./contracts.js";
 import { createId } from "./ids.js";
 export function createSessionEntry(options) {
     const { createId, now, ...entry } = options;
@@ -93,16 +93,17 @@ function rebuildSessionContextCore(entries, options = {}) {
     }
     return { leafId: branch.at(-1)?.id, entries: branch, messages, summaries };
 }
-export function createMemorySessionStore(initialEntries = []) {
+export function createMemorySessionStore(initialEntries = [], options = {}) {
     const byId = new Map();
     const bySession = new Map();
     const leafBySession = new Map();
     const idempotencySeen = new Set();
+    const mode = options.sessionSearchMode ?? "linear";
     for (const entry of initialEntries)
         add(entry);
     return {
-        async append(entry, options) {
-            add(entry, options);
+        async append(entry, appendOptions) {
+            add(entry, appendOptions);
         },
         async list(sessionId) {
             return (bySession.get(sessionId) ?? []).map(cloneEntry);
@@ -111,6 +112,11 @@ export function createMemorySessionStore(initialEntries = []) {
             const entry = byId.get(id);
             return entry ? cloneEntry(entry) : undefined;
         },
+        async searchSessions(query) {
+            if (mode === "unsupported")
+                throw new SessionSearchUnsupportedError();
+            return searchMemorySessionsLinear(bySession, leafBySession, query);
+        },
     };
     function add(entry, options) {
         // ponytail: idempotency dedup keyed on (session, key, expectedParentId) so a
@@ -146,6 +152,170 @@ export function createMemorySessionStore(initialEntries = []) {
         leafBySession.set(entry.sessionId, entry.id);
     }
 }
+function searchMemorySessionsLinear(bySession, leafBySession, query) {
+    const q = resolveSessionSearchQuery(query);
+    q.signal?.throwIfAborted();
+    let sessionsScanned = 0;
+    let entriesScanned = 0;
+    let bytesScanned = 0;
+    const matches = [];
+    for (const [sessionId, entries] of bySession) {
+        if (sessionsScanned >= DEFAULT_MAX_SESSION_SEARCH_LINEAR_SESSIONS)
+            break;
+        if (entriesScanned >= DEFAULT_MAX_SESSION_SEARCH_LINEAR_ENTRIES)
+            break;
+        if (bytesScanned >= DEFAULT_MAX_SESSION_SEARCH_LINEAR_BYTES)
+            break;
+        q.signal?.throwIfAborted();
+        sessionsScanned += 1;
+        let updatedAt = "";
+        let label;
+        let summary;
+        let workspaceRoot;
+        let tenantId;
+        let accountId;
+        let userId;
+        let matchedLabel = false;
+        let matchedSummary = false;
+        let matchedQuery = false;
+        let matchedProvider = false;
+        let matchedModel = false;
+        let snippetSource;
+        for (const entry of entries) {
+            if (entriesScanned >= DEFAULT_MAX_SESSION_SEARCH_LINEAR_ENTRIES)
+                break;
+            if (bytesScanned >= DEFAULT_MAX_SESSION_SEARCH_LINEAR_BYTES)
+                break;
+            entriesScanned += 1;
+            const text = entrySearchText(entry);
+            bytesScanned += utf8Bytes(text) + utf8Bytes(entry.label) + utf8Bytes(entry.summary);
+            if (entry.timestamp > updatedAt)
+                updatedAt = entry.timestamp;
+            if (entry.label)
+                label = entry.label;
+            if (entry.summary)
+                summary = entry.summary;
+            const meta = entry.metadata;
+            if (meta) {
+                if (typeof meta[SESSION_SEARCH_WORKSPACE_METADATA_KEY] === "string") {
+                    workspaceRoot = meta[SESSION_SEARCH_WORKSPACE_METADATA_KEY];
+                }
+                if (typeof meta.tenantId === "string")
+                    tenantId = meta.tenantId;
+                if (typeof meta.accountId === "string")
+                    accountId = meta.accountId;
+                if (typeof meta.userId === "string")
+                    userId = meta.userId;
+            }
+            if (q.label && entry.label?.includes(q.label))
+                matchedLabel = true;
+            if (q.summary && entry.summary?.includes(q.summary))
+                matchedSummary = true;
+            if (q.query) {
+                const hay = `${entry.label ?? ""}\n${entry.summary ?? ""}\n${text}`;
+                if (hay.includes(q.query)) {
+                    matchedQuery = true;
+                    snippetSource ??= entry.label ?? entry.summary ?? text;
+                }
+            }
+            if (q.provider && (entry.model?.provider === q.provider || metaProvider(entry) === q.provider))
+                matchedProvider = true;
+            if (q.model && entry.model?.model === q.model)
+                matchedModel = true;
+        }
+        if (q.workspaceRoot && workspaceRoot !== q.workspaceRoot)
+            continue;
+        if (q.tenantId && tenantId !== q.tenantId)
+            continue;
+        if (q.accountId && accountId !== q.accountId)
+            continue;
+        if (q.userId && userId !== q.userId)
+            continue;
+        if (q.label && !matchedLabel)
+            continue;
+        if (q.summary && !matchedSummary)
+            continue;
+        if (q.query && !matchedQuery)
+            continue;
+        if (q.provider && !matchedProvider)
+            continue;
+        if (q.model && !matchedModel)
+            continue;
+        if (q.fromUpdatedAt && updatedAt < q.fromUpdatedAt)
+            continue;
+        if (q.toUpdatedAt && updatedAt > q.toUpdatedAt)
+            continue;
+        matches.push({
+            sessionId,
+            leafId: leafBySession.get(sessionId),
+            updatedAt: updatedAt || undefined,
+            label,
+            summary,
+            snippet: clipSnippet(snippetSource ?? label ?? summary),
+            metadata: workspaceRoot !== undefined ? { [SESSION_SEARCH_WORKSPACE_METADATA_KEY]: workspaceRoot } : undefined,
+        });
+    }
+    matches.sort((a, b) => compareSearchHit(a, b, q.order));
+    const afterCursor = q.cursor ? decodeSearchCursor(q.cursor) : undefined;
+    const filtered = afterCursor
+        ? matches.filter((hit) => isAfterSearchCursor(hit, afterCursor, q.order))
+        : matches;
+    const page = filtered.slice(0, q.limit);
+    const last = page.at(-1);
+    return {
+        items: page,
+        nextCursor: filtered.length > q.limit && last?.updatedAt
+            ? encodeSearchCursor(last.updatedAt, last.sessionId)
+            : undefined,
+    };
+}
+function entrySearchText(entry) {
+    if (!entry.message?.content)
+        return "";
+    const parts = [];
+    for (const block of entry.message.content) {
+        if (block.type === "text" && typeof block.text === "string")
+            parts.push(block.text);
+    }
+    return parts.join("\n");
+}
+function metaProvider(entry) {
+    const value = entry.metadata?.provider;
+    return typeof value === "string" ? value : undefined;
+}
+function utf8Bytes(value) {
+    return value ? new TextEncoder().encode(value).byteLength : 0;
+}
+function clipSnippet(value) {
+    if (!value)
+        return undefined;
+    const encoded = new TextEncoder().encode(value);
+    if (encoded.byteLength <= DEFAULT_MAX_SESSION_SEARCH_SNIPPET_BYTES)
+        return value;
+    return new TextDecoder().decode(encoded.slice(0, DEFAULT_MAX_SESSION_SEARCH_SNIPPET_BYTES));
+}
+function encodeSearchCursor(updatedAt, sessionId) {
+    return `${updatedAt}\t${sessionId}`;
+}
+function decodeSearchCursor(cursor) {
+    const tab = cursor.indexOf("\t");
+    if (tab <= 0 || tab === cursor.length - 1)
+        throw new TypeError("SessionSearchQuery.cursor is invalid");
+    return { updatedAt: cursor.slice(0, tab), sessionId: cursor.slice(tab + 1) };
+}
+function compareSearchHit(a, b, order) {
+    const aAt = a.updatedAt ?? "";
+    const bAt = b.updatedAt ?? "";
+    const cmp = aAt < bAt ? -1 : aAt > bAt ? 1 : a.sessionId < b.sessionId ? -1 : a.sessionId > b.sessionId ? 1 : 0;
+    return order === "asc" ? cmp : -cmp;
+}
+function isAfterSearchCursor(hit, cursor, order) {
+    const at = hit.updatedAt ?? "";
+    if (order === "asc") {
+        return at > cursor.updatedAt || (at === cursor.updatedAt && hit.sessionId > cursor.sessionId);
+    }
+    return at < cursor.updatedAt || (at === cursor.updatedAt && hit.sessionId < cursor.sessionId);
+}
 function cloneEntry(entry) {
     return structuredClone(entry);
 }

package/dist/structured-output.d.ts

@@ -1,4 +1,4 @@
-import type { AgentConfig, ModelCapabilities, ModelConfig, ProviderRequestOptions, RunOptions, StructuredOutputOptions } from "./contracts.js";
+import type { AgentConfig, ModelCapabilities, ModelConfig, ProviderRequest, ProviderRequestOptions, RunOptions, StructuredOutputOptions } from "./contracts.js";
 export declare const DEFAULT_MAX_STRUCTURED_OUTPUT_SCHEMA_BYTES = 65536;
 export declare const DEFAULT_MAX_STRUCTURED_OUTPUT_NAME_LENGTH = 128;
 export declare class StructuredOutputError extends Error {
@@ -9,3 +9,7 @@ export declare function modelSupportsStructuredOutput(capabilities?: ModelCapabi
 export declare function validateStructuredOutputOptions(options: StructuredOutputOptions): StructuredOutputOptions;
 export declare function assertStructuredOutputRequestSupported(model: ModelConfig, options?: ProviderRequestOptions): void;
 export declare function resolveRunProviderOptions(runOptions: Pick<RunOptions, "providerOptions" | "loop">, config: Pick<AgentConfig, "providerOptions" | "loop">): ProviderRequestOptions | undefined;
+/** Strip native schema so a tool-eligible turn can call tools freely. */
+export declare function withoutStructuredOutput(request: ProviderRequest): ProviderRequest;
+/** Artifact/revision turn: keep/restore schema and withdraw tools. */
+export declare function artifactStructuredOutputRequest(request: ProviderRequest, schema?: StructuredOutputOptions): ProviderRequest;

package/dist/structured-output.js

@@ -56,4 +56,22 @@ export function resolveRunProviderOptions(runOptions, config) {
         structuredOutput: validateStructuredOutputOptions(loop.structuredOutput),
     });
 }
+/** Strip native schema so a tool-eligible turn can call tools freely. */
+export function withoutStructuredOutput(request) {
+    if (!request.options?.structuredOutput)
+        return request;
+    const { structuredOutput: _drop, ...options } = request.options;
+    return { ...request, options: Object.keys(options).length > 0 ? options : undefined };
+}
+/** Artifact/revision turn: keep/restore schema and withdraw tools. */
+export function artifactStructuredOutputRequest(request, schema) {
+    const structuredOutput = schema ?? request.options?.structuredOutput;
+    if (!structuredOutput)
+        return { ...request, tools: undefined };
+    return {
+        ...request,
+        tools: undefined,
+        options: { ...request.options, structuredOutput },
+    };
+}
 //# sourceMappingURL=structured-output.js.map

package/dist/testing/persistence-schema.d.ts

@@ -1,6 +1,6 @@
 import type { PersistencePage, SessionEntry, SessionEntryQuery } from "../contracts.js";
 /** Current shared persistence schema version for production database adapters. */
-export declare const PERSISTENCE_SCHEMA_VERSION = 3;
+export declare const PERSISTENCE_SCHEMA_VERSION = 4;
 export type PersistenceTableName = "prism_tenants" | "prism_accounts" | "prism_users" | "prism_agent_definitions" | "prism_sessions" | "prism_branches" | "prism_session_entries" | "prism_session_append_idempotency" | "prism_runs" | "prism_agent_events" | "prism_tool_calls" | "prism_usage" | "prism_run_feedback" | "prism_retention_policies" | "prism_migrations";
 export type PersistenceColumnType = "text" | "integer" | "number" | "boolean" | "json" | "timestamp";
 export interface PersistenceColumnDefinition {