@haikeilabs/agentware 0.1.0 → 0.1.1

package/dist/middleware/inference.d.ts

@@ -5,6 +5,7 @@ import type { ContextWindowManager } from "../llmcontext/context_window.js";
 import type { ResponseValidator } from "./guardrails/response_validator.js";
 import { ErrorTracker } from "./guardrails/error_tracker.js";
 import { StepEnforcer } from "./guardrails/step_enforcer.js";
+import { ReasoningAdapter, type ContextTree } from "../reasoning/index.js";
 export declare class RetriesExhaustedError extends Error {
     constructor(message: string);
 }
@@ -13,6 +14,10 @@ export interface InferenceResult {
     newMessages: Message[];
     toolCallCounter: number;
     attempts: number;
+    /** Normalized context tree for the final turn's reasoning (native
+     * reasoning_content and/or thinking tags). Null when the turn carried no
+     * reasoning. Holds bounded summaries only; raw reasoning is never attached. */
+    reasoningTree: ContextTree | null;
 }
 export interface InferenceConfig {
     client: Backend;
@@ -23,6 +28,9 @@ export interface InferenceConfig {
     toolSpecs: ToolDefinition[];
     maxAttempts: number;
     stepIndex?: number;
+    /** Optional reasoning adapter override for limits and registered model
+     * fields. */
+    reasoning?: ReasoningAdapter;
 }
 export declare function runInference(messages: Message[], cfg: InferenceConfig, sessionId?: string): Promise<InferenceResult | null>;
 //# sourceMappingURL=inference.d.ts.map

package/dist/middleware/inference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inference.d.ts","sourceRoot":"","sources":["../../src/middleware/inference.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,KAAK,EAAE,QAAQ,EAA2B,MAAM,oBAAoB,CAAC;AAC5E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAG5E,OAAO,KAAK,EAAE,iBAAiB,EAA8B,MAAM,oCAAoC,CAAC;AACxG,OAAO,EAAE,YAAY,EAAiB,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAG7D,qBAAa,qBAAsB,SAAQ,KAAK;gBAClC,OAAO,EAAE,MAAM;CAI5B;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,QAAQ,CAAC;IACnB,WAAW,EAAE,OAAO,EAAE,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,OAAO,CAAC;IAChB,cAAc,CAAC,EAAE,oBAAoB,CAAC;IACtC,SAAS,CAAC,EAAE,iBAAiB,CAAC;IAC9B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAsB,YAAY,CAChC,QAAQ,EAAE,OAAO,EAAE,EACnB,GAAG,EAAE,eAAe,EACpB,SAAS,GAAE,MAAW,GACrB,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAwJjC"}
+{"version":3,"file":"inference.d.ts","sourceRoot":"","sources":["../../src/middleware/inference.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,KAAK,EAAE,QAAQ,EAA2B,MAAM,oBAAoB,CAAC;AAC5E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAG5E,OAAO,KAAK,EAAE,iBAAiB,EAA8B,MAAM,oCAAoC,CAAC;AACxG,OAAO,EAAE,YAAY,EAAiB,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAE7D,OAAO,EAAE,gBAAgB,EAAkB,KAAK,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAE3F,qBAAa,qBAAsB,SAAQ,KAAK;gBAClC,OAAO,EAAE,MAAM;CAI5B;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,QAAQ,CAAC;IACnB,WAAW,EAAE,OAAO,EAAE,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB;;mFAE+E;IAC/E,aAAa,EAAE,WAAW,GAAG,IAAI,CAAC;CACnC;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,OAAO,CAAC;IAChB,cAAc,CAAC,EAAE,oBAAoB,CAAC;IACtC,SAAS,CAAC,EAAE,iBAAiB,CAAC;IAC9B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;iBACa;IACb,SAAS,CAAC,EAAE,gBAAgB,CAAC;CAC9B;AAKD,wBAAsB,YAAY,CAChC,QAAQ,EAAE,OAAO,EAAE,EACnB,GAAG,EAAE,eAAe,EACpB,SAAS,GAAE,MAAW,GACrB,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CA8LjC"}

package/dist/middleware/inference.js

@@ -2,12 +2,15 @@ import { Role } from "../llm/request.js";
 import { MessageType } from "./types.js";
 import { ErrorCategory } from "./guardrails/error_tracker.js";
 import { stepNudge } from "./guardrails/nudge.js";
+import { ReasoningAdapter, ReasoningError } from "../reasoning/index.js";
 export class RetriesExhaustedError extends Error {
     constructor(message) {
         super(message);
         this.name = "RetriesExhaustedError";
     }
 }
+// Default adapter strips and normalizes reasoning in the inference loop.
+const defaultAdapter = new ReasoningAdapter();
 export async function runInference(messages, cfg, sessionId = "") {
     let maxAttempts = cfg.maxAttempts;
     if (maxAttempts <= 0) {
@@ -49,43 +52,81 @@ export async function runInference(messages, cfg, sessionId = "") {
             cfg.contextManager.updateTokenCount(resp.usage_tokens.total_tokens);
         }
         let validationResult = null;
-        if (resp.tool_calls && resp.tool_calls.length > 0) {
-            const guardrailsToolCalls = resp.tool_calls.map((tc) => ({
-                tool: tc.name,
-                args: tc.arguments,
-            }));
-            if (cfg.validator) {
-                validationResult = cfg.validator.validateToolCalls(guardrailsToolCalls);
+        // AR-1: normalize reasoning and strip it before ordinary tool-call
+        // parsing. Reasoning can arrive as a native reasoning_content field or as
+        // embedded thinking tags in content; both are combined into a synthetic
+        // structured input so the adapter sees the full picture. Malformed or
+        // unbounded reasoning fails closed: this turn is treated as invalid and
+        // retried rather than parsed partially.
+        let reasoningTree = null;
+        let cleanContent = resp.content;
+        let reasoningFailed = false;
+        if (resp.content || resp.reasoning) {
+            const reasoningInput = { content: resp.content };
+            if (resp.reasoning) {
+                reasoningInput["reasoning_content"] = resp.reasoning;
             }
-            else {
-                validationResult = {
-                    toolCalls: guardrailsToolCalls,
-                    nudge: null,
-                    needsRetry: false,
-                };
-            }
-        }
-        else if (resp.content) {
-            if (cfg.validator) {
-                validationResult = cfg.validator.validateTextResponse(resp.content);
+            const adapter = cfg.reasoning ?? defaultAdapter;
+            try {
+                reasoningTree = adapter.extract(reasoningInput, cfg.client.modelName(), "llm-backend");
+                cleanContent = adapter.strip(reasoningInput);
             }
-            else {
-                validationResult = { toolCalls: [], nudge: null, needsRetry: false };
+            catch (e) {
+                if (e instanceof ReasoningError) {
+                    reasoningFailed = true;
+                    // Fail closed: never echo content that may carry reasoning we could
+                    // not parse.
+                    cleanContent = "";
+                    validationResult = {
+                        toolCalls: [],
+                        nudge: null,
+                        needsRetry: true,
+                    };
+                }
+                else {
+                    throw e;
+                }
             }
-            if (!validationResult.needsRetry && validationResult.toolCalls.length > 0) {
-                resp.tool_calls = validationResult.toolCalls.map((tc) => ({
-                    id: "",
-                    name: tc.tool,
-                    arguments: tc.args,
+        }
+        if (!reasoningFailed) {
+            if (resp.tool_calls && resp.tool_calls.length > 0) {
+                const guardrailsToolCalls = resp.tool_calls.map((tc) => ({
+                    tool: tc.name,
+                    args: tc.arguments,
                 }));
+                if (cfg.validator) {
+                    validationResult = cfg.validator.validateToolCalls(guardrailsToolCalls);
+                }
+                else {
+                    validationResult = {
+                        toolCalls: guardrailsToolCalls,
+                        nudge: null,
+                        needsRetry: false,
+                    };
+                }
             }
-        }
-        else {
-            if (cfg.validator) {
-                validationResult = cfg.validator.validateTextResponse("");
+            else if (cleanContent) {
+                if (cfg.validator) {
+                    validationResult = cfg.validator.validateTextResponse(cleanContent);
+                }
+                else {
+                    validationResult = { toolCalls: [], nudge: null, needsRetry: false };
+                }
+                if (!validationResult.needsRetry && validationResult.toolCalls.length > 0) {
+                    resp.tool_calls = validationResult.toolCalls.map((tc) => ({
+                        id: "",
+                        name: tc.tool,
+                        arguments: tc.args,
+                    }));
+                }
             }
             else {
-                validationResult = { toolCalls: [], nudge: null, needsRetry: true };
+                if (cfg.validator) {
+                    validationResult = cfg.validator.validateTextResponse("");
+                }
+                else {
+                    validationResult = { toolCalls: [], nudge: null, needsRetry: true };
+                }
             }
         }
         lastResponse = resp;
@@ -114,6 +155,7 @@ export async function runInference(messages, cfg, sessionId = "") {
                 newMessages: currentMessages,
                 toolCallCounter,
                 attempts,
+                reasoningTree,
             };
         }
         if (cfg.errorTracker) {
@@ -132,7 +174,7 @@ export async function runInference(messages, cfg, sessionId = "") {
         }
         const failedMsg = {
             role: Role.ASSISTANT,
-            content: resp.content,
+            content: cleanContent,
             meta: { type: MessageType.TEXT_RESPONSE },
         };
         currentMessages.push(failedMsg);

package/dist/reasoning/adapter.d.ts

@@ -0,0 +1,33 @@
+import { ReasoningError } from "./errors.js";
+import { ReasoningOptions } from "./options.js";
+import { ContextTree } from "./types.js";
+export { ReasoningError };
+export declare class ReasoningAdapter {
+    private readonly opts;
+    private readonly modelFields;
+    constructor(options?: ReasoningOptions);
+    get options(): Required<ReasoningOptions>;
+    /** Map a model name to a model-specific reasoning field name. Fields
+     * registered here are consulted before the known field set. */
+    registerModelField(model: string, fieldName: string): void;
+    /** Remove reasoning from raw and return the clean content that ordinary
+     * tool-call parsers should see. Fails closed. */
+    strip(raw: unknown): string;
+    /** Normalize reasoning found in raw into a versioned context tree. Raw
+     * reasoning is never stored on the tree: nodes carry bounded summaries. */
+    extract(raw: unknown, model?: string, backend?: string): ContextTree;
+    /** Strip and extract in one call: return the clean content and tree. */
+    parse(raw: unknown, model?: string, backend?: string): {
+        clean: string;
+        tree: ContextTree;
+    };
+    private analyze;
+    private analyzeString;
+    private analyzeBytes;
+    private analyzeStructured;
+    private extractReasoningField;
+    private analyzeText;
+    private hasRecognizedKey;
+    private parseNodes;
+}
+//# sourceMappingURL=adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/reasoning/adapter.ts"],"names":[],"mappings":"AAcA,OAAO,EAKL,cAAc,EAKf,MAAM,aAAa,CAAC;AACrB,OAAO,EAAoB,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,EAAoB,WAAW,EAAsC,MAAM,YAAY,CAAC;AAE/F,OAAO,EAAE,cAAc,EAAE,CAAC;AAmE1B,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA6B;IAClD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAsB;gBAEtC,OAAO,CAAC,EAAE,gBAAgB;IAKtC,IAAI,OAAO,IAAI,QAAQ,CAAC,gBAAgB,CAAC,CAExC;IAED;mEAC+D;IAC/D,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAM1D;qDACiD;IACjD,KAAK,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM;IAI3B;+EAC2E;IAC3E,OAAO,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,SAAK,EAAE,OAAO,SAAK,GAAG,WAAW;IA0B5D,wEAAwE;IACxE,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,SAAK,EAAE,OAAO,SAAK,GAAG;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,WAAW,CAAA;KAAE;IAKnF,OAAO,CAAC,OAAO;IAaf,OAAO,CAAC,aAAa;IAgBrB,OAAO,CAAC,YAAY;IAgBpB,OAAO,CAAC,iBAAiB;IA+BzB,OAAO,CAAC,qBAAqB;IAqC7B,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,UAAU;CA2DnB"}

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";
+    }
+}