@psnext/slingcli 2.5.20260723-1 → 2.5.20260725-1

package/node_modules/@earendil-works/pi-agent-core/dist/harness/tools/image.js

@@ -0,0 +1,106 @@
+const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+export function detectSupportedImageMimeType(buffer) {
+    if (startsWith(buffer, [0xff, 0xd8, 0xff]))
+        return buffer[3] === 0xf7 ? undefined : "image/jpeg";
+    if (startsWith(buffer, PNG_SIGNATURE))
+        return isPng(buffer) && !isAnimatedPng(buffer) ? "image/png" : undefined;
+    if (startsWithAscii(buffer, 0, "GIF"))
+        return "image/gif";
+    if (startsWithAscii(buffer, 0, "RIFF") && startsWithAscii(buffer, 8, "WEBP"))
+        return "image/webp";
+    if (startsWithAscii(buffer, 0, "BM") && isBmp(buffer))
+        return "image/bmp";
+    return undefined;
+}
+export function encodeBase64(bytes) {
+    const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    let output = "";
+    for (let index = 0; index < bytes.length; index += 3) {
+        const first = bytes[index] ?? 0;
+        const second = bytes[index + 1];
+        const third = bytes[index + 2];
+        output += alphabet[first >> 2];
+        output += alphabet[((first & 0x03) << 4) | ((second ?? 0) >> 4)];
+        output += second === undefined ? "=" : alphabet[((second & 0x0f) << 2) | ((third ?? 0) >> 6)];
+        output += third === undefined ? "=" : alphabet[third & 0x3f];
+    }
+    return output;
+}
+function isPng(buffer) {
+    return (buffer.length >= 16 && readUint32BE(buffer, PNG_SIGNATURE.length) === 13 && startsWithAscii(buffer, 12, "IHDR"));
+}
+function isAnimatedPng(buffer) {
+    let offset = PNG_SIGNATURE.length;
+    while (offset + 8 <= buffer.length) {
+        const chunkLength = readUint32BE(buffer, offset);
+        const chunkTypeOffset = offset + 4;
+        if (startsWithAscii(buffer, chunkTypeOffset, "acTL"))
+            return true;
+        if (startsWithAscii(buffer, chunkTypeOffset, "IDAT"))
+            return false;
+        const nextOffset = offset + 8 + chunkLength + 4;
+        if (nextOffset <= offset || nextOffset > buffer.length)
+            return false;
+        offset = nextOffset;
+    }
+    return false;
+}
+function isBmp(buffer) {
+    if (buffer.length < 26)
+        return false;
+    const declaredFileSize = readUint32LE(buffer, 2);
+    const pixelDataOffset = readUint32LE(buffer, 10);
+    const dibHeaderSize = readUint32LE(buffer, 14);
+    if (declaredFileSize !== 0 && declaredFileSize < 26)
+        return false;
+    if (pixelDataOffset < 14 + dibHeaderSize)
+        return false;
+    if (declaredFileSize !== 0 && pixelDataOffset >= declaredFileSize)
+        return false;
+    let colorPlanes;
+    let bitsPerPixel;
+    if (dibHeaderSize === 12) {
+        colorPlanes = readUint16LE(buffer, 22);
+        bitsPerPixel = readUint16LE(buffer, 24);
+    }
+    else if (dibHeaderSize >= 40 && dibHeaderSize <= 124) {
+        if (buffer.length < 30)
+            return false;
+        colorPlanes = readUint16LE(buffer, 26);
+        bitsPerPixel = readUint16LE(buffer, 28);
+    }
+    else {
+        return false;
+    }
+    return colorPlanes === 1 && [1, 4, 8, 16, 24, 32].includes(bitsPerPixel);
+}
+function readUint16LE(buffer, offset) {
+    return (buffer[offset] ?? 0) + ((buffer[offset + 1] ?? 0) << 8);
+}
+function readUint32BE(buffer, offset) {
+    return ((buffer[offset] ?? 0) * 0x1000000 +
+        ((buffer[offset + 1] ?? 0) << 16) +
+        ((buffer[offset + 2] ?? 0) << 8) +
+        (buffer[offset + 3] ?? 0));
+}
+function readUint32LE(buffer, offset) {
+    return ((buffer[offset] ?? 0) +
+        ((buffer[offset + 1] ?? 0) << 8) +
+        ((buffer[offset + 2] ?? 0) << 16) +
+        (buffer[offset + 3] ?? 0) * 0x1000000);
+}
+function startsWith(buffer, bytes) {
+    if (buffer.length < bytes.length)
+        return false;
+    return bytes.every((byte, index) => buffer[index] === byte);
+}
+function startsWithAscii(buffer, offset, text) {
+    if (buffer.length < offset + text.length)
+        return false;
+    for (let index = 0; index < text.length; index++) {
+        if (buffer[offset + index] !== text.charCodeAt(index))
+            return false;
+    }
+    return true;
+}
+//# sourceMappingURL=image.js.map

package/node_modules/@earendil-works/pi-agent-core/dist/harness/tools/index.js

@@ -0,0 +1,5 @@
+export { createBashTool, } from "./bash.js";
+export { createEditTool, } from "./edit.js";
+export { createReadTool, } from "./read.js";
+export { createWriteTool } from "./write.js";
+//# sourceMappingURL=index.js.map

package/node_modules/@earendil-works/pi-agent-core/dist/harness/tools/path-utils.js

@@ -0,0 +1,26 @@
+import { getOrThrow } from "../types.js";
+const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+const NARROW_NO_BREAK_SPACE = "\u202F";
+function normalizeToolPath(path) {
+    const normalized = path.replace(UNICODE_SPACES, " ");
+    return normalized.startsWith("@") ? normalized.slice(1) : normalized;
+}
+export async function resolveToolPath(env, path, signal) {
+    return getOrThrow(await env.absolutePath(normalizeToolPath(path), signal));
+}
+export async function resolveReadToolPath(env, path, signal) {
+    const resolved = await resolveToolPath(env, path, signal);
+    const variants = [
+        resolved,
+        resolved.replace(/ (AM|PM)\./gi, `${NARROW_NO_BREAK_SPACE}$1.`),
+        resolved.normalize("NFD"),
+        resolved.replace(/'/g, "\u2019"),
+        resolved.normalize("NFD").replace(/'/g, "\u2019"),
+    ];
+    for (const variant of new Set(variants)) {
+        if (getOrThrow(await env.exists(variant, signal)))
+            return variant;
+    }
+    return resolved;
+}
+//# sourceMappingURL=path-utils.js.map

package/node_modules/@earendil-works/pi-agent-core/dist/harness/tools/read.js

@@ -0,0 +1,110 @@
+import { Type } from "typebox";
+import { getOrThrow } from "../types.js";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead, } from "../utils/truncate.js";
+import { detectSupportedImageMimeType, encodeBase64 } from "./image.js";
+import { resolveReadToolPath } from "./path-utils.js";
+const readSchema = Type.Object({
+    path: Type.String({ description: "Path to the file to read (relative or absolute)" }),
+    offset: Type.Optional(Type.Number({ description: "Line number to start reading from (1-indexed)" })),
+    limit: Type.Optional(Type.Number({ description: "Maximum number of lines to read" })),
+});
+export function createReadTool(options) {
+    return {
+        name: "read",
+        label: "read",
+        description: `Read the contents of a file. Supports text files and images (jpg, png, gif, webp, bmp). Images are sent as attachments. For text files, output is truncated to ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). Use offset/limit for large files. When you need the full file, continue with offset until complete.`,
+        parameters: readSchema,
+        async execute(_toolCallId, { path, offset, limit }, signal, _onUpdate, { env }) {
+            const absolutePath = await resolveReadToolPath(env, path, signal);
+            const bytes = getOrThrow(await env.readBinaryFile(absolutePath, signal));
+            const mimeType = detectSupportedImageMimeType(bytes);
+            if (mimeType) {
+                if (options?.imageProcessor) {
+                    const processed = await options.imageProcessor(bytes, mimeType, {
+                        autoResizeImages: options.autoResizeImages ?? true,
+                    });
+                    if (!processed.ok) {
+                        return {
+                            content: [{ type: "text", text: `Read image file [${mimeType}]\n${processed.message}` }],
+                            details: undefined,
+                        };
+                    }
+                    const hints = processed.hints.length > 0 ? `\n${processed.hints.join("\n")}` : "";
+                    return {
+                        content: [
+                            { type: "text", text: `Read image file [${processed.mimeType}]${hints}` },
+                            { type: "image", data: processed.data, mimeType: processed.mimeType },
+                        ],
+                        details: undefined,
+                    };
+                }
+                if (mimeType === "image/bmp") {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "Read image file [image/bmp]\n[Image omitted: configure an imageProcessor to convert BMP images.]",
+                            },
+                        ],
+                        details: undefined,
+                    };
+                }
+                return {
+                    content: [
+                        { type: "text", text: `Read image file [${mimeType}]` },
+                        { type: "image", data: encodeBase64(bytes), mimeType },
+                    ],
+                    details: undefined,
+                };
+            }
+            const textContent = new TextDecoder().decode(bytes);
+            const allLines = textContent.split("\n");
+            const totalFileLines = allLines.length;
+            const startLine = offset ? Math.max(0, offset - 1) : 0;
+            const startLineDisplay = startLine + 1;
+            if (startLine >= allLines.length) {
+                throw new Error(`Offset ${offset} is beyond end of file (${allLines.length} lines total)`);
+            }
+            let selectedContent;
+            let userLimitedLines;
+            if (limit !== undefined) {
+                const endLine = Math.min(startLine + limit, allLines.length);
+                selectedContent = allLines.slice(startLine, endLine).join("\n");
+                userLimitedLines = endLine - startLine;
+            }
+            else {
+                selectedContent = allLines.slice(startLine).join("\n");
+            }
+            const truncation = truncateHead(selectedContent);
+            let outputText;
+            let details;
+            if (truncation.firstLineExceedsLimit) {
+                const firstLineSize = formatSize(new TextEncoder().encode(allLines[startLine]).byteLength);
+                outputText = `[Line ${startLineDisplay} is ${firstLineSize}, exceeds ${formatSize(DEFAULT_MAX_BYTES)} limit. Use bash: sed -n '${startLineDisplay}p' ${path} | head -c ${DEFAULT_MAX_BYTES}]`;
+                details = { truncation };
+            }
+            else if (truncation.truncated) {
+                const endLineDisplay = startLineDisplay + truncation.outputLines - 1;
+                const nextOffset = endLineDisplay + 1;
+                outputText = truncation.content;
+                if (truncation.truncatedBy === "lines") {
+                    outputText += `\n\n[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use offset=${nextOffset} to continue.]`;
+                }
+                else {
+                    outputText += `\n\n[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Use offset=${nextOffset} to continue.]`;
+                }
+                details = { truncation };
+            }
+            else if (userLimitedLines !== undefined && startLine + userLimitedLines < allLines.length) {
+                const remaining = allLines.length - (startLine + userLimitedLines);
+                const nextOffset = startLine + userLimitedLines + 1;
+                outputText = `${truncation.content}\n\n[${remaining} more lines in file. Use offset=${nextOffset} to continue.]`;
+            }
+            else {
+                outputText = truncation.content;
+            }
+            return { content: [{ type: "text", text: outputText }], details };
+        },
+    };
+}
+//# sourceMappingURL=read.js.map

package/node_modules/@earendil-works/pi-agent-core/dist/harness/tools/tool-context.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tool-context.js.map

package/node_modules/@earendil-works/pi-agent-core/dist/harness/tools/write.js

@@ -0,0 +1,31 @@
+import { Type } from "typebox";
+import { getOrThrow } from "../types.js";
+import { withFileMutationQueue } from "./file-mutation-queue.js";
+import { resolveToolPath } from "./path-utils.js";
+const writeSchema = Type.Object({
+    path: Type.String({ description: "Path to the file to write (relative or absolute)" }),
+    content: Type.String({ description: "Content to write to the file" }),
+});
+export function createWriteTool() {
+    return {
+        name: "write",
+        label: "write",
+        description: "Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Automatically creates parent directories.",
+        parameters: writeSchema,
+        async execute(_toolCallId, { path, content }, signal, _onUpdate, { env }) {
+            const absolutePath = await resolveToolPath(env, path, signal);
+            return withFileMutationQueue(env, absolutePath, async () => {
+                if (signal?.aborted)
+                    throw new Error("Operation aborted");
+                getOrThrow(await env.writeFile(absolutePath, content, signal));
+                if (signal?.aborted)
+                    throw new Error("Operation aborted");
+                return {
+                    content: [{ type: "text", text: `Successfully wrote ${content.length} bytes to ${path}` }],
+                    details: undefined,
+                };
+            });
+        },
+    };
+}
+//# sourceMappingURL=write.js.map

package/node_modules/@earendil-works/pi-agent-core/dist/harness/utils/shell-output.js

@@ -1,5 +1,5 @@
 import { ExecutionError, err, ok, toError } from "../types.js";
-import { DEFAULT_MAX_BYTES, truncateTail } from "./truncate.js";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, truncateTail } from "./truncate.js";
 function toExecutionError(error) {
     if (error instanceof ExecutionError)
         return error;
@@ -22,61 +22,104 @@ export function sanitizeBinaryOutput(str) {
     })
         .join("");
 }
+function trimToLastUtf8Bytes(text, maxBytes, encoder) {
+    const bytes = encoder.encode(text);
+    if (bytes.byteLength <= maxBytes)
+        return text;
+    let start = bytes.byteLength - maxBytes;
+    while (start < bytes.byteLength && ((bytes[start] ?? 0) & 0xc0) === 0x80)
+        start++;
+    return new TextDecoder().decode(bytes.subarray(start));
+}
 export async function executeShellWithCapture(env, command, options) {
-    const outputChunks = [];
-    let outputBytes = 0;
+    let tailOutput = "";
     const maxOutputBytes = DEFAULT_MAX_BYTES * 2;
     const encoder = new TextEncoder();
     let totalBytes = 0;
+    let completedLines = 0;
+    let hasOpenLine = false;
+    let currentLineBytes = 0;
     let fullOutputPath;
+    let fullOutputRequested = false;
+    let acceptingOutput = true;
     let writeChain = Promise.resolve(ok(undefined));
     let captureError;
     const appendFullOutput = (text) => {
-        if (!fullOutputPath || captureError)
+        if (!fullOutputRequested || captureError)
             return;
-        const path = fullOutputPath;
         writeChain = writeChain.then(async (previous) => {
             if (!previous.ok)
                 return previous;
-            const appendResult = await env.appendFile(path, text, options?.abortSignal);
+            if (!fullOutputPath)
+                return err(new ExecutionError("unknown", "Full output path was not created"));
+            const appendResult = await env.appendFile(fullOutputPath, text);
             return appendResult.ok ? ok(undefined) : err(toExecutionError(appendResult.error));
         });
     };
     const ensureFullOutputFile = (initialContent) => {
-        if (fullOutputPath || captureError)
+        if (fullOutputRequested || captureError)
             return;
+        fullOutputRequested = true;
         writeChain = writeChain.then(async (previous) => {
             if (!previous.ok)
                 return previous;
-            const tempFile = await env.createTempFile({
-                prefix: "bash-",
-                suffix: ".log",
-                abortSignal: options?.abortSignal,
-            });
+            const tempFile = await env.createTempFile({ prefix: "bash-", suffix: ".log" });
             if (!tempFile.ok)
                 return err(toExecutionError(tempFile.error));
             fullOutputPath = tempFile.value;
-            const appendResult = await env.appendFile(tempFile.value, initialContent, options?.abortSignal);
+            const appendResult = await env.appendFile(tempFile.value, initialContent);
             return appendResult.ok ? ok(undefined) : err(toExecutionError(appendResult.error));
         });
     };
+    const createProgress = () => {
+        const tailTruncation = truncateTail(tailOutput);
+        const totalLines = completedLines + (hasOpenLine ? 1 : 0);
+        const truncated = totalLines > DEFAULT_MAX_LINES || totalBytes > DEFAULT_MAX_BYTES;
+        const truncation = {
+            ...tailTruncation,
+            truncated,
+            truncatedBy: truncated
+                ? (tailTruncation.truncatedBy ?? (totalBytes > DEFAULT_MAX_BYTES ? "bytes" : "lines"))
+                : null,
+            totalLines,
+            totalBytes,
+        };
+        return {
+            output: truncated ? truncation.content : tailOutput,
+            truncation,
+            fullOutputPath,
+            lastLineBytes: currentLineBytes,
+        };
+    };
     const onChunk = (chunk) => {
+        if (!acceptingOutput)
+            return;
         try {
-            totalBytes += encoder.encode(chunk).byteLength;
             const text = sanitizeBinaryOutput(chunk).replace(/\r/g, "");
-            if (totalBytes > DEFAULT_MAX_BYTES && !fullOutputPath) {
-                ensureFullOutputFile(outputChunks.join("") + text);
+            const textBytes = encoder.encode(text).byteLength;
+            totalBytes += textBytes;
+            const newlineCount = text.split("\n").length - 1;
+            completedLines += newlineCount;
+            const lastNewline = text.lastIndexOf("\n");
+            if (lastNewline >= 0) {
+                const trailingText = text.slice(lastNewline + 1);
+                currentLineBytes = encoder.encode(trailingText).byteLength;
+                hasOpenLine = trailingText.length > 0;
             }
-            else {
-                appendFullOutput(text);
+            else if (text.length > 0) {
+                currentLineBytes += textBytes;
+                hasOpenLine = true;
+            }
+            tailOutput += text;
+            const totalLines = completedLines + (hasOpenLine ? 1 : 0);
+            if ((totalBytes > DEFAULT_MAX_BYTES || totalLines > DEFAULT_MAX_LINES) && !fullOutputRequested) {
+                ensureFullOutputFile(tailOutput);
             }
-            outputChunks.push(text);
-            outputBytes += text.length;
-            while (outputBytes > maxOutputBytes && outputChunks.length > 1) {
-                const removed = outputChunks.shift();
-                outputBytes -= removed.length;
+            else if (fullOutputRequested) {
+                appendFullOutput(text);
             }
-            options?.onChunk?.(text);
+            tailOutput = trimToLastUtf8Bytes(tailOutput, maxOutputBytes, encoder);
+            options?.onChunk?.(text, createProgress);
         }
         catch (error) {
             captureError = toExecutionError(error);
@@ -84,42 +127,54 @@ export async function executeShellWithCapture(env, command, options) {
     };
     try {
         const result = await env.exec(command, {
-            ...(options ?? {}),
+            cwd: options?.cwd,
+            env: options?.env,
+            inheritEnv: options?.inheritEnv,
+            timeout: options?.timeout,
+            abortSignal: options?.abortSignal,
             onStdout: onChunk,
             onStderr: onChunk,
         });
-        const tailOutput = outputChunks.join("");
-        const truncationResult = truncateTail(tailOutput);
-        if (truncationResult.truncated && !fullOutputPath) {
+        acceptingOutput = false;
+        let progress = createProgress();
+        if (progress.truncation.truncated && !fullOutputRequested)
             ensureFullOutputFile(tailOutput);
-        }
         const writeResult = await writeChain;
         if (!writeResult.ok)
             return err(writeResult.error);
         if (captureError)
             return err(captureError);
+        progress = createProgress();
         if (!result.ok) {
             if (result.error.code === "aborted" || options?.abortSignal?.aborted) {
                 return ok({
-                    output: truncationResult.truncated ? truncationResult.content : tailOutput,
+                    ...progress,
                     exitCode: undefined,
                     cancelled: true,
-                    truncated: truncationResult.truncated,
-                    fullOutputPath,
+                    truncated: progress.truncation.truncated,
+                });
+            }
+            if (options?.returnExecutionErrors) {
+                return ok({
+                    ...progress,
+                    exitCode: undefined,
+                    cancelled: false,
+                    truncated: progress.truncation.truncated,
+                    executionError: result.error,
                 });
             }
             return err(result.error);
         }
         const cancelled = options?.abortSignal?.aborted ?? false;
         return ok({
-            output: truncationResult.truncated ? truncationResult.content : tailOutput,
+            ...progress,
             exitCode: cancelled ? undefined : result.value.exitCode,
             cancelled,
-            truncated: truncationResult.truncated,
-            fullOutputPath,
+            truncated: progress.truncation.truncated,
         });
     }
     catch (error) {
+        acceptingOutput = false;
         return err(toExecutionError(error));
     }
 }

package/node_modules/@earendil-works/pi-agent-core/dist/harness/utils/truncate.js

@@ -43,6 +43,14 @@ function utf8ByteLength(content) {
     }
     return bytes;
 }
+function splitLinesForCounting(content) {
+    if (content.length === 0)
+        return [];
+    const lines = content.split("\n");
+    if (content.endsWith("\n"))
+        lines.pop();
+    return lines;
+}
 function replaceUnpairedSurrogates(content) {
     let output = "";
     for (let i = 0; i < content.length; i++) {
@@ -92,7 +100,7 @@ export function truncateHead(content, options = {}) {
     const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
     const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
     const totalBytes = utf8ByteLength(content);
-    const lines = content.split("\n");
+    const lines = splitLinesForCounting(content);
     const totalLines = lines.length;
     // Check if no truncation needed
     if (totalLines <= maxLines && totalBytes <= maxBytes) {
@@ -171,9 +179,7 @@ export function truncateTail(content, options = {}) {
     const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
     const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
     const totalBytes = utf8ByteLength(content);
-    const lines = content.split("\n");
-    if (lines.length > 1 && lines[lines.length - 1] === "")
-        lines.pop();
+    const lines = splitLinesForCounting(content);
     const totalLines = lines.length;
     // Check if no truncation needed
     if (totalLines <= maxLines && totalBytes <= maxBytes) {

package/node_modules/@earendil-works/pi-agent-core/dist/index.js

@@ -16,6 +16,7 @@ export * from "./harness/session/repo-utils.js";
 export * from "./harness/session/session.js";
 export * from "./harness/skills.js";
 export * from "./harness/system-prompt.js";
+export * from "./harness/tools/index.js";
 // Harness
 export * from "./harness/types.js";
 export * from "./harness/utils/shell-output.js";

package/node_modules/@earendil-works/pi-agent-core/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@earendil-works/pi-agent-core",
-	"version": "0.81.1",
+	"version": "0.82.0",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -29,7 +29,8 @@
 		"prepublishOnly": "npm run build"
 	},
 	"dependencies": {
-		"@earendil-works/pi-ai": "^0.81.1",
+		"@earendil-works/pi-ai": "^0.82.0",
+		"diff": "8.0.4",
 		"ignore": "7.0.5",
 		"typebox": "1.1.38",
 		"yaml": "2.9.0"

package/node_modules/@earendil-works/pi-ai/dist/api/anthropic-messages.js

@@ -5,7 +5,9 @@ import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
 import { parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
+import { retryProviderRequest } from "../utils/provider-retry.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
+import { resolveJsonSchemaStrictSampling } from "./constrained-sampling.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
 import { adjustMaxTokensForThinking, buildBaseOptions, clampMaxTokensToContext } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
@@ -115,6 +117,7 @@ function getAnthropicCompat(model) {
         supportsCacheControlOnTools: model.compat?.supportsCacheControlOnTools ?? true,
         supportsTemperature: model.compat?.supportsTemperature ?? true,
         allowEmptySignature: model.compat?.allowEmptySignature ?? false,
+        supportsStrictTools: model.compat?.supportsStrictTools ?? false,
         supportsToolReferences: model.compat?.supportsToolReferences ?? defaultSupportsToolReferences(model),
     };
 }
@@ -365,9 +368,13 @@ export const stream = (model, context, options) => {
             const requestOptions = {
                 ...(options?.signal ? { signal: options.signal } : {}),
                 ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
-                maxRetries: options?.maxRetries ?? 0,
+                maxRetries: 0,
             };
-            const response = await client.messages.create({ ...params, stream: true }, requestOptions).asResponse();
+            const response = await retryProviderRequest(() => client.messages.create({ ...params, stream: true }, requestOptions).asResponse(), {
+                maxRetries: options?.maxRetries,
+                maxRetryDelayMs: options?.maxRetryDelayMs,
+                signal: options?.signal,
+            });
             await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
             stream.push({ type: "start", partial: output });
             const blocks = output.content;
@@ -739,8 +746,8 @@ function buildParams(model, context, isOAuthToken, options) {
     }
     if (immediateTools.length > 0 || deferredTools.length > 0) {
         params.tools = [
-            ...convertTools(immediateTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsCacheControlOnTools ? cacheControl : undefined),
-            ...convertTools(deferredTools, isOAuthToken, compat.supportsEagerToolInputStreaming, undefined, true),
+            ...convertTools(immediateTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, compat.supportsCacheControlOnTools ? cacheControl : undefined),
+            ...convertTools(deferredTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, undefined, true),
         ];
     }
     // Configure thinking mode: adaptive, budget-based, or explicitly disabled.
@@ -978,20 +985,29 @@ function convertMessages(transformedMessages, isOAuthToken, cacheControl, allowE
 function shouldUseFineGrainedToolStreamingBeta(model, context) {
     return !!context.tools?.length && !getAnthropicCompat(model).supportsEagerToolInputStreaming;
 }
-function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, cacheControl, deferLoading = false) {
+function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, supportsStrictTools, cacheControl, deferLoading = false) {
     if (!tools)
         return [];
     return tools.map((tool, index) => {
+        const strict = resolveJsonSchemaStrictSampling(tool, supportsStrictTools);
         const schema = tool.parameters;
+        const legacyInputSchema = {
+            type: "object",
+            properties: schema.properties ?? {},
+            required: schema.required ?? [],
+        };
+        const inputSchema = strict === true
+            ? {
+                ...tool.parameters,
+                ...legacyInputSchema,
+            }
+            : legacyInputSchema;
         return {
             name: isOAuthToken ? toClaudeCodeName(tool.name) : tool.name,
             description: tool.description,
             ...(supportsEagerToolInputStreaming ? { eager_input_streaming: true } : {}),
-            input_schema: {
-                type: "object",
-                properties: schema.properties ?? {},
-                required: schema.required ?? [],
-            },
+            ...(strict === true ? { strict: true } : {}),
+            input_schema: inputSchema,
             ...(deferLoading ? { defer_loading: true } : {}),
             ...(cacheControl && index === tools.length - 1 ? { cache_control: cacheControl } : {}),
         };