@inflexa-ai/harness 0.1.1

package/dist/loop/run-agent.js

@@ -0,0 +1,204 @@
+import { jsonSchema, tool as aiTool } from "ai";
+import { classifyProviderError } from "../providers/errors.js";
+import { resultStep } from "./run-step.js";
+import { isToolError } from "../tools/define-tool.js";
+import { recordAgentRun } from "./metrics.js";
+const TRUNCATED_PROSE_STEER = "Your previous reply was cut off at the output-token limit; continue concisely, or finish via your terminal tool.";
+const TRUNCATED_TOOL_USE_ERROR = "Your previous tool call was cut off at the output-token limit and was not executed. Retry with a smaller payload, writing in incremental pieces.";
+export const DEFAULT_STEP_NAME_FORMATTER = {
+    llm: (i) => `llm-${i}`,
+    tool: (name, id) => `tool-${name}-${id}`,
+};
+export async function runAgent(agent, initial, session, opts) {
+    const { provider, signal, emit, runStep } = opts;
+    const formatStepName = opts.formatStepName ?? DEFAULT_STEP_NAME_FORMATTER;
+    const isFatalLoopError = opts.isFatalLoopError ?? (() => false);
+    if (agent.tools.length > 0 && !provider.capabilities.toolCalling) {
+        throw new Error(`Provider/model cannot run tool-required agent "${agent.id}"`);
+    }
+    const messages = [...initial];
+    const source = {
+        agentId: session.provenance.agentId ?? agent.id,
+        callPath: session.provenance.callPath,
+    };
+    const toolsById = new Map(agent.tools.map((t) => [t.id, t]));
+    const toolDefs = Object.fromEntries(agent.tools.map((t) => [
+        t.id,
+        aiTool({
+            description: t.description,
+            inputSchema: jsonSchema(t.jsonSchema),
+        }),
+    ]));
+    const toolCtx = (tu) => ({
+        session,
+        signal,
+        emit,
+        runStep: (name, fn) => runStep(`${formatStepName.tool(tu.toolName, tu.toolCallId)}:${name}`, fn),
+    });
+    let iterations = 0;
+    let truncationRecoveries = 0;
+    for (let i = 0; i < agent.maxIterations; i++) {
+        iterations = i + 1;
+        const request = {
+            system: agent.systemPrompt,
+            messages,
+            tools: toolDefs,
+        };
+        const reply = await resultStep(runStep)(formatStepName.llm(i), () => provider.chat(request, session, signal));
+        messages.push(reply.message);
+        const toolCalls = toolCallParts(reply.message);
+        if (reply.finishReason === "length") {
+            truncationRecoveries++;
+            await emit({ type: "iteration", source, index: i, final: false });
+            if (toolCalls.length === 0) {
+                messages.push({ role: "user", content: TRUNCATED_PROSE_STEER });
+                continue;
+            }
+            const trailing = toolCalls[toolCalls.length - 1];
+            const earlier = toolCalls.slice(0, -1);
+            for (const tu of earlier) {
+                await emit({ type: "tool-started", source, toolUseId: tu.toolCallId, name: tu.toolName, input: tu.input });
+            }
+            const results = await dispatchTools(earlier, toolsById, toolCtx, isFatalLoopError, runStep, formatStepName.tool);
+            for (let idx = 0; idx < earlier.length; idx++) {
+                const tu = earlier[idx];
+                await emit({
+                    type: "tool-finished",
+                    source,
+                    toolUseId: tu.toolCallId,
+                    name: tu.toolName,
+                    isError: isErrorOutput(results[idx]),
+                });
+            }
+            results.push(errorResult(trailing, TRUNCATED_TOOL_USE_ERROR));
+            messages.push({ role: "tool", content: results });
+            continue;
+        }
+        if (reply.finishReason !== "tool-calls") {
+            await emit({ type: "iteration", source, index: i, final: true });
+            recordAgentRun({ agentId: agent.id, iterations, cappedOut: false });
+            return { messages, finish: { reason: reply.finishReason, cappedOut: false, truncationRecoveries } };
+        }
+        await emit({ type: "iteration", source, index: i, final: false });
+        for (const tu of toolCalls) {
+            await emit({ type: "tool-started", source, toolUseId: tu.toolCallId, name: tu.toolName, input: tu.input });
+        }
+        const results = await dispatchTools(toolCalls, toolsById, toolCtx, isFatalLoopError, runStep, formatStepName.tool);
+        for (let idx = 0; idx < toolCalls.length; idx++) {
+            const tu = toolCalls[idx];
+            await emit({
+                type: "tool-finished",
+                source,
+                toolUseId: tu.toolCallId,
+                name: tu.toolName,
+                isError: isErrorOutput(results[idx]),
+            });
+        }
+        messages.push({ role: "tool", content: results });
+    }
+    const wrapUp = await resultStep(runStep)(formatStepName.llm(agent.maxIterations), () => provider.chat({ system: agent.systemPrompt, messages, tools: {}, toolChoice: "none" }, session, signal));
+    messages.push(wrapUp.message);
+    await emit({ type: "iteration", source, index: agent.maxIterations, final: true });
+    recordAgentRun({ agentId: agent.id, iterations, cappedOut: true });
+    return { messages, finish: { reason: "max_iterations", cappedOut: true, truncationRecoveries } };
+}
+function toolCallParts(message) {
+    if (typeof message.content === "string")
+        return [];
+    return message.content.filter((part) => part.type === "tool-call");
+}
+async function dispatchTools(toolUses, toolsById, toolCtx, isFatalLoopError, runStep, toolStepName) {
+    const results = new Array(toolUses.length);
+    const stepTools = [];
+    const workflowTools = [];
+    const inlineTools = [];
+    for (const [idx, tu] of toolUses.entries()) {
+        const mode = toolsById.get(tu.toolName)?.executionMode ?? "step";
+        if (mode === "workflow")
+            workflowTools.push({ tu, idx });
+        else if (mode === "inline")
+            inlineTools.push({ tu, idx });
+        else
+            stepTools.push({ tu, idx });
+    }
+    await Promise.all(stepTools.map(({ tu, idx }) => runStep(toolStepName(tu.toolName, tu.toolCallId), () => dispatchTool(tu, toolsById, toolCtx(tu), isFatalLoopError)).then((r) => {
+        results[idx] = r;
+    })));
+    for (const { tu, idx } of workflowTools) {
+        results[idx] = await dispatchTool(tu, toolsById, toolCtx(tu), isFatalLoopError);
+    }
+    for (const { tu, idx } of inlineTools) {
+        results[idx] = await dispatchTool(tu, toolsById, toolCtx(tu), isFatalLoopError);
+    }
+    return results;
+}
+async function dispatchTool(tu, toolsById, ctx, isFatalLoopError) {
+    const tool = toolsById.get(tu.toolName);
+    if (tool === undefined) {
+        return errorResult(tu, `unknown tool: ${tu.toolName}`);
+    }
+    const parsed = tool.inputSchema.safeParse(tu.input);
+    if (!parsed.success) {
+        return errorResult(tu, `input validation failed: ${formatZodIssues(parsed.error)}`);
+    }
+    try {
+        const output = await tool.execute(parsed.data, ctx);
+        if (output.isErr())
+            return errorResult(tu, toolErrorContent(output.error));
+        return successResult(tu, output.value);
+    }
+    catch (err) {
+        if (isFatalLoopError(err))
+            throw err;
+        return errorResult(tu, toolErrorContent(err));
+    }
+}
+function jsonValue(value) {
+    return JSON.parse(JSON.stringify(value ?? null));
+}
+function successResult(toolCall, value) {
+    return {
+        type: "tool-result",
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        output: { type: "json", value: jsonValue(value) },
+    };
+}
+function toolErrorContent(value) {
+    if (isToolError(value)) {
+        return JSON.stringify({ error: value.error, retryable: value.retryable });
+    }
+    const { retryable } = classifyProviderError(value);
+    const error = value instanceof Error ? value.message : String(value);
+    return JSON.stringify({ error, retryable });
+}
+function errorResult(toolCall, content) {
+    return {
+        type: "tool-result",
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        output: { type: "error-text", value: content },
+    };
+}
+function isErrorOutput(result) {
+    return result.output.type === "error-text" || result.output.type === "error-json" || result.output.type === "execution-denied";
+}
+export function finalText(messages) {
+    const last = messages.at(-1);
+    if (last === undefined || last.role !== "assistant")
+        return "";
+    if (typeof last.content === "string")
+        return last.content;
+    return last.content
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("");
+}
+function formatZodIssues(error) {
+    return error.issues
+        .map((issue) => {
+        const path = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+        return `${path}: ${issue.message}`;
+    })
+        .join("; ");
+}

package/dist/loop/run-step.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `RunStep` adapters.
+ *
+ * `runAgent` wraps every LLM and tool call in an injected `RunStep`. Two
+ * adapters cover the two execution modes:
+ *
+ * - `passthroughStep` — the chat route. In-process, single-replica, no
+ *   durability. Just runs the function.
+ * - `durableStep` — workflow contexts. Wraps the call as a `DBOS.runStep`
+ *   so a crashed workflow replays without re-issuing completed LLM/tool
+ *   calls. The step name (`llm-${i}`, `tool-${name}-${toolUseId}`) is the
+ *   cache key on replay (see the harness-thread-store spec) and must not be reformatted.
+ *
+ * The loop body never imports DBOS — it depends only on the `RunStep`
+ * shape, which is what lets the same `runAgent` serve chat and (in change
+ * 8) durable workflows.
+ */
+import type { Result } from "neverthrow";
+import type { RunStep } from "./types.js";
+export declare const passthroughStep: RunStep;
+export declare const durableStep: RunStep;
+/**
+ * Adapt a `RunStep` to a `Result`-returning body. This is THE seam where
+ * `Result` meets durability: a step is recorded as failed — and retried /
+ * fails fast — only when its body throws, so an `err` MUST become a throw at
+ * the step boundary. The body stays Result-shaped; `unwrapOrThrow` isolates
+ * the throw. Pass `durableStep` in workflows, `passthroughStep` in chat.
+ */
+export declare function resultStep(runStep: RunStep): <T, E>(name: string, fn: () => PromiseLike<Result<T, E>>) => Promise<T>;

package/dist/loop/run-step.js

@@ -0,0 +1,34 @@
+/**
+ * `RunStep` adapters.
+ *
+ * `runAgent` wraps every LLM and tool call in an injected `RunStep`. Two
+ * adapters cover the two execution modes:
+ *
+ * - `passthroughStep` — the chat route. In-process, single-replica, no
+ *   durability. Just runs the function.
+ * - `durableStep` — workflow contexts. Wraps the call as a `DBOS.runStep`
+ *   so a crashed workflow replays without re-issuing completed LLM/tool
+ *   calls. The step name (`llm-${i}`, `tool-${name}-${toolUseId}`) is the
+ *   cache key on replay (see the harness-thread-store spec) and must not be reformatted.
+ *
+ * The loop body never imports DBOS — it depends only on the `RunStep`
+ * shape, which is what lets the same `runAgent` serve chat and (in change
+ * 8) durable workflows.
+ */
+import { DBOS } from "@dbos-inc/dbos-sdk";
+import { unwrapOrThrow } from "../lib/result.js";
+export const passthroughStep = (_name, fn) => fn();
+export const durableStep = (name, fn) => DBOS.runStep(fn, { name });
+/**
+ * Adapt a `RunStep` to a `Result`-returning body. This is THE seam where
+ * `Result` meets durability: a step is recorded as failed — and retried /
+ * fails fast — only when its body throws, so an `err` MUST become a throw at
+ * the step boundary. The body stays Result-shaped; `unwrapOrThrow` isolates
+ * the throw. Pass `durableStep` in workflows, `passthroughStep` in chat.
+ */
+export function resultStep(runStep) {
+    return (name, 
+    // `PromiseLike`, not `Promise` — a `ResultAsync` (what `provider.chat`
+    // returns) is a `PromiseLike<Result>`, awaited to its inner `Result`.
+    fn) => runStep(name, async () => unwrapOrThrow(await fn()));
+}

package/dist/loop/run-to-terminal.d.ts

@@ -0,0 +1,46 @@
+/**
+ * `runToTerminal` — terminal-salvage wrapper around `runAgent`.
+ *
+ * Some agents communicate their result EXCLUSIVELY through a terminal tool
+ * (`submit_plan`, `submit_report`, `submit_profile`, `submit_synthesis`, …):
+ * the loop's text reply is discarded and the outcome is read from a closure
+ * cell the terminal tool writes. Plain `runAgent` ends a capped run on a
+ * tool-LESS wrap-up turn, so an agent that burns its whole iteration budget —
+ * or simply stops on prose — without ever submitting leaves that cell empty
+ * and forces the caller to hard-fail.
+ *
+ * `runToTerminal` runs the agent, then — if the outcome cell is still empty
+ * and the run was not aborted — grants ONE focused salvage continuation whose
+ * only tools are the terminal tools, opened by a corrective nudge. Restricting
+ * the surface to the terminal tools removes every distraction; a small
+ * `maxIterations` lets the model fix a single validation rejection and
+ * resubmit.
+ *
+ * Salvage steps are namespaced (`salvage:…`) so a durable (DBOS) caller does
+ * not collide the continuation's `llm-*` / `tool-*` cache keys with the first
+ * run's — replaying them would silently return the first run's cached results.
+ */
+import type { AgentSession } from "../auth/types.js";
+import type { Tool } from "../tools/define-tool.js";
+import { type RunAgentOptions, type RunAgentResult } from "./run-agent.js";
+import type { AgentDefinition, LoopMessage } from "./types.js";
+/** Default salvage budget: one submit plus a validation-fix retry or two. */
+export declare const DEFAULT_SALVAGE_ITERATIONS = 3;
+/** Describes how to salvage a run that never reached its terminal tool. */
+export interface TerminalSalvage {
+    /** True once the agent recorded its terminal outcome (reads the closure cell). */
+    readonly resolved: () => boolean;
+    /** Terminal tools offered on the salvage turn (submit / blocker / …). Must be
+     *  the same instances the first run used — they close over the outcome cell. */
+    readonly tools: readonly Tool[];
+    /** Corrective user message that opens the salvage continuation. */
+    readonly nudge: string;
+    /** Salvage iteration budget. Defaults to {@link DEFAULT_SALVAGE_ITERATIONS}. */
+    readonly maxIterations?: number;
+}
+/**
+ * Drive `agent` to its terminal tool, salvaging once if it doesn't get there.
+ * Returns the salvage run's result when a salvage occurred (its message array
+ * already includes the first run's), otherwise the first run's result.
+ */
+export declare function runToTerminal(agent: AgentDefinition, initial: readonly LoopMessage[], session: AgentSession, opts: RunAgentOptions, salvage: TerminalSalvage): Promise<RunAgentResult>;

package/dist/loop/run-to-terminal.js

@@ -0,0 +1,51 @@
+/**
+ * `runToTerminal` — terminal-salvage wrapper around `runAgent`.
+ *
+ * Some agents communicate their result EXCLUSIVELY through a terminal tool
+ * (`submit_plan`, `submit_report`, `submit_profile`, `submit_synthesis`, …):
+ * the loop's text reply is discarded and the outcome is read from a closure
+ * cell the terminal tool writes. Plain `runAgent` ends a capped run on a
+ * tool-LESS wrap-up turn, so an agent that burns its whole iteration budget —
+ * or simply stops on prose — without ever submitting leaves that cell empty
+ * and forces the caller to hard-fail.
+ *
+ * `runToTerminal` runs the agent, then — if the outcome cell is still empty
+ * and the run was not aborted — grants ONE focused salvage continuation whose
+ * only tools are the terminal tools, opened by a corrective nudge. Restricting
+ * the surface to the terminal tools removes every distraction; a small
+ * `maxIterations` lets the model fix a single validation rejection and
+ * resubmit.
+ *
+ * Salvage steps are namespaced (`salvage:…`) so a durable (DBOS) caller does
+ * not collide the continuation's `llm-*` / `tool-*` cache keys with the first
+ * run's — replaying them would silently return the first run's cached results.
+ */
+import { DEFAULT_STEP_NAME_FORMATTER, runAgent } from "./run-agent.js";
+/** Default salvage budget: one submit plus a validation-fix retry or two. */
+export const DEFAULT_SALVAGE_ITERATIONS = 3;
+function salvageStepNames(base) {
+    return {
+        llm: (i) => `salvage:${base.llm(i)}`,
+        tool: (name, id) => `salvage:${base.tool(name, id)}`,
+    };
+}
+/**
+ * Drive `agent` to its terminal tool, salvaging once if it doesn't get there.
+ * Returns the salvage run's result when a salvage occurred (its message array
+ * already includes the first run's), otherwise the first run's result.
+ */
+export async function runToTerminal(agent, initial, session, opts, salvage) {
+    const first = await runAgent(agent, initial, session, opts);
+    if (salvage.resolved() || opts.signal.aborted)
+        return first;
+    const salvageAgent = {
+        ...agent,
+        tools: [...salvage.tools],
+        maxIterations: salvage.maxIterations ?? DEFAULT_SALVAGE_ITERATIONS,
+    };
+    const salvageOpts = {
+        ...opts,
+        formatStepName: salvageStepNames(opts.formatStepName ?? DEFAULT_STEP_NAME_FORMATTER),
+    };
+    return runAgent(salvageAgent, [...first.messages, { role: "user", content: salvage.nudge }], session, salvageOpts);
+}

package/dist/loop/types.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Agent-loop seam — shared types.
+ *
+ * `runAgent` (run-agent.ts) is a pure-async function: it owns the message
+ * loop and nothing else. Durability and streaming are *injected* — a
+ * `RunStep` wraps each LLM/tool call (`passthroughStep` for chat, a
+ * `DBOS.runStep` wrapper in PR #3) and an `EmitFn` is the flat event sink.
+ * The loop body itself knows nothing about DBOS, HTTP, or memory.
+ */
+import type { ModelMessage } from "ai";
+import type { ChatStreamEvent } from "../providers/types.js";
+import type { Tool } from "../tools/define-tool.js";
+/**
+ * A loop message. The harness's working message array is AI SDK-shaped
+ * `ModelMessage`.
+ */
+export type LoopMessage = ModelMessage;
+/**
+ * Everything `runAgent` needs to drive one agent: identity, the system
+ * prompt, the model id (provenance / metric label — the `ChatProvider`
+ * owns the wire model), the tool surface, and the runaway-guard cap.
+ */
+export interface AgentDefinition {
+    readonly id: string;
+    readonly systemPrompt: string;
+    readonly model: string;
+    readonly tools: readonly Tool[];
+    /** Runaway guard — at the cap the loop forces a tool-less wrap-up call. */
+    readonly maxIterations: number;
+}
+/**
+ * The durability seam. `passthroughStep` (`(_, fn) => fn()`) in the chat
+ * route; a `DBOS.runStep` wrapper in PR #3. The loop is agnostic — it only
+ * promises a deterministic `name` per call (the step-naming contract).
+ */
+export type RunStep = <T>(name: string, fn: () => Promise<T>) => Promise<T>;
+/**
+ * Provenance stamped onto every orchestration event — the agent call
+ * chain at the point of emission, derived from the `Session` (see the harness-durable-runtime spec).
+ * `callPath` is provenance only; nothing branches on it.
+ */
+export interface EventSource {
+    readonly agentId: string;
+    readonly callPath: readonly string[];
+}
+/**
+ * Orchestration events the loop emits: iteration boundaries and tool-call
+ * lifecycle. Distinct from `ChatStreamEvent` (model-output text deltas) —
+ * the chat route folds both into one `EmitFn` sink.
+ */
+export type EmitEvent = {
+    readonly type: "iteration";
+    readonly source: EventSource;
+    /** Zero-based iteration index; equals `maxIterations` for the wrap-up. */
+    readonly index: number;
+    /** True when this iteration produced the loop's terminal reply. */
+    readonly final: boolean;
+} | {
+    readonly type: "tool-started";
+    readonly source: EventSource;
+    readonly toolUseId: string;
+    readonly name: string;
+    readonly input: unknown;
+} | {
+    readonly type: "tool-finished";
+    readonly source: EventSource;
+    readonly toolUseId: string;
+    readonly name: string;
+    readonly isError: boolean;
+};
+/**
+ * A UI presentation event a tool streams to chat — an AI-SDK `data-*`
+ * part whose payload the frontend renders (file references, plan cards,
+ * synthesized content). The loop and `emit` are agnostic to the payload
+ * shape; the typed contract lives in `harness/contracts`.
+ */
+export interface ChatDataPart {
+    readonly type: `data-${string}`;
+    readonly data: unknown;
+    /**
+     * Emitting-agent provenance, for the SSE route's depth filter (it drops
+     * sub-agent display parts the same way it drops sub-agent tool events).
+     * Omitted by emitters outside the chat loop (workflow parts carry their own
+     * routing envelopes).
+     */
+    readonly source?: EventSource;
+}
+/**
+ * The flat event sink. One function reference flows unchanged through
+ * every nesting level. It carries three event categories: orchestration
+ * events (`EmitEvent`, from the loop), model-output deltas
+ * (`ChatStreamEvent`, from the provider), and UI presentation parts
+ * (`ChatDataPart`, from tools). A tool that does not stream never calls it.
+ */
+export type EmitFn = (event: EmitEvent | ChatStreamEvent | ChatDataPart) => void | Promise<void>;

package/dist/loop/types.js

@@ -0,0 +1,10 @@
+/**
+ * Agent-loop seam — shared types.
+ *
+ * `runAgent` (run-agent.ts) is a pure-async function: it owns the message
+ * loop and nothing else. Durability and streaming are *injected* — a
+ * `RunStep` wraps each LLM/tool call (`passthroughStep` for chat, a
+ * `DBOS.runStep` wrapper in PR #3) and an `EmitFn` is the flat event sink.
+ * The loop body itself knows nothing about DBOS, HTTP, or memory.
+ */
+export {};

package/dist/memory/ai-sdk-message-storage.d.ts

@@ -0,0 +1,20 @@
+import { type ModelMessage } from "ai";
+import { z } from "zod";
+export declare const SUPPORTED_AI_SDK_MAJOR = 7;
+export declare const StoredMessageEnvelopeSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"ai-sdk-model-message">;
+    aiSdkMajor: z.ZodLiteral<7>;
+    message: z.ZodType<ModelMessage, unknown, z.core.$ZodTypeInternals<ModelMessage, unknown>>;
+}, z.core.$strip>;
+export type StoredMessageEnvelope = z.infer<typeof StoredMessageEnvelopeSchema>;
+export declare function envelopeMessage(message: ModelMessage): StoredMessageEnvelope;
+export declare function parseStoredMessageEnvelope(value: unknown, identity: string): StoredMessageEnvelope;
+type LegacyContent = string | Array<Record<string, unknown>>;
+export interface LegacyMessageRow {
+    readonly threadId: string;
+    readonly seq: number;
+    readonly role: string;
+    readonly content: LegacyContent;
+}
+export declare function legacyAnthropicToModelMessage(row: LegacyMessageRow): ModelMessage;
+export {};

package/dist/memory/ai-sdk-message-storage.js

@@ -0,0 +1,114 @@
+import { modelMessageSchema } from "ai";
+import { z } from "zod";
+export const SUPPORTED_AI_SDK_MAJOR = 7;
+export const StoredMessageEnvelopeSchema = z.object({
+    kind: z.literal("ai-sdk-model-message"),
+    aiSdkMajor: z.literal(SUPPORTED_AI_SDK_MAJOR),
+    message: modelMessageSchema,
+});
+export function envelopeMessage(message) {
+    return {
+        kind: "ai-sdk-model-message",
+        aiSdkMajor: SUPPORTED_AI_SDK_MAJOR,
+        message,
+    };
+}
+export function parseStoredMessageEnvelope(value, identity) {
+    const parsed = StoredMessageEnvelopeSchema.safeParse(value);
+    if (!parsed.success) {
+        throw new Error(`Invalid stored AI SDK message envelope at ${identity}: ${parsed.error.message}`);
+    }
+    return parsed.data;
+}
+function providerOptionsFromLegacy(block) {
+    // A block may carry both a signed thinking signature and cache_control;
+    // both are required for valid continuation, so both must survive.
+    const anthropic = {};
+    if (typeof block.signature === "string")
+        anthropic.signature = block.signature;
+    if (typeof block.cache_control === "object" && block.cache_control !== null) {
+        anthropic.cacheControl = block.cache_control;
+    }
+    return Object.keys(anthropic).length > 0 ? { anthropic } : undefined;
+}
+export function legacyAnthropicToModelMessage(row) {
+    const content = row.content;
+    if (row.role === "user") {
+        if (typeof content === "string")
+            return { role: "user", content };
+        const toolResults = content.filter((block) => block.type === "tool_result");
+        if (toolResults.length > 0) {
+            // An AI SDK tool message carries only tool-result parts; a legacy row
+            // mixing tool_result with other blocks cannot become one message and
+            // must fail the row rather than drop the extra blocks.
+            if (toolResults.length !== content.length) {
+                throw new Error(`Legacy user row ${row.threadId}/${row.seq} mixes tool_result with other content blocks and cannot be represented losslessly`);
+            }
+            return {
+                role: "tool",
+                content: toolResults.map((block) => {
+                    const toolCallId = block.tool_use_id;
+                    if (typeof toolCallId !== "string")
+                        throw new Error(`Legacy tool_result row ${row.threadId}/${row.seq} is missing tool_use_id`);
+                    const raw = typeof block.content === "string" ? block.content : JSON.stringify(block.content ?? null);
+                    return {
+                        type: "tool-result",
+                        toolCallId,
+                        toolName: typeof block.name === "string" ? block.name : "legacy_tool",
+                        output: block.is_error === true ? { type: "error-text", value: raw } : { type: "text", value: raw },
+                    };
+                }),
+            };
+        }
+        const unrepresentable = content.find((block) => !(block.type === "text" && typeof block.text === "string"));
+        if (unrepresentable !== undefined) {
+            throw new Error(`Legacy user row ${row.threadId}/${row.seq} contains unrepresentable block type "${String(unrepresentable.type)}"; failing rather than writing a lossy envelope`);
+        }
+        const userContent = content.map((block) => ({ type: "text", text: String(block.text), providerOptions: providerOptionsFromLegacy(block) }));
+        return {
+            role: "user",
+            content: userContent,
+        };
+    }
+    if (row.role === "assistant") {
+        if (typeof content === "string")
+            return { role: "assistant", content };
+        const assistantContent = [];
+        for (const block of content) {
+            if (block.type === "text" && typeof block.text === "string") {
+                assistantContent.push({ type: "text", text: block.text, providerOptions: providerOptionsFromLegacy(block) });
+                continue;
+            }
+            if (block.type === "thinking" && typeof block.thinking === "string") {
+                assistantContent.push({ type: "reasoning", text: block.thinking, providerOptions: providerOptionsFromLegacy(block) });
+                continue;
+            }
+            if (block.type === "tool_use") {
+                if (typeof block.id !== "string" || typeof block.name !== "string") {
+                    throw new Error(`Legacy tool_use row ${row.threadId}/${row.seq} is missing id/name`);
+                }
+                assistantContent.push({
+                    type: "tool-call",
+                    toolCallId: block.id,
+                    toolName: block.name,
+                    input: block.input ?? {},
+                    providerOptions: providerOptionsFromLegacy(block),
+                });
+                continue;
+            }
+            // Any other block (e.g. redacted_thinking) may carry signed provider
+            // data required for continuation; fail the row instead of dropping it.
+            throw new Error(`Legacy assistant row ${row.threadId}/${row.seq} contains unrepresentable block type "${String(block.type)}"; failing rather than writing a lossy envelope`);
+        }
+        return {
+            role: "assistant",
+            content: assistantContent,
+        };
+    }
+    if (row.role === "system") {
+        if (typeof content !== "string")
+            throw new Error(`Legacy system row ${row.threadId}/${row.seq} must contain string content`);
+        return { role: "system", content };
+    }
+    throw new Error(`Unsupported legacy message role at ${row.threadId}/${row.seq}: ${row.role}`);
+}