@actor0/harness 0.0.0-stage → 0.5.2

package/dist/plan-prefix.js

@@ -0,0 +1,59 @@
+const MAX_HEADING_LEN = 100;
+const MAX_PLAN_LEN = 1_200;
+function headingText(line) {
+    const match = /^\s{0,3}#{1,6}\s+(\S.*?)\s*#*\s*$/.exec(line);
+    if (!match)
+        return null;
+    const text = (match[1] ?? "").trim();
+    if (!text || text.length > MAX_HEADING_LEN)
+        return null;
+    return text;
+}
+export function parsePlanPrefix(buffer) {
+    const newline = buffer.indexOf("\n");
+    if (newline === -1)
+        return null;
+    const title = headingText(buffer.slice(0, newline));
+    if (!title)
+        return null;
+    let start = newline + 1;
+    let end = buffer.indexOf("\n\n", start);
+    if (buffer.startsWith("\n", start)) {
+        const second = buffer.indexOf("\n\n", start + 1);
+        const between = second === -1 ? "" : buffer.slice(start + 1, second);
+        if (second !== -1 && between.length > 0 && between.length <= MAX_PLAN_LEN) {
+            start += 1;
+            end = second;
+        }
+        else {
+            start = newline + 1;
+            end = newline;
+        }
+    }
+    if (end === -1)
+        return null;
+    const body = buffer.slice(start, end);
+    if (body.length > MAX_PLAN_LEN)
+        return null;
+    return {
+        title,
+        plan: buffer.slice(0, end).replace(/\s+$/, ""),
+        consumed: end + 2,
+    };
+}
+export function needsMorePlanData(buffer) {
+    if (!/^\s{0,3}(?:#{1,6}\s+|#{0,6}\s*$)/.test(buffer))
+        return false;
+    const newline = buffer.indexOf("\n");
+    if (newline === -1)
+        return true;
+    if (!headingText(buffer.slice(0, newline)))
+        return false;
+    return !buffer.includes("\n\n");
+}
+export function extractPlanPrefix(buffer) {
+    const plan = parsePlanPrefix(buffer);
+    return plan
+        ? { plan, rest: buffer.slice(plan.consumed) }
+        : { plan: null, rest: buffer };
+}

package/dist/protocol.d.ts

@@ -0,0 +1,21 @@
+import type { ChatMessage, HarnessEvent, ToolCall, ToolDefinition } from "./types.js";
+export type ModelConnection = {
+    baseUrl: string;
+    apiKey?: string;
+    model: string;
+};
+export type TurnRequest = {
+    connection: ModelConnection;
+    messages: ChatMessage[];
+    tools?: ToolDefinition[];
+};
+export type TurnResponseEvent = HarnessEvent | {
+    type: "turn_end";
+    text: string;
+    complete: boolean;
+    toolCalls: ToolCall[];
+};
+export declare function encodeEvent(event: TurnResponseEvent): Uint8Array;
+export declare function readEvents(response: Response): AsyncGenerator<TurnResponseEvent, void, unknown>;
+export declare function parseTurnRequest(value: unknown): TurnRequest;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEtF,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,UAAU,EAAE,eAAe,CAAC;IAC5B,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,KAAK,CAAC,EAAE,cAAc,EAAE,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,iBAAiB,GACzB,YAAY,GACZ;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,QAAQ,EAAE,CAAC;CACvB,CAAC;AAGN,wBAAgB,WAAW,CAAC,KAAK,EAAE,iBAAiB,GAAG,UAAU,CAEhE;AAED,wBAAuB,UAAU,CAC/B,QAAQ,EAAE,QAAQ,GACjB,cAAc,CAAC,iBAAiB,EAAE,IAAI,EAAE,OAAO,CAAC,CA4BlD;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CA2B5D"}

package/dist/protocol.js

@@ -0,0 +1,70 @@
+export function encodeEvent(event) {
+    return new TextEncoder().encode(`data: ${JSON.stringify(event)}\n\n`);
+}
+export async function* readEvents(response) {
+    if (!response.body)
+        throw new Error("response has no body");
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+        const { done, value } = await reader.read();
+        buffer += decoder.decode(value, { stream: !done });
+        const frames = buffer.split(/\r?\n\r?\n/);
+        buffer = frames.pop() ?? "";
+        for (const frame of frames) {
+            const data = frame
+                .split(/\r?\n/)
+                .filter((line) => line.startsWith("data:"))
+                .map((line) => line.slice(5).trim())
+                .join("\n");
+            if (data)
+                yield JSON.parse(data);
+        }
+        if (done)
+            break;
+    }
+    if (buffer.trim()) {
+        const data = buffer
+            .split(/\r?\n/)
+            .filter((line) => line.startsWith("data:"))
+            .map((line) => line.slice(5).trim())
+            .join("\n");
+        if (data)
+            yield JSON.parse(data);
+    }
+}
+export function parseTurnRequest(value) {
+    if (!isRecord(value))
+        throw new Error("request body must be an object");
+    const connection = value.connection;
+    const messages = value.messages;
+    if (!isRecord(connection))
+        throw new Error("connection is required");
+    if (typeof connection.baseUrl !== "string" || !connection.baseUrl.trim()) {
+        throw new Error("connection.baseUrl is required");
+    }
+    if (typeof connection.model !== "string" || !connection.model.trim()) {
+        throw new Error("connection.model is required");
+    }
+    if (connection.apiKey !== undefined && typeof connection.apiKey !== "string") {
+        throw new Error("connection.apiKey must be a string");
+    }
+    if (!Array.isArray(messages))
+        throw new Error("messages must be an array");
+    if (value.tools !== undefined && !Array.isArray(value.tools)) {
+        throw new Error("tools must be an array");
+    }
+    return {
+        connection: {
+            baseUrl: connection.baseUrl,
+            apiKey: connection.apiKey,
+            model: connection.model,
+        },
+        messages: messages,
+        tools: (value.tools ?? []),
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/reasoning-summary.d.ts

@@ -0,0 +1,15 @@
+import type { ReasoningSummary } from "./types.js";
+/**
+ * One line of model reasoning with the markup stripped off.
+ *
+ * A heading marker, a bold run or a list bullet means something to a markdown
+ * renderer and nothing to anyone reading a terminal. Left in, it is the
+ * transcript showing the model its own syntax: a conversation containing a
+ * literal "##" looks like a log dump rather than a thought.
+ *
+ * Exported because every surface that shows reasoning has to strip it, and a
+ * second copy of this in a renderer is a second set of rules for the same job.
+ */
+export declare function stripReasoningMarkup(line: string): string;
+export declare function formatReasoningSummary(text: string): ReasoningSummary;
+//# sourceMappingURL=reasoning-summary.d.ts.map

package/dist/reasoning-summary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reasoning-summary.d.ts","sourceRoot":"","sources":["../src/reasoning-summary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAKnD;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAUzD;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,CAsBrE"}

package/dist/reasoning-summary.js

@@ -0,0 +1,48 @@
+const MAX_TITLE = 90;
+const MAX_SUMMARY = 900;
+/**
+ * One line of model reasoning with the markup stripped off.
+ *
+ * A heading marker, a bold run or a list bullet means something to a markdown
+ * renderer and nothing to anyone reading a terminal. Left in, it is the
+ * transcript showing the model its own syntax: a conversation containing a
+ * literal "##" looks like a log dump rather than a thought.
+ *
+ * Exported because every surface that shows reasoning has to strip it, and a
+ * second copy of this in a renderer is a second set of rules for the same job.
+ */
+export function stripReasoningMarkup(line) {
+    return line
+        .replace(/^\s{0,3}#{1,6}\s+/, "")
+        .replace(/^\s*[-*+]\s+/, "")
+        .replace(/^\s*\d+[.)]\s+/, "")
+        .replace(/\*\*/g, "")
+        .replace(/[*_`]/g, "")
+        .replace(/\[·?\]/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function formatReasoningSummary(text) {
+    const lines = text.split("\n").map(stripReasoningMarkup).filter((line) => line.length > 0);
+    if (lines.length === 0)
+        return { title: "", summary: "" };
+    const bracketed = /^\[(?:·\s*)?([^\]]{2,60})\]$/.exec(lines[0] ?? "");
+    let title = "";
+    let body = lines;
+    if (bracketed) {
+        title = (bracketed[1] ?? "").trim().slice(0, MAX_TITLE);
+        body = lines.slice(1);
+    }
+    else if (lines.length > 1) {
+        const first = text.split("\n")[0] ?? "";
+        if (/^\s{0,3}(?:#{1,6}\s+|\*\*)/.test(first)) {
+            title = (lines[0] ?? "").slice(0, MAX_TITLE);
+            body = lines.slice(1);
+        }
+    }
+    const summary = body.join(" ").slice(0, MAX_SUMMARY);
+    if (!title && summary) {
+        title = (summary.split(/(?<=[.!?])\s/)[0] ?? "").slice(0, MAX_TITLE);
+    }
+    return { title, summary };
+}

package/dist/tool-call-block.d.ts

@@ -0,0 +1,141 @@
+import type { ToolCall } from "./types.js";
+/** Which envelope a buffered block is waiting for. */
+export type BlockKind = "fence" | "envelope";
+/**
+ * Give up on a block that never closes. An unterminated fence must not
+ * swallow the rest of the answer, and no legitimate tool call is this long.
+ */
+export declare const MAX_TOOL_BLOCK = 8000;
+/** True when `line` opens a tool-call candidate. */
+export declare function matchOpenFence(text: string): {
+    length: number;
+} | null;
+/**
+ * True when `text` could still grow into an opening fence but is not one yet.
+ *
+ * A fence routinely straddles a delta boundary ("``" + "`json\n"), and
+ * deciding per-delta would release the first half as text. This is the hold
+ * that makes the protocol recognisable no matter how the stream is chunked.
+ */
+export declare function mayBeOpenFence(text: string): boolean;
+/** True when `line` opens a `<tool_calls>` envelope. */
+export declare function matchOpenEnvelope(text: string): {
+    length: number;
+} | null;
+/**
+ * The `<tool_calls>` twin of `mayBeOpenFence`.
+ *
+ * SSE deltas are small enough that `<tool_` on one and `calls>` on the next is
+ * routine, and releasing the first half as text would leave `calls>` orphaned
+ * in the answer. Same hold, same reason.
+ */
+export declare function mayBeOpenEnvelope(text: string): boolean;
+/**
+ * Locate the closing `</tool_calls>`, resuming at `fromIndex`.
+ *
+ * `fromIndex` is the length of the part already buffered, and the scan starts
+ * `CLOSE_ENVELOPE_PREFIX` characters earlier on purpose: a close can straddle
+ * the boundary between the buffer and the new delta, and a delta boundary
+ * landing mid-tag is the *normal* case for a small-chunked SSE stream. Resuming
+ * exactly at `fromIndex` misses it forever, and the block then grows until it
+ * is released as text. Resuming from 0 would be correct too, just quadratic on
+ * a long unterminated block.
+ */
+export declare function matchCloseEnvelope(text: string, fromIndex?: number): {
+    index: number;
+    length: number;
+} | null;
+/**
+ * Locate the closing fence.
+ *
+ * Every fence is scanned, not just the first: the text handed in usually still
+ * contains the opening fence, which must be skipped rather than mistaken for
+ * the close. Mid-stream a close only counts once its newline has arrived, so a
+ * buffer ending in "``" is left pending; at end of stream (`atEnd`) a fence
+ * with no trailing newline is final and does count.
+ *
+ * Callers pass the whole buffered block, not just the newest delta: a fence can
+ * straddle the two, and a close hidden in the accumulated half is as real as
+ * one in the delta.
+ */
+export declare function matchCloseFence(text: string, atEnd?: boolean): {
+    index: number;
+    length: number;
+} | null;
+/** The JSON body of a complete block, without its fences. */
+export declare function blockBody(block: string): string;
+/**
+ * A protocol block that was recognised but refused: it named a tool this
+ * request never offered, or its arguments were not parseable JSON.
+ *
+ * Rejection is a protocol event, not prose. The old behaviour released the
+ * block as answer text, which taught the model nothing — it re-emitted the
+ * same block, and the user watched raw JSON scroll past. A rejected block now
+ * becomes a synthetic call plus an error tool result, so the next round opens
+ * with the model being told, in its own protocol, that the call was refused
+ * and why. The UI shows the same pair it shows for a failing tool: a cross
+ * against a name, with the reason.
+ */
+export type RejectedBlock = {
+    /** The name the model asked for, offered or not. For the error message. */
+    name: string;
+    /** The synthetic call that will carry the error result. */
+    call: ToolCall;
+    /** One sentence a model (and a user) can act on. */
+    reason: string;
+};
+/**
+ * Build the rejection record for a block whose JSON parsed but named a tool
+ * the request did not offer. The reason quotes the offered names so the model
+ * can pick a real one instead of guessing again.
+ */
+export declare function rejectUnknownTool(name: string, offered: string[]): RejectedBlock;
+/**
+ * Build the rejection record for a block that looked like a tool call but
+ * whose arguments were not valid JSON. The common cause is a raw newline or
+ * tab inside a string literal — the model formatted the command like shell
+ * output instead of escaping it — so the reason names that repair first. A
+ * body with no usable "name" gets the name-specific hint instead; the
+ * generic newline hint would be pointing at a fault it does not have.
+ */
+export declare function rejectMalformedArguments(detail: string, rawBody?: string): RejectedBlock;
+/**
+ * Parse a complete fenced block into a tool call.
+ *
+ * Returns null — meaning "this is ordinary answer text" — unless the block is
+ * a JSON object that says `type: "tool_call"` and carries a string `name`.
+ * The `type` check is what stops every other JSON example in every answer
+ * from being treated as protocol.
+ *
+ * The result says what happened: a `call` when the name is one the request
+ * actually offered, or a `rejected` record when it is not — including when
+ * the body is protocol-shaped but not valid JSON, the field case being a raw
+ * newline inside a string value. Rejected is not the same as text — the model
+ * addressed the protocol; the harness answers in the same protocol (see
+ * RejectedBlock).
+ */
+export declare function parseToolCallBlock(block: string, toolNames: string[]): ToolCall | RejectedBlock | null;
+/**
+ * The `<tool_calls>` body: every top-level `{…}` object, in order.
+ *
+ * Braces inside strings are ignored, so a title containing `}` cannot end the
+ * scan early. Anything that does not close is not an object and not a call.
+ */
+export declare function scanJsonObjects(text: string): string[];
+/**
+ * Parse a closed `<tool_calls>` envelope into the calls it carries.
+ *
+ * All-or-nothing, like the fence: an envelope is protocol only if *every*
+ * object in it is a call for a tool this request actually offered. One
+ * `set_conversation_title` in a `<tool_calls>` envelope is not a partial tool
+ * round to half-execute — it is a different assistant's protocol, and
+ * executing half of it would hide the mismatch. The first non-call object in
+ * the envelope therefore poisons the whole envelope: every call-shaped object
+ * before it becomes a rejection (the model addressed the protocol and is told
+ * so next round), and none of them executes.
+ */
+export declare function parseToolCallEnvelope(block: string, toolNames: string[]): {
+    calls: ToolCall[];
+    rejected: RejectedBlock[];
+};
+//# sourceMappingURL=tool-call-block.d.ts.map

package/dist/tool-call-block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-call-block.d.ts","sourceRoot":"","sources":["../src/tool-call-block.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AA6D3C,sDAAsD;AACtD,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,UAAU,CAAC;AAE7C;;;GAGG;AACH,eAAO,MAAM,cAAc,OAAQ,CAAC;AAIpC,oDAAoD;AACpD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAGtE;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGpD;AAED,wDAAwD;AACxD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAGzE;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAKvD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,SAAI,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAMxG;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,UAAQ,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAYrG;AAED,6DAA6D;AAC7D,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/C;AAKD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb,2DAA2D;IAC3D,IAAI,EAAE,QAAQ,CAAC;IACf,oDAAoD;IACpD,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,aAAa,CAehF;AAgBD;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,aAAa,CA0BxF;AAcD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,QAAQ,GAAG,aAAa,GAAG,IAAI,CAatG;AA4BD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAgCtD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG;IAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;IAAC,QAAQ,EAAE,aAAa,EAAE,CAAA;CAAE,CAiD1H"}