@caupulican/pi-adaptative 0.81.13 → 0.81.16

package/dist/core/agent-session.js

@@ -1,4 +1,5 @@
-import { readFileSync } from "node:fs";
+import { readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { classifyFailure, compactToolResultDetailsForRetention, computeRetryDelayMs, createCustomMessage, DEFAULT_RETRY_POLICY, RetryController, sleepAbortable, withStreamIdleWatchdog, } from "@caupulican/pi-agent-core";
 import { calculateContextTokens, compact, createDeterministicCompaction, estimateContextTokens, getLatestCompactionEntry, prepareCompaction, runCompactionLoop, shouldCompact, } from "@caupulican/pi-agent-core/node";
@@ -60,12 +61,22 @@ const MODEL_ADAPTATION_REPAIR_THRESHOLD = 3;
 const TEXT_TOOL_PROTOCOL_VERSION = 1;
 const TEXT_TOOL_PROTOCOL_TRIALS_PER_VARIANT = 2;
 const TEXT_TOOL_PROTOCOL_PARSE_FAILURE_THRESHOLD = 3;
-const TEXT_TOOL_PROTOCOL_VARIANTS = ["tool-tag", "tool-call", "fenced-json"];
+const TEXT_TOOL_PROTOCOL_VARIANTS = [
+    "tool-tag",
+    "tool-call",
+    "fenced-json",
+    "function-xml",
+];
 const TEXT_TOOL_PROTOCOL_ECHO_TOOL = {
     name: "echo",
     description: "Echo calibration data",
     parameters: Type.Object({ data: Type.String() }),
 };
+const NATIVE_TOOL_PROBE_READ_TOOL = {
+    name: "read",
+    description: "Read file contents",
+    parameters: Type.Object({ path: Type.String() }),
+};
 /** Test-only override of the stream-idle bounds. Read per-request by the wiring's resolver. */
 let streamIdleOptionsOverride;
 /**
@@ -151,6 +162,7 @@ export class AgentSession {
     _repairModeSessionCounts = new Map();
     _textProtocolParseFailures = new Map();
     _textProtocolParseObservedThisTurn = false;
+    _textProtocolValidationOutcomeThisTurn;
     /** Assembles the session's base system prompt from live session state (see
      * system-prompt-builder.ts); owns the paired _baseSystemPromptOptions. */
     _systemPromptBuilder;
@@ -507,6 +519,7 @@ export class AgentSession {
             previousToolArgumentValidation?.(taggedEvent);
             this._analytics.recordToolArgumentValidation(taggedEvent);
             this._recordToolValidationBounce(taggedEvent);
+            this._handleTextToolProtocolValidationOutcome(taggedEvent);
             this._handleModelAdaptationTelemetry(taggedEvent);
         };
         this._treeNavigator = new SessionTreeNavigator({
@@ -837,30 +850,67 @@ export class AgentSession {
         return {
             systemPrompt: `${primer}\n\n${instruction}`,
             messages: [{ role: "user", content: [{ type: "text", text: instruction }], timestamp: Date.now() }],
-            tools: [TEXT_TOOL_PROTOCOL_ECHO_TOOL],
         };
     }
-    _messageHasEchoProbe(message, token) {
-        return message.content.some((block) => block.type === "toolCall" && block.name === "echo" && block.arguments.data === token);
+    _messageHasToolCallWithStringArgument(message, toolName, argName, argValue) {
+        return message.content.some((block) => {
+            if (block.type !== "toolCall" || block.name !== toolName)
+                return false;
+            const args = block.arguments;
+            return (typeof args === "object" &&
+                args !== null &&
+                !Array.isArray(args) &&
+                args[argName] === argValue);
+        });
+    }
+    _nativeToolProbeSystemPrompt(instruction) {
+        const base = (this.agent.state.systemPrompt ?? "").trim();
+        return base ? `${base}\n\n${instruction}` : instruction;
+    }
+    async _runNativeReadTaskProbeTrial(model, path) {
+        const instruction = `Native tool-call capability probe: task-scale read. Use provider-native tool calling, not prose. ` +
+            `Call read exactly once with path exactly "${path}".`;
+        const stream = await this._streamForToolProbe(model, {
+            systemPrompt: this._nativeToolProbeSystemPrompt(instruction),
+            messages: [{ role: "user", content: [{ type: "text", text: instruction }], timestamp: Date.now() }],
+            tools: [NATIVE_TOOL_PROBE_READ_TOOL],
+        }, { textToolCallProtocol: false, maxRetries: 0, temperature: 0, maxTokens: 768 });
+        return this._messageHasToolCallWithStringArgument(await stream.result(), "read", "path", path);
     }
-    async _runNativeToolProbeTrial(model, token) {
-        const instruction = `Native tool-call capability probe. Use provider-native tool calling, not prose. ` +
+    async _runNativeEchoToolProbeTrial(model, token) {
+        const instruction = `Native tool-call capability probe: echo-only. Use provider-native tool calling, not prose. ` +
             `Call echo with data exactly "${token}".`;
         const stream = await this._streamForToolProbe(model, {
-            systemPrompt: instruction,
+            systemPrompt: this._nativeToolProbeSystemPrompt(instruction),
             messages: [{ role: "user", content: [{ type: "text", text: instruction }], timestamp: Date.now() }],
             tools: [TEXT_TOOL_PROTOCOL_ECHO_TOOL],
-        }, { textToolCallProtocol: false, maxRetries: 0 });
-        return this._messageHasEchoProbe(await stream.result(), token);
+        }, { textToolCallProtocol: false, maxRetries: 0, temperature: 0, maxTokens: 256 });
+        return this._messageHasToolCallWithStringArgument(await stream.result(), "echo", "data", token);
+    }
+    async _gradeNativeToolCallingForModel(model, token) {
+        const path = join(tmpdir(), `pi-native-probe-${process.pid}-${Date.now()}.txt`);
+        writeFileSync(path, token, "utf-8");
+        try {
+            const taskPassed = await this._runNativeReadTaskProbeTrial(model, path);
+            if (taskPassed)
+                return "task";
+            const echoPassed = await this._runNativeEchoToolProbeTrial(model, token);
+            if (echoPassed)
+                return "echo-only";
+            return "absent";
+        }
+        finally {
+            rmSync(path, { force: true });
+        }
     }
     async _runTextProtocolTrial(model, variant, token) {
         const stream = await this._streamForToolProbe(model, this._textProtocolCalibrationContext(variant, token), {
             textToolCallProtocol: false,
             maxRetries: 0,
+            temperature: 0,
+            maxTokens: 256,
         });
         const message = await stream.result();
-        if (this._messageHasEchoProbe(message, token))
-            return true;
         const text = message.content
             .filter((block) => block.type === "text")
             .map((block) => block.text)
@@ -932,12 +982,17 @@ export class AgentSession {
         return `${model.provider}/${model.id}`;
     }
     _formatToolProbeReport(results) {
-        const lines = ["Tool probe results:", "Model | Verdict | Variant | Diagnostic", "--- | --- | --- | ---"];
+        const lines = [
+            "Tool probe results:",
+            "Model | Verdict | Variant | Native grade | Diagnostic",
+            "--- | --- | --- | --- | ---",
+        ];
         for (const result of results) {
             lines.push([
                 result.model,
                 result.verdict,
                 result.variant ?? "-",
+                result.nativeGrade ?? "-",
                 result.diagnostic ? result.diagnostic.replace(/\s+/g, " ").slice(0, 160) : "-",
             ].join(" | "));
         }
@@ -949,12 +1004,23 @@ export class AgentSession {
     async _probeToolCallingForModel(model) {
         const modelKey = this._modelRef(model);
         const probedAt = new Date().toISOString();
+        let nativeGrade = "absent";
         let diagnostic;
         try {
-            if (await this._runNativeToolProbeTrial(model, "pi-native-probe")) {
-                this._storeToolProbe(modelKey, { version: TEXT_TOOL_PROTOCOL_VERSION, status: "native", probedAt });
-                return { model: modelKey, verdict: "native" };
+            nativeGrade = await this._gradeNativeToolCallingForModel(model, "pi-native-probe");
+            if (nativeGrade === "task") {
+                this._storeToolProbe(modelKey, {
+                    version: TEXT_TOOL_PROTOCOL_VERSION,
+                    status: "native",
+                    probedAt,
+                    nativeGrade,
+                });
+                return { model: modelKey, verdict: "native", nativeGrade };
             }
+            diagnostic =
+                nativeGrade === "echo-only"
+                    ? "Native echo probe passed but task-scale read probe failed."
+                    : "Native task-scale read and echo probes did not produce provider-native tool calls.";
         }
         catch (error) {
             diagnostic = error instanceof Error ? error.message : String(error);
@@ -967,16 +1033,24 @@ export class AgentSession {
                     status: "text-protocol",
                     probedAt: calibrated.calibratedAt,
                     variant: calibrated.variant,
+                    nativeGrade,
+                    diagnostic,
                 });
-                return { model: modelKey, verdict: "text-protocol", variant: calibrated.variant };
+                return { model: modelKey, verdict: "text-protocol", variant: calibrated.variant, nativeGrade, diagnostic };
             }
-            diagnostic ??= `Text protocol variants failed: ${calibrated.variantsTried.join(", ")}`;
+            diagnostic = `${diagnostic ? `${diagnostic} ` : ""}Text protocol variants failed: ${calibrated.variantsTried.join(", ")}`;
         }
         catch (error) {
             diagnostic = error instanceof Error ? error.message : String(error);
         }
-        this._storeToolProbe(modelKey, { version: TEXT_TOOL_PROTOCOL_VERSION, status: "none", probedAt, diagnostic });
-        return { model: modelKey, verdict: "none", diagnostic };
+        this._storeToolProbe(modelKey, {
+            version: TEXT_TOOL_PROTOCOL_VERSION,
+            status: "none",
+            probedAt,
+            nativeGrade,
+            diagnostic,
+        });
+        return { model: modelKey, verdict: "none", nativeGrade, diagnostic };
     }
     async _resolveToolProbeModels(target) {
         const trimmed = target?.trim();
@@ -1007,10 +1081,8 @@ export class AgentSession {
     _handleTextToolProtocolParse(event) {
         this._textProtocolParseObservedThisTurn = true;
         const modelKey = `${event.provider}/${event.model}`;
-        if (event.status === "parsed") {
-            this._textProtocolParseFailures.delete(modelKey);
+        if (event.status === "parsed")
             return;
-        }
         const signature = `${event.variant}:${event.reason ?? "failed"}`;
         const previous = this._textProtocolParseFailures.get(modelKey);
         const repeats = previous?.signature === signature ? previous.repeats + 1 : 1;
@@ -1024,7 +1096,40 @@ export class AgentSession {
         }
         this._textProtocolParseFailures.delete(modelKey);
     }
+    _handleTextToolProtocolValidationOutcome(event) {
+        if (event.source !== "text-protocol")
+            return;
+        const protocol = this.agent.textToolCallProtocol;
+        const variant = protocol === true ? "tool-tag" : protocol ? protocol.variant : undefined;
+        if (!variant)
+            return;
+        const status = event.outcome === "bounced" ? "failed" : "parsed";
+        if (this._textProtocolValidationOutcomeThisTurn?.status === "parsed" && status === "failed")
+            return;
+        this._textProtocolValidationOutcomeThisTurn = {
+            provider: event.provider ?? this.agent.state.model.provider,
+            model: event.model ?? this.agent.state.model.id,
+            variant,
+            status,
+            callCount: 1,
+            textLength: 0,
+            ...(status === "failed" && {
+                reason: event.errorKeywords?.includes("unknown_tool") ? "unknown-tool" : "validation-failed",
+            }),
+        };
+    }
     _recordTextToolProtocolParseOutcomeFromLastAssistant() {
+        const validationOutcome = this._textProtocolValidationOutcomeThisTurn;
+        this._textProtocolValidationOutcomeThisTurn = undefined;
+        if (validationOutcome?.status === "parsed") {
+            this._textProtocolParseObservedThisTurn = true;
+            this._textProtocolParseFailures.delete(`${validationOutcome.provider}/${validationOutcome.model}`);
+            return;
+        }
+        if (validationOutcome) {
+            this._handleTextToolProtocolParse(validationOutcome);
+            return;
+        }
         if (this._textProtocolParseObservedThisTurn)
             return;
         const protocol = this.agent.textToolCallProtocol;
@@ -1903,6 +2008,9 @@ export class AgentSession {
     getLocalRuntime(baseUrl) {
         return this._localRuntimeController.getLocalRuntime(baseUrl);
     }
+    getTransformersRuntime(modelId, baseUrl) {
+        return this._localRuntimeController.getTransformersRuntime(modelId, baseUrl);
+    }
     /** models.json registers a local model's baseUrl as `<server>/v1` (OpenAI-compat); the runtime's
      * own health/boot endpoints are on the Ollama-native server root. Delegates to
      * {@link LocalRuntimeController}; kept here for `_warnIfManualModelChoiceIsRisky`'s own use. */
@@ -2181,6 +2289,7 @@ export class AgentSession {
         }
         preflightResult?.(true);
         this._textProtocolParseObservedThisTurn = false;
+        this._textProtocolValidationOutcomeThisTurn = undefined;
         await this._modelRouter.runRoutedTurn(messages, routedTurnModel, routedTurnRouteDecision);
         this._recordTextToolProtocolParseOutcomeFromLastAssistant();
         // R4: score whether the agent actually used the recalled context, so the recall gate can adapt.