@haikeilabs/agentware 0.1.0 → 0.2.1

package/dist/reasoning/adapter.js

@@ -0,0 +1,365 @@
+// Model-agnostic reasoning adapter (mirrors go/reasoning/adapter.go).
+//
+// The adapter recognizes three shapes of model output:
+//   - native reasoning_content fields (DeepSeek/Qwen/Kimi/GLM-style JSON)
+//   - generic thinking tags (<thinking>...</thinking>, [THINK]...[/THINK])
+//   - model-specific reasoning fields (registered per model name)
+//
+// Reasoning is stripped before ordinary tool-call parsing, and the extracted
+// reasoning text is normalized into a versioned context tree. Raw reasoning is
+// never exposed in normal replies or default audits: tree nodes carry only
+// bounded summaries. The adapter fails closed on malformed or unbounded input.
+import { createHash } from "node:crypto";
+import { MalformedContentError, MalformedInputError, MalformedJSONError, MalformedReasoningFieldError, ReasoningError, ReasoningTooLargeError, TooDeepError, TooManyNodesError, UnbalancedThinkingError, } from "./errors.js";
+import { normalizeOptions } from "./options.js";
+import { CONTRACT_VERSION, Format, NodeKind, NodeStatus } from "./types.js";
+export { ReasoningError };
+// Known reasoning field names on a structured response, in priority order.
+// reasoning_content is the de-facto native field (DeepSeek, Qwen/QwQ, Kimi,
+// GLM); the others cover common model-specific names.
+const KNOWN_REASONING_FIELDS = ["reasoning_content", "thinking", "thinking_content", "reasoning"];
+// Keys that make a structured response worth entering the structured path. A
+// mapping without any of these is treated as opaque text and returned
+// unchanged.
+const RECOGNIZED_KEYS = new Set([
+    "message",
+    "content",
+    "reasoning_content",
+    "thinking",
+    "thinking_content",
+    "reasoning",
+]);
+const THINKING_OPEN = /<thinking>|\[THINK\]/i;
+const THINKING_CLOSE = /<\/thinking>|\[\/THINK\]/i;
+const PARAGRAPH_SEP = /\n[ \t]*\n/;
+const LIST_ORNAMENT = /^\s*(?:[-*+•]|\d+[.)])\s+/;
+const KIND_PREFIX = /^\s*(goal|observation|decision|tool-call|tool_call|tool-result|tool_result|tool|conclusion|blocker)\s*[:=]\s*/i;
+const STATUS_MARKER = /\s*\[(blocked|pending|active|superseded|complete)\]\s*$/i;
+const EVIDENCE_PATTERNS = [
+    /\[E\d+\]/g,
+    /\bref\s*[=:]\s*(\S+)/g,
+    /\bevidence\s*[=:]\s*(\S+)/g,
+];
+const TOOL_REF = /\b(?:tool|call)\s*[=:]\s*([a-zA-Z_][a-zA-Z0-9_.-]*)/;
+const LEADING_IDENTIFIER = /^([a-zA-Z_][a-zA-Z0-9_.-]*)\s*[:=]/;
+const BARE_IDENTIFIER = /^[a-zA-Z_][a-zA-Z0-9_.-]*$/;
+const KIND_BY_LABEL = {
+    goal: NodeKind.GOAL,
+    observation: NodeKind.OBSERVATION,
+    decision: NodeKind.DECISION,
+    "tool-call": NodeKind.TOOL_CALL,
+    tool_call: NodeKind.TOOL_CALL,
+    tool: NodeKind.TOOL_CALL,
+    "tool-result": NodeKind.TOOL_RESULT,
+    tool_result: NodeKind.TOOL_RESULT,
+    conclusion: NodeKind.CONCLUSION,
+    blocker: NodeKind.BLOCKER,
+};
+const STATUS_BY_LABEL = {
+    blocked: NodeStatus.BLOCKED,
+    pending: NodeStatus.ACTIVE,
+    active: NodeStatus.ACTIVE,
+    superseded: NodeStatus.SUPERSEDED,
+    complete: NodeStatus.COMPLETE,
+};
+function isRecord(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+export class ReasoningAdapter {
+    opts;
+    modelFields;
+    constructor(options) {
+        this.opts = normalizeOptions(options);
+        this.modelFields = new Map();
+    }
+    get options() {
+        return this.opts;
+    }
+    /** Map a model name to a model-specific reasoning field name. Fields
+     * registered here are consulted before the known field set. */
+    registerModelField(model, fieldName) {
+        if (model && fieldName) {
+            this.modelFields.set(model.toLowerCase(), fieldName);
+        }
+    }
+    /** Remove reasoning from raw and return the clean content that ordinary
+     * tool-call parsers should see. Fails closed. */
+    strip(raw) {
+        return this.analyze(raw, "").clean;
+    }
+    /** Normalize reasoning found in raw into a versioned context tree. Raw
+     * reasoning is never stored on the tree: nodes carry bounded summaries. */
+    extract(raw, model = "", backend = "") {
+        const analysis = this.analyze(raw, model);
+        const now = this.opts.clock();
+        const tree = {
+            version: CONTRACT_VERSION,
+            format: analysis.format,
+            model,
+            backend,
+            created_at: now,
+            root_id: "",
+            nodes: [],
+        };
+        if (analysis.reasoning.trim() === "") {
+            return tree;
+        }
+        const nodes = this.parseNodes(analysis.reasoning, now);
+        tree.nodes = nodes;
+        if (nodes.length > 0) {
+            tree.root_id = nodes[0].id;
+        }
+        return tree;
+    }
+    /** Strip and extract in one call: return the clean content and tree. */
+    parse(raw, model = "", backend = "") {
+        const analysis = this.analyze(raw, model);
+        return { clean: analysis.clean, tree: this.extract(raw, model, backend) };
+    }
+    analyze(raw, model) {
+        if (typeof raw === "string") {
+            return this.analyzeString(raw, model);
+        }
+        if (raw instanceof Uint8Array) {
+            return this.analyzeBytes(raw, model);
+        }
+        if (isRecord(raw)) {
+            return this.analyzeStructured(raw, model);
+        }
+        throw new MalformedInputError(`unsupported raw type ${typeof raw}`);
+    }
+    analyzeString(raw, model) {
+        const trimmed = raw.trim();
+        if (trimmed.startsWith("{")) {
+            let parsed;
+            try {
+                parsed = JSON.parse(trimmed);
+            }
+            catch (e) {
+                throw new MalformedJSONError(e instanceof Error ? e.message : String(e));
+            }
+            if (isRecord(parsed) && this.hasRecognizedKey(parsed)) {
+                return this.analyzeStructured(parsed, model);
+            }
+        }
+        return this.analyzeText(raw);
+    }
+    analyzeBytes(raw, model) {
+        const trimmed = raw.length > 0 ? new TextDecoder().decode(raw).trim() : "";
+        if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+            let parsed;
+            try {
+                parsed = JSON.parse(trimmed);
+            }
+            catch (e) {
+                throw new MalformedJSONError(e instanceof Error ? e.message : String(e));
+            }
+            if (isRecord(parsed) && this.hasRecognizedKey(parsed)) {
+                return this.analyzeStructured(parsed, model);
+            }
+        }
+        return this.analyzeText(trimmed);
+    }
+    analyzeStructured(m, model) {
+        const message = m["message"];
+        if (isRecord(message)) {
+            return this.analyzeStructured(message, model);
+        }
+        let content = "";
+        if ("content" in m) {
+            const value = m["content"];
+            if (value === null || value === undefined) {
+                content = "";
+            }
+            else if (typeof value === "string") {
+                content = value;
+            }
+            else {
+                throw new MalformedContentError(`content field is ${typeof value}, not a string`);
+            }
+        }
+        const [reasoning, format] = this.extractReasoningField(m, model);
+        if (reasoning !== "") {
+            return { reasoning, clean: splitThinkingTags(content).clean, format };
+        }
+        const result = splitThinkingTags(content);
+        if (result.reasoning !== "") {
+            return { reasoning: result.reasoning, clean: result.clean, format: Format.THINKING };
+        }
+        return { reasoning: "", clean: content, format: Format.NONE };
+    }
+    extractReasoningField(m, model) {
+        if (model) {
+            const fieldName = this.modelFields.get(model.toLowerCase());
+            if (fieldName) {
+                const value = m[fieldName];
+                if (value !== null && value !== undefined) {
+                    if (typeof value !== "string") {
+                        throw new MalformedReasoningFieldError(`field "${fieldName}" is ${typeof value}, not a string`);
+                    }
+                    if (value !== "") {
+                        return [value, Format.MODEL_SPECIFIC];
+                    }
+                }
+            }
+        }
+        for (const fieldName of KNOWN_REASONING_FIELDS) {
+            const value = m[fieldName];
+            if (value === null || value === undefined) {
+                continue;
+            }
+            if (typeof value !== "string") {
+                throw new MalformedReasoningFieldError(`field "${fieldName}" is ${typeof value}, not a string`);
+            }
+            if (value !== "") {
+                return [value, Format.NATIVE];
+            }
+        }
+        return ["", Format.NONE];
+    }
+    analyzeText(raw) {
+        const result = splitThinkingTags(raw);
+        if (result.reasoning !== "") {
+            return { reasoning: result.reasoning, clean: result.clean, format: Format.THINKING };
+        }
+        return { reasoning: "", clean: raw, format: Format.NONE };
+    }
+    hasRecognizedKey(m) {
+        return Object.keys(m).some((k) => RECOGNIZED_KEYS.has(k));
+    }
+    parseNodes(reasoning, now) {
+        if (Buffer.byteLength(reasoning, "utf8") > this.opts.max_reasoning_bytes) {
+            throw new ReasoningTooLargeError();
+        }
+        const paragraphs = splitParagraphs(reasoning);
+        if (paragraphs.length > this.opts.max_nodes) {
+            throw new TooManyNodesError();
+        }
+        const nodes = [];
+        let parentId = "";
+        let depth = 0;
+        for (const para of paragraphs) {
+            depth += 1;
+            if (depth > this.opts.max_depth) {
+                throw new TooDeepError();
+            }
+            let kind = NodeKind.OBSERVATION;
+            let summary = para.replace(LIST_ORNAMENT, "");
+            const kindMatch = KIND_PREFIX.exec(summary);
+            if (kindMatch) {
+                kind = KIND_BY_LABEL[kindMatch[1].toLowerCase()] ?? NodeKind.OBSERVATION;
+                summary = summary.slice(kindMatch[0].length).trim();
+            }
+            let status = NodeStatus.COMPLETE;
+            const statusMatch = STATUS_MARKER.exec(summary);
+            if (statusMatch) {
+                status = STATUS_BY_LABEL[statusMatch[1].toLowerCase()] ?? NodeStatus.COMPLETE;
+                summary = summary.slice(0, statusMatch.index).trim();
+            }
+            else if (kind === NodeKind.BLOCKER) {
+                status = NodeStatus.BLOCKED;
+            }
+            summary = truncateCodePoints(summary, this.opts.max_summary_chars);
+            if (summary === "") {
+                depth -= 1;
+                continue;
+            }
+            const id = nodeId(kind, parentId, summary);
+            nodes.push({
+                id,
+                parent_id: parentId,
+                kind,
+                status,
+                summary,
+                evidence_refs: extractEvidence(summary),
+                tool_call_refs: extractToolRefs(kind, summary),
+                created_at: now,
+                updated_at: now,
+            });
+            parentId = id;
+        }
+        return nodes;
+    }
+}
+function splitThinkingTags(text) {
+    if (!THINKING_OPEN.test(text) && !THINKING_CLOSE.test(text)) {
+        return { clean: text, reasoning: "" };
+    }
+    const parts = [];
+    const reasons = [];
+    let rest = text;
+    for (;;) {
+        const open = THINKING_OPEN.exec(rest);
+        if (open === null) {
+            if (THINKING_CLOSE.test(rest)) {
+                throw new UnbalancedThinkingError();
+            }
+            parts.push(rest);
+            break;
+        }
+        parts.push(rest.slice(0, open.index));
+        const inner = rest.slice(open.index + open[0].length);
+        const close = THINKING_CLOSE.exec(inner);
+        if (close === null) {
+            throw new UnbalancedThinkingError();
+        }
+        reasons.push(inner.slice(0, close.index));
+        rest = inner.slice(close.index + close[0].length);
+    }
+    return { clean: parts.join(""), reasoning: reasons.join("\n").trim() };
+}
+function splitParagraphs(text) {
+    return text
+        .split(PARAGRAPH_SEP)
+        .map((p) => p.trim())
+        .filter((p) => p !== "");
+}
+function extractEvidence(summary) {
+    const out = [];
+    const seen = new Set();
+    for (const pattern of EVIDENCE_PATTERNS) {
+        pattern.lastIndex = 0;
+        let match;
+        while ((match = pattern.exec(summary)) !== null) {
+            const ref = (match[1] ?? match[0]).replace(/^\[|\]$/g, "");
+            if (ref !== "" && !seen.has(ref)) {
+                seen.add(ref);
+                out.push(ref);
+            }
+        }
+    }
+    return out;
+}
+function extractToolRefs(kind, summary) {
+    if (kind !== NodeKind.TOOL_CALL && kind !== NodeKind.TOOL_RESULT) {
+        return [];
+    }
+    const leading = LEADING_IDENTIFIER.exec(summary);
+    if (leading) {
+        return [leading[1]];
+    }
+    const ref = TOOL_REF.exec(summary);
+    if (ref) {
+        return [ref[1]];
+    }
+    if (BARE_IDENTIFIER.test(summary)) {
+        return [summary];
+    }
+    return [];
+}
+function truncateCodePoints(s, n) {
+    if (n <= 0) {
+        return "";
+    }
+    const points = Array.from(s);
+    if (points.length <= n) {
+        return s;
+    }
+    return points.slice(0, n).join("");
+}
+function nodeId(kind, parentId, summary) {
+    return createHash("sha256")
+        .update(`${kind}\0${parentId}\0${summary}`)
+        .digest("hex")
+        .slice(0, 16);
+}

package/dist/reasoning/errors.d.ts

@@ -0,0 +1,28 @@
+export declare class ReasoningError extends Error {
+    constructor(message: string);
+}
+export declare class MalformedInputError extends ReasoningError {
+    constructor(message: string);
+}
+export declare class MalformedJSONError extends ReasoningError {
+    constructor(message: string);
+}
+export declare class MalformedReasoningFieldError extends ReasoningError {
+    constructor(message: string);
+}
+export declare class MalformedContentError extends ReasoningError {
+    constructor(message: string);
+}
+export declare class UnbalancedThinkingError extends ReasoningError {
+    constructor(message?: string);
+}
+export declare class ReasoningTooLargeError extends ReasoningError {
+    constructor(message?: string);
+}
+export declare class TooManyNodesError extends ReasoningError {
+    constructor(message?: string);
+}
+export declare class TooDeepError extends ReasoningError {
+    constructor(message?: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/reasoning/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/reasoning/errors.ts"],"names":[],"mappings":"AAIA,qBAAa,cAAe,SAAQ,KAAK;gBAC3B,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,mBAAoB,SAAQ,cAAc;gBACzC,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,kBAAmB,SAAQ,cAAc;gBACxC,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,4BAA6B,SAAQ,cAAc;gBAClD,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,qBAAsB,SAAQ,cAAc;gBAC3C,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,uBAAwB,SAAQ,cAAc;gBAC7C,OAAO,SAAuC;CAI3D;AAED,qBAAa,sBAAuB,SAAQ,cAAc;gBAC5C,OAAO,SAA8C;CAIlE;AAED,qBAAa,iBAAkB,SAAQ,cAAc;gBACvC,OAAO,SAAwC;CAI5D;AAED,qBAAa,YAAa,SAAQ,cAAc;gBAClC,OAAO,SAAuC;CAI3D"}

package/dist/reasoning/errors.js

@@ -0,0 +1,57 @@
+// Fail-closed errors raised by the reasoning adapter.
+// Every error represents a fail-closed outcome: malformed or unbounded input
+// never produces a partial tree or partially-stripped content.
+export class ReasoningError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ReasoningError";
+    }
+}
+export class MalformedInputError extends ReasoningError {
+    constructor(message) {
+        super(message);
+        this.name = "MalformedInputError";
+    }
+}
+export class MalformedJSONError extends ReasoningError {
+    constructor(message) {
+        super(message);
+        this.name = "MalformedJSONError";
+    }
+}
+export class MalformedReasoningFieldError extends ReasoningError {
+    constructor(message) {
+        super(message);
+        this.name = "MalformedReasoningFieldError";
+    }
+}
+export class MalformedContentError extends ReasoningError {
+    constructor(message) {
+        super(message);
+        this.name = "MalformedContentError";
+    }
+}
+export class UnbalancedThinkingError extends ReasoningError {
+    constructor(message = "reasoning: unbalanced thinking tag") {
+        super(message);
+        this.name = "UnbalancedThinkingError";
+    }
+}
+export class ReasoningTooLargeError extends ReasoningError {
+    constructor(message = "reasoning: reasoning exceeds maximum size") {
+        super(message);
+        this.name = "ReasoningTooLargeError";
+    }
+}
+export class TooManyNodesError extends ReasoningError {
+    constructor(message = "reasoning: too many reasoning nodes") {
+        super(message);
+        this.name = "TooManyNodesError";
+    }
+}
+export class TooDeepError extends ReasoningError {
+    constructor(message = "reasoning: reasoning tree too deep") {
+        super(message);
+        this.name = "TooDeepError";
+    }
+}

package/dist/reasoning/index.d.ts

@@ -0,0 +1,6 @@
+export { ReasoningAdapter, ReasoningError } from "./adapter.js";
+export { MalformedContentError, MalformedInputError, MalformedJSONError, MalformedReasoningFieldError, ReasoningTooLargeError, TooDeepError, TooManyNodesError, UnbalancedThinkingError, } from "./errors.js";
+export { ReasoningOptions, normalizeOptions } from "./options.js";
+export { CONTRACT_VERSION, Format, NodeKind, NodeStatus, isContextTreeEmpty, } from "./types.js";
+export type { Node, ContextTree } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/reasoning/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/reasoning/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAChE,OAAO,EACL,qBAAqB,EACrB,mBAAmB,EACnB,kBAAkB,EAClB,4BAA4B,EAC5B,sBAAsB,EACtB,YAAY,EACZ,iBAAiB,EACjB,uBAAuB,GACxB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,EACL,gBAAgB,EAChB,MAAM,EACN,QAAQ,EACR,UAAU,EACV,kBAAkB,GACnB,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC"}

package/dist/reasoning/index.js

@@ -0,0 +1,4 @@
+export { ReasoningAdapter, ReasoningError } from "./adapter.js";
+export { MalformedContentError, MalformedInputError, MalformedJSONError, MalformedReasoningFieldError, ReasoningTooLargeError, TooDeepError, TooManyNodesError, UnbalancedThinkingError, } from "./errors.js";
+export { normalizeOptions } from "./options.js";
+export { CONTRACT_VERSION, Format, NodeKind, NodeStatus, isContextTreeEmpty, } from "./types.js";

package/dist/reasoning/options.d.ts

@@ -0,0 +1,18 @@
+export interface ReasoningOptions {
+    /** Cap on the size of the extracted reasoning text, in bytes. */
+    max_reasoning_bytes?: number;
+    /** Cap on the number of nodes a single tree may contain. */
+    max_nodes?: number;
+    /** Cap on the depth of the node chain. */
+    max_depth?: number;
+    /** Cap on the length of every node summary, in code points. */
+    max_summary_chars?: number;
+    /** Clock supplying timestamps for tree and nodes. Defaults to Date.now. */
+    clock?: () => Date;
+}
+export declare const DEFAULT_MAX_REASONING_BYTES: number;
+export declare const DEFAULT_MAX_NODES = 64;
+export declare const DEFAULT_MAX_DEPTH = 32;
+export declare const DEFAULT_MAX_SUMMARY_CHARS = 512;
+export declare function normalizeOptions(opts?: ReasoningOptions): Required<ReasoningOptions>;
+//# sourceMappingURL=options.d.ts.map

package/dist/reasoning/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../src/reasoning/options.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,gBAAgB;IAC/B,iEAAiE;IACjE,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,4DAA4D;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0CAA0C;IAC1C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,2EAA2E;IAC3E,KAAK,CAAC,EAAE,MAAM,IAAI,CAAC;CACpB;AAED,eAAO,MAAM,2BAA2B,QAAY,CAAC;AACrD,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAE7C,wBAAgB,gBAAgB,CAAC,IAAI,CAAC,EAAE,gBAAgB,GAAG,QAAQ,CAAC,gBAAgB,CAAC,CAQpF"}

package/dist/reasoning/options.js

@@ -0,0 +1,18 @@
+// Bounds for the reasoning adapter (mirrors go/reasoning/options.go).
+//
+// All limits fail closed: an input that exceeds a bound raises an error rather
+// than being truncated into a partial tree (summaries are the one bounded
+// field by design; they are truncated, never the parse aborted).
+export const DEFAULT_MAX_REASONING_BYTES = 64 * 1024;
+export const DEFAULT_MAX_NODES = 64;
+export const DEFAULT_MAX_DEPTH = 32;
+export const DEFAULT_MAX_SUMMARY_CHARS = 512;
+export function normalizeOptions(opts) {
+    return {
+        max_reasoning_bytes: opts?.max_reasoning_bytes ?? DEFAULT_MAX_REASONING_BYTES,
+        max_nodes: opts?.max_nodes ?? DEFAULT_MAX_NODES,
+        max_depth: opts?.max_depth ?? DEFAULT_MAX_DEPTH,
+        max_summary_chars: opts?.max_summary_chars ?? DEFAULT_MAX_SUMMARY_CHARS,
+        clock: opts?.clock ?? (() => new Date()),
+    };
+}

package/dist/reasoning/types.d.ts

@@ -0,0 +1,44 @@
+export declare const CONTRACT_VERSION = "1";
+export declare enum Format {
+    NATIVE = "native",
+    THINKING = "thinking",
+    MODEL_SPECIFIC = "model_specific",
+    NONE = "none"
+}
+export declare enum NodeKind {
+    GOAL = "goal",
+    OBSERVATION = "observation",
+    DECISION = "decision",
+    TOOL_CALL = "tool-call",
+    TOOL_RESULT = "tool-result",
+    CONCLUSION = "conclusion",
+    BLOCKER = "blocker"
+}
+export declare enum NodeStatus {
+    ACTIVE = "active",
+    COMPLETE = "complete",
+    BLOCKED = "blocked",
+    SUPERSEDED = "superseded"
+}
+export interface Node {
+    id: string;
+    parent_id: string;
+    kind: NodeKind;
+    status: NodeStatus;
+    summary: string;
+    evidence_refs: string[];
+    tool_call_refs: string[];
+    created_at: Date;
+    updated_at: Date;
+}
+export interface ContextTree {
+    version: string;
+    format: Format;
+    model: string;
+    backend: string;
+    created_at: Date;
+    root_id: string;
+    nodes: Node[];
+}
+export declare function isContextTreeEmpty(tree: ContextTree | null | undefined): boolean;
+//# sourceMappingURL=types.d.ts.map

package/dist/reasoning/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/reasoning/types.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAEpC,oBAAY,MAAM;IAChB,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,cAAc,mBAAmB;IACjC,IAAI,SAAS;CACd;AAGD,oBAAY,QAAQ;IAClB,IAAI,SAAS;IACb,WAAW,gBAAgB;IAC3B,QAAQ,aAAa;IACrB,SAAS,cAAc;IACvB,WAAW,gBAAgB;IAC3B,UAAU,eAAe;IACzB,OAAO,YAAY;CACpB;AAGD,oBAAY,UAAU;IACpB,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,OAAO,YAAY;IACnB,UAAU,eAAe;CAC1B;AAID,MAAM,WAAW,IAAI;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,UAAU,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,UAAU,EAAE,IAAI,CAAC;IACjB,UAAU,EAAE,IAAI,CAAC;CAClB;AAKD,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,IAAI,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAEhF"}

package/dist/reasoning/types.js

@@ -0,0 +1,32 @@
+// Versioned context-tree contract for normalized reasoning.
+// Mirrors go/reasoning/types.go and python/src/pedro_agentware/reasoning/types.py.
+export const CONTRACT_VERSION = "1";
+export var Format;
+(function (Format) {
+    Format["NATIVE"] = "native";
+    Format["THINKING"] = "thinking";
+    Format["MODEL_SPECIFIC"] = "model_specific";
+    Format["NONE"] = "none";
+})(Format || (Format = {}));
+// NodeKind is the closed vocabulary of context-tree node kinds.
+export var NodeKind;
+(function (NodeKind) {
+    NodeKind["GOAL"] = "goal";
+    NodeKind["OBSERVATION"] = "observation";
+    NodeKind["DECISION"] = "decision";
+    NodeKind["TOOL_CALL"] = "tool-call";
+    NodeKind["TOOL_RESULT"] = "tool-result";
+    NodeKind["CONCLUSION"] = "conclusion";
+    NodeKind["BLOCKER"] = "blocker";
+})(NodeKind || (NodeKind = {}));
+// NodeStatus is the closed vocabulary of context-tree node statuses.
+export var NodeStatus;
+(function (NodeStatus) {
+    NodeStatus["ACTIVE"] = "active";
+    NodeStatus["COMPLETE"] = "complete";
+    NodeStatus["BLOCKED"] = "blocked";
+    NodeStatus["SUPERSEDED"] = "superseded";
+})(NodeStatus || (NodeStatus = {}));
+export function isContextTreeEmpty(tree) {
+    return !tree || tree.nodes.length === 0;
+}

package/dist/toolformat/formatter.d.ts

@@ -1,4 +1,4 @@
-import type { Tool, Result } from "../tools/index.js";
+import type { AnyTool, Result } from "../tools/index.js";
 export interface ParsedToolCall {
     id: string;
     name: string;
@@ -6,13 +6,13 @@ export interface ParsedToolCall {
     raw: string;
 }
 export interface ToolFormatter {
-    formatToolDefinitions(tools: Tool[]): string;
+    formatToolDefinitions(tools: AnyTool[]): string;
     parseToolCalls(response: string): ParsedToolCall[];
     formatToolResult(name: string, result: Result): string;
     modelFamily(): string;
 }
 export declare class GenericFormatter implements ToolFormatter {
-    formatToolDefinitions(tools: Tool[]): string;
+    formatToolDefinitions(tools: AnyTool[]): string;
     parseToolCalls(_response: string): ParsedToolCall[];
     formatToolResult(name: string, result: Result): string;
     modelFamily(): string;

package/dist/toolformat/formatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../../src/toolformat/formatter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEtD,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,aAAa;IAC5B,qBAAqB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,MAAM,CAAC;IAC7C,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,EAAE,CAAC;IACnD,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IACvD,WAAW,IAAI,MAAM,CAAC;CACvB;AAED,qBAAa,gBAAiB,YAAW,aAAa;IACpD,qBAAqB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,MAAM;IAU5C,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,EAAE;IAInD,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAMtD,WAAW,IAAI,MAAM;CAGtB"}
+{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../../src/toolformat/formatter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEzD,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,aAAa;IAC5B,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC;IAChD,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,EAAE,CAAC;IACnD,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IACvD,WAAW,IAAI,MAAM,CAAC;CACvB;AAED,qBAAa,gBAAiB,YAAW,aAAa;IACpD,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,MAAM;IAU/C,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,EAAE;IAInD,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAMtD,WAAW,IAAI,MAAM;CAGtB"}

package/dist/tools/index.d.ts

@@ -1,5 +1,5 @@
-export { Tool, BaseTool, Result, ToolExample } from "./tool.js";
+export { Tool, ToolBase, AsyncTool, AnyTool, BaseTool, Result, ToolExample, executeTool, } from "./tool.js";
 export { ToolRegistry } from "./registry.js";
-export { wrapTool, ToolAbortedError, ToolTimeoutError, } from "./async.js";
+export { wrapTool, ToolAbortedError, ToolTimeoutError } from "./async.js";
 export type { AsyncToolHandler, ToolInvocationOptions, ToolLifecycleEvent, ToolLifecycleHook, WrapToolOptions, WrappedTool, } from "./async.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/tools/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,gBAAgB,EAChB,qBAAqB,EACrB,kBAAkB,EAClB,iBAAiB,EACjB,eAAe,EACf,WAAW,GACZ,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,QAAQ,EACR,SAAS,EACT,OAAO,EACP,QAAQ,EACR,MAAM,EACN,WAAW,EACX,WAAW,GACZ,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC1E,YAAY,EACV,gBAAgB,EAChB,qBAAqB,EACrB,kBAAkB,EAClB,iBAAiB,EACjB,eAAe,EACf,WAAW,GACZ,MAAM,YAAY,CAAC"}

package/dist/tools/index.js

@@ -1,3 +1,3 @@
-export { BaseTool, Result } from "./tool.js";
+export { BaseTool, Result, executeTool, } from "./tool.js";
 export { ToolRegistry } from "./registry.js";
-export { wrapTool, ToolAbortedError, ToolTimeoutError, } from "./async.js";
+export { wrapTool, ToolAbortedError, ToolTimeoutError } from "./async.js";

package/dist/tools/registry.d.ts

@@ -1,9 +1,9 @@
-import type { Tool } from "./tool.js";
+import type { AnyTool } from "./tool.js";
 export declare class ToolRegistry {
     private tools;
-    register(tool: Tool): void;
-    get(name: string): Tool | undefined;
-    all(): Tool[];
+    register(tool: AnyTool): void;
+    get(name: string): AnyTool | undefined;
+    all(): AnyTool[];
     names(): string[];
     schemas(): Record<string, Record<string, unknown>>;
     clear(): void;