@parcha/agentrun-kernel 0.0.0-bootstrap.0 → 0.1.0-beta.29

package/dist/process/recovery.d.ts

@@ -0,0 +1,76 @@
+import { type ReplayPolicy, type SessionState, type Submission } from '../kernel/index.js';
+import { type OpenTurn, openTurn } from './records.js';
+export { type OpenTurn, openTurn };
+/**
+ * The recovery note: what a process harness tells its model when it resumes
+ * a turn a crash cut off. A CLI harness resumes its own session natively,
+ * but it never knows what happened to the calls that were in flight (Codex
+ * needs an output injected for a dangling call), and a resumed session needs a new
+ * user message to move. The note is that message, built from the log: the
+ * calls since the turn began, each with what the log knows about it.
+ */
+export interface RecoveryCall {
+    callId: string;
+    name: string;
+    input: unknown;
+    replay: ReplayPolicy;
+    /**
+     * - `completed`: the result is recorded (`output`);
+     * - `failed`: the tool failed and said so (`error`);
+     * - `interrupted`: a `replay: 'never'` call whose outcome was lost: it may
+     *   have taken effect;
+     * - `retryable`: a `replay: 'safe'` call that was interrupted: safe to repeat;
+     * - `running`: still open in the log (build the note after the kernel's
+     *   recovery has resolved intents; a drive's own context always has).
+     */
+    status: 'completed' | 'failed' | 'interrupted' | 'retryable' | 'running';
+    output?: string;
+    error?: string;
+}
+export interface RecoveryOptions {
+    /** Pending submissions to fold into the note. Default: every pending one. Pass `[]` to place them separately. */
+    pending?: Submission[];
+    /**
+     * Quote the prompts placed in the interrupted turn. For a harness whose
+     * native session may have lost them (the crash came before the record of
+     * the message was in the log).
+     */
+    prompts?: boolean;
+    /** How much of a tool's output, input or error to quote. Default 1500 characters. */
+    clipChars?: number;
+}
+export interface RecoveryNote {
+    /** The message to send the harness, as a user message. */
+    text: string;
+    calls: RecoveryCall[];
+    /** The pending submissions the note carries: place these with it (`placeSubmissions`). */
+    pending: Submission[];
+    turn: OpenTurn;
+}
+/** The note for the open turn, or `undefined` if no turn is open. */
+export declare function recoveryNote(state: SessionState, options?: RecoveryOptions): RecoveryNote | undefined;
+/**
+ * The note as a harness carries it outside the user's turn (a system prompt, a developer item): from the harness, about the
+ * turn before, in the harness's own words only. It names each call and says how it ended, and never quotes what a tool was
+ * given or answered with (that is data the agent read, not something the harness may speak for), a prompt, or a pending message.
+ * `undefined` when no turn is open.
+ */
+export declare function recoverySystemNote(state: SessionState): string | undefined;
+/** The user's turn that resumes a cut-off turn: only the user's words (the prompts the session never got, then the messages sent since), or a bare nudge. */
+export declare function recoveryUserTurn(lost: string[], pending: string[]): string;
+/**
+ * The live event a harness sends as it resumes a turn a crash cut off,
+ * before the model answers again: the model starts the step the crash
+ * interrupted over, so what a reader saw of its reply is replaced.
+ * `text` is the turn's text as the log kept it (the assistant text of its
+ * finished steps, and the text before each tool call); a reader shows it in
+ * place of what it showed of the turn so far (everything since the last
+ * `idle`), and appends what streams after it. `parts` is the same text, one
+ * entry per kept step, for a reader that shows tool calls between them: a
+ * turn on screen with more text than `parts` has a cut-off reply last.
+ */
+export declare function restartEvent(turn: OpenTurn): {
+    type: 'restart';
+    text: string;
+    parts: string[];
+};

package/dist/process/recovery.js

@@ -0,0 +1,139 @@
+// Copyright 2026 Vercel Inc. Licensed under the Apache License, Version 2.0; see LICENSE in this package.
+// From github.com/vercel-labs/durable-harness, packages/harness-process/src/recovery.ts at ea8aa4060c (UPSTREAM.json records its blob and sha256).
+// Changed by Parcha, imports rewritten for AgentRun; patches: 003-comments-name-this-host, 009-recovery-system-note, 010-recovery-note-statuses-only
+import { pendingSubmissions } from '../kernel/index.js';
+import { openTurn } from './records.js';
+export { openTurn };
+/** The note for the open turn, or `undefined` if no turn is open. */
+export function recoveryNote(state, options = {}) {
+    const turn = openTurn(state);
+    if (!turn)
+        return undefined;
+    const max = options.clipChars ?? 1500;
+    const calls = turn.calls.map((e) => recoveryCall(e, max));
+    const pending = options.pending ?? pendingSubmissions(state);
+    const lines = [
+        '[Recovery] Your previous turn was interrupted: the process running it stopped, and this session was resumed from its durable log.',
+    ];
+    if (options.prompts) {
+        const texts = turn.placed
+            .map((id) => state.submissions.find((s) => s.id === id)?.text)
+            .filter((t) => !!t);
+        if (texts.length)
+            lines.push('', 'The user\'s message in that turn:', ...texts.map((t) => quote(clip(t, max))));
+    }
+    lines.push('');
+    if (calls.length === 0)
+        lines.push('No tool call had started in that turn.');
+    else {
+        lines.push('What the log records about the tool calls since that turn began:');
+        for (const c of calls)
+            lines.push(...describe(c));
+    }
+    lines.push('', 'Check the actual state before repeating anything that may have taken effect, then carry on with the task.');
+    if (pending.length) {
+        lines.push('', 'New messages since then:');
+        for (const s of pending)
+            lines.push(quote(s.text ?? ''));
+    }
+    return { text: lines.join('\n'), calls, pending, turn };
+}
+/**
+ * The note as a harness carries it outside the user's turn (a system prompt, a developer item): from the harness, about the
+ * turn before, in the harness's own words only. It names each call and says how it ended, and never quotes what a tool was
+ * given or answered with (that is data the agent read, not something the harness may speak for), a prompt, or a pending message.
+ * `undefined` when no turn is open.
+ */
+export function recoverySystemNote(state) {
+    const turn = openTurn(state);
+    if (!turn)
+        return undefined;
+    const calls = turn.calls.map((e) => recoveryCall(e, 0));
+    const lines = [
+        'The harness, not the user, adds this about the turn before this one:',
+        '[Recovery] Your previous turn was interrupted: the process running it stopped, and this session was resumed from its durable log.',
+        '',
+    ];
+    if (calls.length === 0)
+        lines.push('No tool call had started in that turn.');
+    else {
+        lines.push('What the log records about the tool calls since that turn began (none was run again):');
+        for (const c of calls)
+            lines.push(`- ${c.name}, call ${c.callId}: ${ended(c)}`);
+        lines.push('', 'The output of those calls is not shown here. Check the actual state before relying on it.');
+    }
+    lines.push('', 'Check the actual state before repeating anything that may have taken effect, then carry on with the task.');
+    return lines.join('\n');
+}
+function ended(c) {
+    switch (c.status) {
+        case 'completed':
+            return 'completed.';
+        case 'failed':
+            return 'failed.';
+        case 'interrupted':
+            return 'interrupted before it reported a result. It is not safe to repeat, and it may have taken effect.';
+        case 'retryable':
+            return 'interrupted before it reported a result. It is safe to repeat.';
+        case 'running':
+            return 'interrupted, and it may still be running. It may have taken effect.';
+    }
+}
+/** The user's turn that resumes a cut-off turn: only the user's words (the prompts the session never got, then the messages sent since), or a bare nudge. */
+export function recoveryUserTurn(lost, pending) {
+    const words = [...lost, ...pending].filter((t) => t !== '');
+    return words.length ? words.join('\n\n') : 'Continue.';
+}
+function recoveryCall(e, max) {
+    const base = {
+        callId: e.key.startsWith('tool:') ? e.key.slice(5) : e.key,
+        name: e.name.slice('tool.'.length),
+        input: e.input,
+        replay: e.replay,
+    };
+    if (e.status === 'completed')
+        return { ...base, status: 'completed', output: clip(text(e.output), max) };
+    if (e.status === 'pending')
+        return { ...base, status: 'retryable' };
+    if (e.status === 'running')
+        return { ...base, status: 'running' };
+    if (e.error?.interrupted)
+        return { ...base, status: e.replay === 'safe' ? 'retryable' : 'interrupted' };
+    return { ...base, status: 'failed', error: clip(e.error?.message ?? 'failed', max) };
+}
+function describe(c) {
+    const head = `- ${c.name}(${clip(text(c.input), 300)}), call ${c.callId}:`;
+    switch (c.status) {
+        case 'completed':
+            return [`${head} completed. Its result:`, ...indent(c.output ?? '')];
+        case 'failed':
+            return [`${head} failed: ${c.error}`];
+        case 'interrupted':
+            return [`${head} interrupted before it reported a result. It is not safe to repeat, and it may have taken effect: check before repeating it.`];
+        case 'retryable':
+            return [`${head} interrupted before it reported a result. It is safe to repeat.`];
+        case 'running':
+            return [`${head} interrupted, and it may still be running. It may have taken effect: check before repeating it.`];
+    }
+}
+const text = (v) => (typeof v === 'string' ? v : JSON.stringify(v) ?? String(v));
+const quote = (t) => t.split('\n').map((l) => `> ${l}`).join('\n');
+const indent = (t) => t.split('\n').map((l) => `    ${l}`);
+function clip(t, max) {
+    return t.length <= max ? t : `${t.slice(0, max)}… [${t.length - max} more characters]`;
+}
+/**
+ * The live event a harness sends as it resumes a turn a crash cut off,
+ * before the model answers again: the model starts the step the crash
+ * interrupted over, so what a reader saw of its reply is replaced.
+ * `text` is the turn's text as the log kept it (the assistant text of its
+ * finished steps, and the text before each tool call); a reader shows it in
+ * place of what it showed of the turn so far (everything since the last
+ * `idle`), and appends what streams after it. `parts` is the same text, one
+ * entry per kept step, for a reader that shows tool calls between them: a
+ * turn on screen with more text than `parts` has a cut-off reply last.
+ */
+export function restartEvent(turn) {
+    const parts = turn.entries.flatMap((r) => (r.data?.type === 'message' && r.data.role === 'assistant' && r.data.text ? [r.data.text] : []));
+    return { type: 'restart', text: parts.join('\n\n'), parts };
+}

package/dist/process/settle.d.ts

@@ -0,0 +1,11 @@
+import { type Drive } from "../kernel/index.js";
+/**
+ * Records the session's open turn as ended in its transcript, the record a turn that ends writes (so `openTurn` finds
+ * none, and the next turn carries no recovery note for it), and runs nothing. Input the turn never placed (a stop that
+ * landed before the harness took its prompt) is withdrawn first, as the kernel's follow-up settle does, so no later open
+ * finds it pending, and the next message is sent alone. It is the write behind
+ * `AdapterSession.settleOpenTurn()` for a turn the person stopped, which is never resumed. The adapter checks that a
+ * turn is open. The end is the kernel's for the session's own stop (`abortedOutcome` of its `SessionHalt`), the one
+ * path an interrupted turn's end takes, though the turn never ran in this process.
+ */
+export declare function settleTurn(drive: Drive): Promise<void>;

package/dist/process/settle.js

@@ -0,0 +1,20 @@
+// AgentRun's own (not copied): how a process harness settles a turn its session left open.
+import { abortedOutcome, pendingSubmissions, SessionHalt } from "../kernel/index.js";
+import { NativeJournal } from "./journal.js";
+/**
+ * Records the session's open turn as ended in its transcript, the record a turn that ends writes (so `openTurn` finds
+ * none, and the next turn carries no recovery note for it), and runs nothing. Input the turn never placed (a stop that
+ * landed before the harness took its prompt) is withdrawn first, as the kernel's follow-up settle does, so no later open
+ * finds it pending, and the next message is sent alone. It is the write behind
+ * `AdapterSession.settleOpenTurn()` for a turn the person stopped, which is never resumed. The adapter checks that a
+ * turn is open. The end is the kernel's for the session's own stop (`abortedOutcome` of its `SessionHalt`), the one
+ * path an interrupted turn's end takes, though the turn never ran in this process.
+ */
+export async function settleTurn(drive) {
+    for (const submission of pendingSubmissions(drive.state()))
+        await drive.submit({ id: `withdraw:${submission.id}`, kind: "withdraw", target: submission.id });
+    const { status, error } = abortedOutcome(AbortSignal.abort(new SessionHalt("interrupted")));
+    const journal = new NativeJournal(drive);
+    journal.message({ type: "turn", status, ...(error === undefined ? {} : { error }) });
+    await journal.flush();
+}

package/dist/process/tail.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A line-complete tail of an append-only file (a JSONL transcript, a
+ * rollout): `read()` returns the lines completed since the last read and
+ * keeps a partial last line for the next one. For mirroring a native
+ * session file into the journal as the harness writes it.
+ */
+export declare class FileTail {
+    readonly path: string;
+    /** Byte offset already consumed (the length of what the journal already holds). */
+    offset: number;
+    constructor(path: string, 
+    /** Byte offset already consumed (the length of what the journal already holds). */
+    offset?: number);
+    /**
+     * The complete lines appended since the last read. Throws if the file is
+     * now shorter than what was read: it was rewritten, not appended to, and
+     * the journal can no longer mirror it line by line.
+     */
+    read(): string[];
+}

package/dist/process/tail.js

@@ -0,0 +1,53 @@
+// Copyright 2026 Vercel Inc. Licensed under the Apache License, Version 2.0; see LICENSE in this package.
+// From github.com/vercel-labs/durable-harness, packages/harness-process/src/tail.ts at ea8aa4060c (UPSTREAM.json records its blob and sha256).
+// Changed by Parcha, patches: 002-message-prefix
+import { closeSync, fstatSync, openSync, readSync } from 'node:fs';
+/**
+ * A line-complete tail of an append-only file (a JSONL transcript, a
+ * rollout): `read()` returns the lines completed since the last read and
+ * keeps a partial last line for the next one. For mirroring a native
+ * session file into the journal as the harness writes it.
+ */
+export class FileTail {
+    path;
+    offset;
+    constructor(path, 
+    /** Byte offset already consumed (the length of what the journal already holds). */
+    offset = 0) {
+        this.path = path;
+        this.offset = offset;
+    }
+    /**
+     * The complete lines appended since the last read. Throws if the file is
+     * now shorter than what was read: it was rewritten, not appended to, and
+     * the journal can no longer mirror it line by line.
+     */
+    read() {
+        let fd;
+        try {
+            fd = openSync(this.path, 'r');
+        }
+        catch (err) {
+            if (err.code === 'ENOENT')
+                return [];
+            throw err;
+        }
+        try {
+            const size = fstatSync(fd).size;
+            if (size < this.offset)
+                throw new Error(`agentrun-kernel: ${this.path} shrank from ${this.offset} to ${size} bytes`);
+            if (size === this.offset)
+                return [];
+            const buf = Buffer.alloc(size - this.offset);
+            readSync(fd, buf, 0, buf.length, this.offset);
+            const last = buf.lastIndexOf(0x0a);
+            if (last < 0)
+                return [];
+            this.offset += last + 1;
+            return buf.subarray(0, last).toString('utf8').split('\n');
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+}

package/dist/process/tools.d.ts

@@ -0,0 +1,105 @@
+import { type DriveContext, type EffectError, type HostTool, type ReplayPolicy } from '../kernel/index.js';
+import { type ToolImage } from '../types.js';
+/**
+ * The tool bridge: `HostTool`s as a harness-neutral list a port maps onto its
+ * harness's own tool mechanism (Codex's dynamic tools).
+ *
+ * Each call runs the kernel's effect sandwich keyed by the harness's own
+ * tool-call id, `tool:<callId>`, step name `tool.<name>`, with the tool's
+ * replay policy: a call the log already finished returns its recorded
+ * result without running (a resumed harness that re-issues a call gets the
+ * same answer), a `replay: 'never'` call interrupted by a crash comes back
+ * as an interrupted result, never a second run. With the harness's built-in
+ * tools turned off, these are its only tools, so every side effect it can
+ * cause has an intent in the log before it runs.
+ *
+ * Every result a harness gets passes here, so here it is held to the host's
+ * bound: a text past HOST_RESULT_MAX_CHARS keeps its start and says where it
+ * was cut (`boundResult`), the call's record keeping it whole.
+ */
+/** What a call returns to the harness. */
+export interface ToolResult {
+    text: string;
+    /** The call failed (its recorded error) or was interrupted. */
+    isError: boolean;
+    /** The call's intent was committed and its outcome lost (see `EffectError.interrupted`). */
+    interrupted?: boolean;
+    /** Images the tool answered with, as it gave them (recorded with its outcome). */
+    images?: readonly ToolImage[];
+    /** The text was cut at HOST_RESULT_MAX_CHARS (`boundResult`); it says so in its last line. */
+    truncated?: true;
+}
+/** One tool, harness-neutral. */
+export interface BridgedTool {
+    name: string;
+    description: string;
+    /** JSON Schema for the input (`zodShapeFromJsonSchema` turns it into zod for SDKs that want that). */
+    inputSchema: Record<string, unknown>;
+    replay: ReplayPolicy;
+    /**
+     * Run the call. `callId` is the harness's id for this call (Codex's
+     * call_id); it must be stable across a resume of
+     * the harness's session, since it is the memo key. `signal` is the
+     * harness's own cancellation, if it has one; the drive's is always applied.
+     */
+    call(args: unknown, callId: string, signal?: AbortSignal): Promise<ToolResult>;
+}
+export interface ToolBridgeOptions {
+    /**
+     * Runs before a `replay: 'never'` call that the log has not finished:
+     * the place for `journal.flush()`, so the harness's record of the call is
+     * in the log before the call's intent is.
+     */
+    beforeNever?: (call: {
+        name: string;
+        callId: string;
+        args: unknown;
+    }) => Promise<void>;
+    /** Serialize calls (a per-drive mutex). Default true: concurrent effects in one drive are not exercised yet. */
+    serial?: boolean;
+    /** Publish `tool_start` / `tool_end` on `ctx.live` for calls that run. Default true. */
+    live?: boolean;
+    /** How much of a partial output an interrupted result quotes. Default 2000 characters. */
+    partialChars?: number;
+}
+export interface ToolBridge {
+    tools: BridgedTool[];
+    get(name: string): BridgedTool | undefined;
+    /** Run a call by tool name. An unknown name is an error result, not a throw. */
+    call(name: string, args: unknown, callId: string, signal?: AbortSignal): Promise<ToolResult>;
+}
+/** A promise-chain mutex. */
+export declare class Mutex {
+    private tail;
+    run<T>(fn: () => Promise<T>): Promise<T>;
+}
+/** The memo key of a tool call. */
+export declare const toolKey: (callId: string) => string;
+/**
+ * Build the bridge for one drive. The calls' effects are this drive's: build
+ * a new bridge per `drive(ctx)`.
+ *
+ * A call whose effect throws anything but a committed failure (the drive was
+ * preempted, a recovery resolved the call first, the World refused a write)
+ * halts the drive (`ctx.halt`) and rethrows: the harness must not be handed
+ * a result the log does not have, and its runtime must stop.
+ */
+export declare function toolBridge(ctx: DriveContext, tools: HostTool[], options?: ToolBridgeOptions): ToolBridge;
+/**
+ * The text a harness gets for a failed call: the error, or for an
+ * interrupted one, what the kernel recorded ("may or may not have taken
+ * effect") plus the last progress it reported.
+ */
+export declare function failureText(error: EffectError, partialChars?: number): string;
+/**
+ * `text` within HOST_RESULT_MAX_CHARS characters, as a harness gets a call's
+ * result: a longer one keeps its start, cut before a character written as a
+ * surrogate pair rather than between its halves, and ends with a line saying
+ * so, `[cut at N of M characters]`, counted in the bound. `truncated` when cut.
+ */
+export declare function boundResult(text: string): {
+    text: string;
+    truncated?: true;
+};
+/** At most `max` characters, with a marker when cut. */
+export declare function clip(text: string, max: number): string;

package/dist/process/tools.js

@@ -0,0 +1,120 @@
+// Copyright 2026 Vercel Inc. Licensed under the Apache License, Version 2.0; see LICENSE in this package.
+// From github.com/vercel-labs/durable-harness, packages/harness-process/src/tools.ts at ea8aa4060c (UPSTREAM.json records its blob and sha256).
+// Changed by Parcha, imports rewritten for AgentRun; patches: 002-message-prefix, 003-comments-name-this-host, 008-tool-images, 011-result-bound
+import { EffectFailure, hostToolIO } from '../kernel/index.js';
+import { HOST_RESULT_MAX_CHARS } from '../types.js';
+/** A promise-chain mutex. */
+export class Mutex {
+    tail = Promise.resolve();
+    run(fn) {
+        const run = this.tail.then(fn, fn);
+        this.tail = run.catch(() => { });
+        return run;
+    }
+}
+/** The memo key of a tool call. */
+export const toolKey = (callId) => `tool:${callId}`;
+/**
+ * Build the bridge for one drive. The calls' effects are this drive's: build
+ * a new bridge per `drive(ctx)`.
+ *
+ * A call whose effect throws anything but a committed failure (the drive was
+ * preempted, a recovery resolved the call first, the World refused a write)
+ * halts the drive (`ctx.halt`) and rethrows: the harness must not be handed
+ * a result the log does not have, and its runtime must stop.
+ */
+export function toolBridge(ctx, tools, options = {}) {
+    const mutex = new Mutex();
+    const serial = options.serial ?? true;
+    const live = options.live ?? true;
+    const bridged = tools.map((tool) => {
+        const run = async (args, callId, signal) => {
+            if (!callId)
+                throw new TypeError(`agentrun-kernel: a call to ${tool.name} has no call id; derive a stable one`);
+            const key = toolKey(callId);
+            const fresh = !ctx.isMemoized(key);
+            if (fresh && tool.replay === 'never')
+                await options.beforeNever?.({ name: tool.name, callId, args });
+            if (fresh && live)
+                ctx.live({ type: 'tool_start', name: tool.name, args, callId });
+            try {
+                const output = await ctx.effect(key, {
+                    name: `tool.${tool.name}`,
+                    replay: tool.replay,
+                    input: args,
+                    ...(tool.requires ? { requires: tool.requires } : {}),
+                    ...(tool.needs?.length ? { needs: tool.needs } : {}),
+                }, (io) => tool.execute(args, hostToolIO(io, ctx, { signal: signal ? AbortSignal.any([signal, io.signal]) : io.signal })));
+                // A tool answers in text, or in text with images (a screenshot): the images come back as recorded.
+                const { text: whole, images } = typeof output === 'object' && output !== null ? output : { text: String(output), images: undefined };
+                const { text, truncated } = boundResult(String(whole));
+                if (fresh && live)
+                    ctx.live({ type: 'tool_end', name: tool.name, callId, result: text, ...(truncated ? { truncated } : {}) });
+                return { text, isError: false, ...(images?.length ? { images } : {}), ...(truncated ? { truncated } : {}) };
+            }
+            catch (err) {
+                if (err instanceof EffectFailure) {
+                    const { text, truncated } = boundResult(failureText(err.error, options.partialChars));
+                    if (fresh && live)
+                        ctx.live({ type: 'tool_end', name: tool.name, callId, isError: true, result: text, ...(truncated ? { truncated } : {}) });
+                    return { text, isError: true, ...(err.error.interrupted ? { interrupted: true } : {}), ...(truncated ? { truncated } : {}) };
+                }
+                ctx.halt?.(err);
+                throw err;
+            }
+        };
+        return {
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+            replay: tool.replay,
+            call: (args, callId, signal) => (serial ? mutex.run(() => run(args, callId, signal)) : run(args, callId, signal)),
+        };
+    });
+    const byName = new Map(bridged.map((t) => [t.name, t]));
+    return {
+        tools: bridged,
+        get: (name) => byName.get(name),
+        call: async (name, args, callId, signal) => {
+            const tool = byName.get(name);
+            if (!tool)
+                return { text: `unknown tool: ${name}`, isError: true };
+            return tool.call(args, callId, signal);
+        },
+    };
+}
+/**
+ * The text a harness gets for a failed call: the error, or for an
+ * interrupted one, what the kernel recorded ("may or may not have taken
+ * effect") plus the last progress it reported.
+ */
+export function failureText(error, partialChars = 2000) {
+    const message = error.message || 'the tool failed with no message';
+    if (!error.interrupted)
+        return message;
+    const last = error.partial?.at(-1);
+    if (last === undefined)
+        return message;
+    const text = typeof last === 'string' ? last : JSON.stringify(last);
+    return `${message}\nPartial output before the interruption:\n${clip(text, partialChars)}`;
+}
+/**
+ * `text` within HOST_RESULT_MAX_CHARS characters, as a harness gets a call's
+ * result: a longer one keeps its start, cut before a character written as a
+ * surrogate pair rather than between its halves, and ends with a line saying
+ * so, `[cut at N of M characters]`, counted in the bound. `truncated` when cut.
+ */
+export function boundResult(text) {
+    if (text.length <= HOST_RESULT_MAX_CHARS)
+        return { text };
+    const note = (kept) => `\n[cut at ${kept} of ${text.length} characters]`;
+    // The note's own length counted at the bound: what is kept is never longer than that, so neither is its note.
+    let kept = HOST_RESULT_MAX_CHARS - note(HOST_RESULT_MAX_CHARS).length;
+    if ((text.charCodeAt(kept - 1) & 0xfc00) === 0xd800 && (text.charCodeAt(kept) & 0xfc00) === 0xdc00)
+        kept -= 1;
+    return { text: `${text.slice(0, kept)}${note(kept)}`, truncated: true };
+}
+/** At most `max` characters, with a marker when cut. */
+export function clip(text, max) {
+    return text.length <= max ? text : `${text.slice(0, max)}… [${text.length - max} more characters]`;
+}

package/dist/process/zod.d.ts

@@ -0,0 +1,32 @@
+/**
+ * JSON Schema to zod, for harness SDKs whose tool APIs take zod (the Claude
+ * Agent SDK's in-process MCP tools, OpenCode's plugin tools). `HostTool`s carry
+ * JSON Schema; this converts the subset tool schemas use.
+ *
+ * zod is passed in (`import { z } from 'zod'`, v3 or v4) so this package
+ * does not pin one: use the one the harness SDK was built against.
+ *
+ * Adapted from the AI SDK's bridge (vercel/ai cbb6b49,
+ * `packages/harness-claude-code/src/bridge/json-schema-to-zod.ts`,
+ * Apache-2.0); changed to take `z` as a parameter and to export the shape.
+ */
+type Z = any;
+type ZodType = any;
+export interface JsonSchemaObject {
+    type?: string | string[];
+    description?: string;
+    properties?: Record<string, JsonSchemaObject>;
+    additionalProperties?: boolean | JsonSchemaObject;
+    required?: string[];
+    items?: JsonSchemaObject | JsonSchemaObject[];
+    enum?: unknown[];
+    const?: unknown;
+    oneOf?: JsonSchemaObject[];
+    anyOf?: JsonSchemaObject[];
+    nullable?: boolean;
+}
+/** A zod object for a JSON Schema object (extra properties allowed unless `additionalProperties: false`). */
+export declare function zodFromJsonSchema(schema: unknown, z: Z): ZodType;
+/** The raw shape (`{ key: zodType }`) of a JSON Schema object, for APIs that take a shape. */
+export declare function zodShapeFromJsonSchema(schema: unknown, z: Z): Record<string, ZodType>;
+export {};