@inflexa-ai/harness 0.45.1 → 0.46.2

package/dist/lib/test/text-shapes.js

@@ -0,0 +1,63 @@
+/**
+ * Text shapes that the test files of several module families assert: the lowercase
+ * hex digest family, the tool-output reference, the six-digit hex color, and the
+ * paired-surrogate invariants of cut text. Each predicate reads the string with the
+ * string methods and the char codes, so no pattern lives here.
+ */
+function isLowerHex(text) {
+    return Array.from(text).every((char) => (char >= "0" && char <= "9") || (char >= "a" && char <= "f"));
+}
+/** Whether `text` is exactly `length` lowercase hex characters. */
+export function isLowerHexOfLength(text, length) {
+    return text.length === length && isLowerHex(text);
+}
+/** Whether `text` is a `sha256:` content hash over a 64-digit lowercase hex digest. */
+export function isSha256Hash(text) {
+    return text.startsWith("sha256:") && isLowerHexOfLength(text.slice("sha256:".length), 64);
+}
+/** Whether `text` is a tool-output reference: `to_` over 20 lowercase hex characters. */
+export function isToolOutputRef(text) {
+    return text.startsWith("to_") && isLowerHexOfLength(text.slice("to_".length), 20);
+}
+/**
+ * The tool-output reference that a cut-result marker names, or undefined when the text
+ * names none. The marker reads `reference "to_<20 hex>"`, and the reference ends at its
+ * closing quote.
+ */
+export function referencedToolOutput(text) {
+    const opener = 'reference "';
+    const at = text.indexOf(opener);
+    if (at < 0)
+        return undefined;
+    const start = at + opener.length;
+    const ref = text.slice(start, start + "to_".length + 20);
+    if (!isToolOutputRef(ref) || text.charAt(start + ref.length) !== '"')
+        return undefined;
+    return ref;
+}
+/** Whether `text` is an RGB color in the six-digit lowercase hex form: `#1a2b3c`. */
+export function isHexColor(text) {
+    return text.startsWith("#") && isLowerHexOfLength(text.slice(1), 6);
+}
+function isHighSurrogate(unit) {
+    return unit >= 0xd800 && unit <= 0xdbff;
+}
+function isLowSurrogate(unit) {
+    return unit >= 0xdc00 && unit <= 0xdfff;
+}
+/** Whether `text` holds a high surrogate that no low surrogate follows. */
+export function hasLoneHighSurrogate(text) {
+    for (let i = 0; i < text.length; i++) {
+        if (isHighSurrogate(text.charCodeAt(i)) && !isLowSurrogate(text.charCodeAt(i + 1)))
+            return true;
+    }
+    return false;
+}
+/** Whether `text` holds a low surrogate that no high surrogate precedes. */
+export function hasLoneLowSurrogate(text) {
+    for (let i = 0; i < text.length; i++) {
+        if (isLowSurrogate(text.charCodeAt(i)) && !isHighSurrogate(text.charCodeAt(i - 1)))
+            return true;
+    }
+    return false;
+}

package/dist/lib/text.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Text shapes shared across module families: whitespace runs, line
+ * boundaries, separator cuts, trailing cutsets, and the all-one-class
+ * predicates. Each is built on the string methods, so no pattern exists
+ * here.
+ */
+/** Collapse every run of whitespace to one space and trim both ends. */
+export declare function collapseWhitespace(text: string): string;
+/** Split on CRLF or LF; a `\r` not followed by `\n` stays in its line. */
+export declare function splitLines(text: string): string[];
+/** The text before the first occurrence of any character of `separators`. */
+export declare function firstSegmentOf(text: string | undefined, separators: string): string | undefined;
+/** Whether any character of `text` is whitespace. */
+export declare function hasWhitespace(text: string): boolean;
+/** Strip every trailing character that appears in `cutset`. */
+export declare function trimTrailingOf(text: string, cutset: string): string;
+/** Whether every character of `text` is a decimal digit; the empty text is all digits. */
+export declare function isAllDigits(text: string): boolean;
+/** Whether every character of `text` is a hexadecimal digit; the empty text is all hex. */
+export declare function isAllHex(text: string): boolean;
+/** The dash-separated calendar form `YYYY-MM-DD`; the digit runs stay unchecked against the calendar. */
+export declare const ISO_DATE_PATTERN: RegExp;

package/dist/lib/text.js

@@ -0,0 +1,68 @@
+/**
+ * Text shapes shared across module families: whitespace runs, line
+ * boundaries, separator cuts, trailing cutsets, and the all-one-class
+ * predicates. Each is built on the string methods, so no pattern exists
+ * here.
+ */
+const WHITESPACE = "\t\n\v\f\r \u00a0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000\ufeff";
+function isWhitespace(char) {
+    return WHITESPACE.includes(char);
+}
+/** Collapse every run of whitespace to one space and trim both ends. */
+export function collapseWhitespace(text) {
+    let out = "";
+    let inWhitespaceRun = false;
+    for (const char of text) {
+        if (isWhitespace(char)) {
+            inWhitespaceRun = true;
+            continue;
+        }
+        if (inWhitespaceRun && out.length > 0)
+            out += " ";
+        inWhitespaceRun = false;
+        out += char;
+    }
+    return out;
+}
+/** Split on CRLF or LF; a `\r` not followed by `\n` stays in its line. */
+export function splitLines(text) {
+    return text.split("\n").map((line, index, lines) => (index < lines.length - 1 && line.endsWith("\r") ? line.slice(0, -1) : line));
+}
+/** The text before the first occurrence of any character of `separators`. */
+export function firstSegmentOf(text, separators) {
+    if (text === undefined)
+        return undefined;
+    let end = text.length;
+    for (const separator of separators) {
+        const at = text.indexOf(separator);
+        if (at >= 0 && at < end)
+            end = at;
+    }
+    return text.slice(0, end);
+}
+/** Whether any character of `text` is whitespace. */
+export function hasWhitespace(text) {
+    return Array.from(text).some(isWhitespace);
+}
+/** Strip every trailing character that appears in `cutset`. */
+export function trimTrailingOf(text, cutset) {
+    let end = text.length;
+    while (end > 0 && cutset.includes(text.charAt(end - 1)))
+        end--;
+    return text.slice(0, end);
+}
+function isAsciiDigit(char) {
+    return char >= "0" && char <= "9";
+}
+const HEX_DIGITS = "0123456789abcdefABCDEF";
+/** Whether every character of `text` is a decimal digit; the empty text is all digits. */
+export function isAllDigits(text) {
+    return Array.from(text).every(isAsciiDigit);
+}
+/** Whether every character of `text` is a hexadecimal digit; the empty text is all hex. */
+export function isAllHex(text) {
+    return Array.from(text).every((char) => HEX_DIGITS.includes(char));
+}
+/** The dash-separated calendar form `YYYY-MM-DD`; the digit runs stay unchecked against the calendar. */
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- a zod `.regex` is the only form that reaches the JSON Schema `pattern` of a model-facing tool input.
+export const ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;

package/dist/lib/thrown.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The reads over an arbitrary thrown value at a catch site: is it already an
+ * `Error`, and which of its `message` / `name` fields carry text. Every read
+ * but {@link errorOf} is structural, so a thrown value from another module
+ * realm — where `instanceof` against this build's class reference would miss —
+ * answers too.
+ */
+/**
+ * The exact `Error` passthrough. A thrown value that IS an `Error` comes back
+ * as itself (class, `.cause`, and own fields intact); anything else gives
+ * `undefined`. The class check is deliberate: a structural lookalike must not
+ * pass, because each caller rethrows or forwards the value as an `Error`.
+ */
+export declare function errorOf(value: unknown): Error | undefined;
+/** The thrown value's own `message` text, when it carries one. */
+export declare function errorMessageOf(value: unknown): string | undefined;
+/** The thrown value's own `name`, when it carries one. */
+export declare function errorNameOf(value: unknown): string | undefined;

package/dist/lib/thrown.js

@@ -0,0 +1,30 @@
+/**
+ * The reads over an arbitrary thrown value at a catch site: is it already an
+ * `Error`, and which of its `message` / `name` fields carry text. Every read
+ * but {@link errorOf} is structural, so a thrown value from another module
+ * realm — where `instanceof` against this build's class reference would miss —
+ * answers too.
+ */
+/**
+ * The exact `Error` passthrough. A thrown value that IS an `Error` comes back
+ * as itself (class, `.cause`, and own fields intact); anything else gives
+ * `undefined`. The class check is deliberate: a structural lookalike must not
+ * pass, because each caller rethrows or forwards the value as an `Error`.
+ */
+export function errorOf(value) {
+    return value instanceof Error ? value : undefined;
+}
+/** The thrown value's own `message` text, when it carries one. */
+export function errorMessageOf(value) {
+    if (typeof value !== "object" || value === null || !("message" in value))
+        return undefined;
+    const { message } = value;
+    return typeof message === "string" ? message : undefined;
+}
+/** The thrown value's own `name`, when it carries one. */
+export function errorNameOf(value) {
+    if (typeof value !== "object" || value === null || !("name" in value))
+        return undefined;
+    const { name } = value;
+    return typeof name === "string" ? name : undefined;
+}

package/dist/lib/unknown-array.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A type predicate over a value no parser has shaped yet. `Array.isArray`
+ * alone narrows `unknown` to `any[]`; this guard yields `unknown[]`, so each
+ * element must narrow before use.
+ */
+export declare function isUnknownArray(value: unknown): value is unknown[];

package/dist/lib/unknown-array.js

@@ -0,0 +1,8 @@
+/**
+ * A type predicate over a value no parser has shaped yet. `Array.isArray`
+ * alone narrows `unknown` to `any[]`; this guard yields `unknown[]`, so each
+ * element must narrow before use.
+ */
+export function isUnknownArray(value) {
+    return Array.isArray(value);
+}

package/dist/lib/unknown-containers.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The generic containers that a walk accepts, as zod schemas.
+ *
+ * A walk over untyped data takes the container shape at its entry and keeps each field and each entry
+ * `unknown`, so every read narrows on its own. The record schema refuses an array, where a
+ * `typeof x === "object"` probe would accept one.
+ */
+import { z } from "zod";
+/** A record whose fields the walk narrows one by one. */
+export declare const UnknownRecordSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+/** An array whose entries the walk narrows one by one. */
+export declare const UnknownArraySchema: z.ZodArray<z.ZodUnknown>;
+/** The record that a value holds, or `undefined` when the value holds no record. */
+export declare function parseUnknownRecord(value: unknown): Record<string, unknown> | undefined;

package/dist/lib/unknown-containers.js

@@ -0,0 +1,17 @@
+/**
+ * The generic containers that a walk accepts, as zod schemas.
+ *
+ * A walk over untyped data takes the container shape at its entry and keeps each field and each entry
+ * `unknown`, so every read narrows on its own. The record schema refuses an array, where a
+ * `typeof x === "object"` probe would accept one.
+ */
+import { z } from "zod";
+/** A record whose fields the walk narrows one by one. */
+export const UnknownRecordSchema = z.record(z.string(), z.unknown());
+/** An array whose entries the walk narrows one by one. */
+export const UnknownArraySchema = z.array(z.unknown());
+/** The record that a value holds, or `undefined` when the value holds no record. */
+export function parseUnknownRecord(value) {
+    const parsed = UnknownRecordSchema.safeParse(value);
+    return parsed.success ? parsed.data : undefined;
+}

package/dist/lib/unknown-text.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The text form of a value whose type stopped at `unknown`: a string stays
+ * itself, each primitive keeps its `String` render — a missing value names
+ * itself as `null` / `undefined`, the `String` form the diagnostic fields
+ * read — and a record or array renders as JSON, so no object reaches a message
+ * as `[object Object]`.
+ */
+export declare function textOf(value: unknown): string;

package/dist/lib/unknown-text.js

@@ -0,0 +1,28 @@
+/**
+ * The text form of a value whose type stopped at `unknown`: a string stays
+ * itself, each primitive keeps its `String` render — a missing value names
+ * itself as `null` / `undefined`, the `String` form the diagnostic fields
+ * read — and a record or array renders as JSON, so no object reaches a message
+ * as `[object Object]`.
+ */
+function jsonTextOf(value) {
+    let json;
+    try {
+        json = JSON.stringify(value);
+    }
+    catch {
+        // A cycle or a bigint inside the value throws here.
+    }
+    // `toJSON` giving `undefined` stringifies to `undefined` rather than throwing; both
+    // non-strings fall to the default object stringification, the render `String` gives.
+    return json ?? Object.prototype.toString.call(value);
+}
+export function textOf(value) {
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || typeof value === "symbol")
+        return String(value);
+    if (typeof value === "function")
+        return String(value);
+    return value === undefined || value === null ? String(value) : jsonTextOf(value);
+}

package/dist/lib/zod-issue-shape.d.ts

@@ -16,6 +16,6 @@
  *
  * Example: `runId: invalid_type (expected string)`.
  */
-import type { z } from "zod";
+import { z } from "zod";
 /** Describe the issues of `error` against `schema`, one entry for each issue. */
 export declare function describeZodIssueShapes(error: z.ZodError, schema: z.ZodType): string[];

package/dist/lib/zod-issue-shape.js

@@ -16,6 +16,7 @@
  *
  * Example: `runId: invalid_type (expected string)`.
  */
+import { z } from "zod";
 /** The most issues that one failure describes. */
 const MAX_ISSUES = 10;
 /** The cap of one entry, in characters. */
@@ -72,50 +73,49 @@ function schemaPath(schema, path) {
 }
 /** The schema of the declared field `key`, looking through wrappers and unions. */
 function fieldOf(schema, key) {
-    const def = unwrap(schema)._zod.def;
-    if (def.type === "object")
-        return Object.hasOwn(def.shape, key) ? def.shape[key] : undefined;
-    if (def.type === "union") {
-        for (const option of def.options) {
+    const inner = unwrap(schema);
+    if (inner instanceof z.ZodObject) {
+        const shape = inner.shape;
+        return Object.hasOwn(shape, key) ? shape[key] : undefined;
+    }
+    if (inner instanceof z.ZodUnion) {
+        for (const option of inner.options) {
             const field = fieldOf(option, key);
             if (field !== undefined)
                 return field;
         }
+        return undefined;
     }
-    if (def.type === "intersection")
-        return fieldOf(def.left, key) ?? fieldOf(def.right, key);
+    if (inner instanceof z.ZodIntersection)
+        return fieldOf(inner.def.left, key) ?? fieldOf(inner.def.right, key);
     return undefined;
 }
 function elementOf(schema, index) {
-    const def = unwrap(schema)._zod.def;
-    if (def.type === "array")
-        return def.element;
-    if (def.type === "tuple")
-        return def.items[index] ?? def.rest ?? undefined;
+    const inner = unwrap(schema);
+    if (inner instanceof z.ZodArray)
+        return inner.element;
+    if (inner instanceof z.ZodTuple)
+        return inner.def.items[index] ?? inner.def.rest ?? undefined;
     return undefined;
 }
 function unwrap(schema) {
     let current = schema;
     for (let depth = 0; depth < 16; depth++) {
-        const def = current._zod.def;
-        switch (def.type) {
-            case "optional":
-            case "nullable":
-            case "default":
-            case "prefault":
-            case "nonoptional":
-            case "catch":
-            case "readonly":
-                current = def.innerType;
-                break;
-            case "pipe":
-                current = def.in;
-                break;
-            case "lazy":
-                current = def.getter();
-                break;
-            default:
-                return current;
+        if (current instanceof z.ZodOptional ||
+            current instanceof z.ZodNullable ||
+            current instanceof z.ZodDefault ||
+            current instanceof z.ZodPrefault ||
+            current instanceof z.ZodNonOptional ||
+            current instanceof z.ZodCatch ||
+            current instanceof z.ZodReadonly ||
+            current instanceof z.ZodLazy) {
+            current = current.unwrap();
+        }
+        else if (current instanceof z.ZodPipe) {
+            current = current.in;
+        }
+        else {
+            return current;
         }
     }
     return current;

package/dist/lib/zod-issues.d.ts

@@ -14,7 +14,7 @@
  *    string.
  *
  * This module owns both halves of the response for the three model-facing
- * validation sites (`loop/run-agent.ts`'s tool-input boundary,
+ * validation sites (`loop/tool-adapter.ts`'s tool-input boundary,
  * `execution/run-synthesis.ts`, `tools/research/generate-plan.ts`):
  *
  *  - `hintForZodIssue` — a **diagnostic only**. It parses nothing into the
@@ -42,7 +42,7 @@
  * human-readable `message`, which is version- and locale-dependent and must
  * not be pattern-matched.
  */
-import type { z } from "zod";
+import { z } from "zod";
 /**
  * A hint for a single Zod issue, or `undefined` when nothing actionable can be
  * said. `input` is the raw value that failed validation — the same value handed
@@ -81,7 +81,7 @@ export declare function hintForZodIssue(issue: z.core.$ZodIssue, input: unknown)
  * untouched branch and clones only along the paths it patches. Repaired content
  * is not re-examined — one pass, no recursion — and no input causes a throw.
  */
-export declare function repairToolInput(input: unknown, error: z.ZodError): unknown | undefined;
+export declare function repairToolInput(input: unknown, error: z.ZodError): unknown;
 /**
  * Decode a value that a model sent as a JSON-encoded object string, with or
  * without a wrapper artifact. The decoded object is returned when the string

package/dist/lib/zod-issues.js

@@ -14,7 +14,7 @@
  *    string.
  *
  * This module owns both halves of the response for the three model-facing
- * validation sites (`loop/run-agent.ts`'s tool-input boundary,
+ * validation sites (`loop/tool-adapter.ts`'s tool-input boundary,
  * `execution/run-synthesis.ts`, `tools/research/generate-plan.ts`):
  *
  *  - `hintForZodIssue` — a **diagnostic only**. It parses nothing into the
@@ -42,6 +42,10 @@
  * human-readable `message`, which is version- and locale-dependent and must
  * not be pattern-matched.
  */
+import { z } from "zod";
+import { parseJsonAs } from "./parse-json.js";
+import { isUnknownArray } from "./unknown-array.js";
+import { parseUnknownRecord, UnknownRecordSchema } from "./unknown-containers.js";
 /**
  * Strings longer than this are neither parsed nor repaired. A real argument
  * payload is tens of kilobytes; the ceiling exists so a pathological input
@@ -51,6 +55,7 @@ const MAX_REPAIRABLE_STRING_LENGTH = 1_000_000;
 /** Longest run of offending wrapper text quoted back to the model in a hint. */
 const HINT_SNIPPET_LENGTH = 40;
 /** A trailing `</parameter>`, optionally followed by `</invoke>`. */
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- the two call-tag closers of the model wire format, stripped from a repaired tool-call text.
 const TRAILING_CALL_TAGS = /<\/parameter>\s*(?:<\/invoke>\s*)?$/;
 /**
  * A hint for a single Zod issue, or `undefined` when nothing actionable can be
@@ -184,16 +189,14 @@ function repairableExpectation(issue) {
  * matches either expectation, but the cell keeps the caller's checks honest.
  */
 function parseAs(raw, expected) {
-    let parsed;
     try {
-        parsed = JSON.parse(raw);
+        if (expected === "array")
+            return { value: parseJsonAs(raw, z.array(z.json())) };
+        return { value: parseJsonAs(raw, UnknownRecordSchema) };
     }
     catch {
         return undefined;
     }
-    if (expected === "array")
-        return Array.isArray(parsed) ? { value: parsed } : undefined;
-    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? { value: parsed } : undefined;
 }
 /**
  * Strip the wrapper artifacts a model sticks to an otherwise complete JSON
@@ -213,12 +216,16 @@ function stripWrappers(raw) {
         text = text.slice(0, tags.index).trim();
     }
     if (text.startsWith("```")) {
-        const open = /^```(?:json)?\s*\n/i.exec(text);
+        const open = 
+        // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the markdown fence opener with its optional json tag and leading whitespace; the whitespace-to-newline rule is the fence grammar.
+        /^```(?:json)?\s*\n/i.exec(text);
         if (open !== null) {
             removed.push(open[0].trim());
             text = text.slice(open[0].length);
         }
-        const close = /\n```\s*$/.exec(text);
+        const close = 
+        // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the closing fence of a repaired block, with whatever whitespace the model left after it.
+        /\n```\s*$/.exec(text);
         if (close !== null) {
             removed.push("```");
             text = text.slice(0, close.index);
@@ -240,10 +247,10 @@ function quoteSnippet(removed) {
 function resolvePath(input, path) {
     let current = input;
     for (const key of path) {
-        if (current === null || (typeof current !== "object" && typeof current !== "function")) {
+        const container = isUnknownArray(current) ? current : parseUnknownRecord(current);
+        if (container === undefined)
             return undefined;
-        }
-        current = current[key];
+        current = Reflect.get(container, key);
     }
     return current;
 }
@@ -255,14 +262,20 @@ function setAtPath(root, path, value) {
     if (path.length === 0)
         return value;
     const [key, ...rest] = path;
-    if (root === null || typeof root !== "object")
-        return root;
-    const container = root;
-    const child = setAtPath(container[key], rest, value);
-    if (Array.isArray(root)) {
+    if (key === undefined)
+        return value;
+    const array = isUnknownArray(root);
+    if (array) {
+        const child = setAtPath(Reflect.get(root, key), rest, value);
+        if (typeof key !== "number")
+            return { ...Object.fromEntries(root.entries()), [key]: child };
         const copy = [...root];
         copy[key] = child;
         return copy;
     }
-    return { ...container, [key]: child };
+    const record = parseUnknownRecord(root);
+    if (record === undefined)
+        return root;
+    const child = setAtPath(Reflect.get(record, key), rest, value);
+    return { ...record, [key]: child };
 }

package/dist/literature/sources/arxiv.d.ts

@@ -1,5 +1,5 @@
 import { type SourceHttpOptions, type SourceHttpResult } from "./http.js";
-export interface ArxivPaper {
+export type ArxivPaper = {
     id: string;
     title: string;
     abstract: string;
@@ -8,15 +8,15 @@ export interface ArxivPaper {
     categories: string[];
     url: string;
     pdfUrl?: string;
-}
-export interface ArxivSearchInput {
+};
+export type ArxivSearchInput = {
     readonly query: string;
     readonly categories?: readonly string[];
     readonly limit: number;
-}
-export interface ArxivSource {
+};
+export type ArxivSource = {
     search(input: ArxivSearchInput, signal?: AbortSignal): Promise<SourceHttpResult<ArxivPaper[]>>;
     lookupExact(id: string, limit: number, signal?: AbortSignal): Promise<SourceHttpResult<ArxivPaper[]>>;
-}
+};
 export declare function parseArxivAtom(xml: string): ArxivPaper[];
 export declare function createArxivSource(options?: SourceHttpOptions): ArxivSource;