@psnext/slingcli 3.0.20260820-2 → 3.0.20260827-1

package/node_modules/@aws-sdk/nested-clients/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/nested-clients",
-  "version": "3.997.43",
+  "version": "3.997.44",
   "description": "Nested clients for AWS SDK packages.",
   "homepage": "https://github.com/aws/aws-sdk-js-v3/tree/main/packages/nested-clients",
   "license": "Apache-2.0",
@@ -100,13 +100,13 @@
     "test:watch": "yarn g:vitest watch"
   },
   "dependencies": {
-    "@aws-sdk/core": "^3.977.8",
-    "@aws-sdk/signature-v4-multi-region": "^3.996.45",
-    "@aws-sdk/types": "^3.974.4",
-    "@smithy/core": "^3.31.1",
-    "@smithy/fetch-http-handler": "^5.6.13",
-    "@smithy/node-http-handler": "^4.9.13",
-    "@smithy/types": "^4.16.1",
+    "@aws-sdk/core": "^3.977.9",
+    "@aws-sdk/signature-v4-multi-region": "^3.996.46",
+    "@aws-sdk/types": "^3.974.5",
+    "@smithy/core": "^3.33.3",
+    "@smithy/fetch-http-handler": "^5.7.2",
+    "@smithy/node-http-handler": "^4.11.3",
+    "@smithy/types": "^4.17.2",
     "tslib": "^2.6.2"
   },
   "devDependencies": {

package/node_modules/@aws-sdk/signature-v4-multi-region/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/signature-v4-multi-region",
-  "version": "3.996.45",
+  "version": "3.996.46",
   "homepage": "https://github.com/aws/aws-sdk-js-v3/tree/main/packages/signature-v4-multi-region",
   "license": "Apache-2.0",
   "author": {
@@ -42,9 +42,9 @@
     "test:browser": "yarn build:browser && yarn g:vitest run -c vitest.config.browser.mts"
   },
   "dependencies": {
-    "@aws-sdk/types": "^3.974.4",
+    "@aws-sdk/types": "^3.974.5",
     "@smithy/signature-v4": "^5.6.12",
-    "@smithy/types": "^4.16.1",
+    "@smithy/types": "^4.17.2",
     "tslib": "^2.6.2"
   },
   "devDependencies": {

package/node_modules/@aws-sdk/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/types",
-  "version": "3.974.4",
+  "version": "3.974.5",
   "description": "Types for the AWS SDK",
   "homepage": "https://github.com/aws/aws-sdk-js-v3/tree/main/packages-internal/types",
   "license": "Apache-2.0",
@@ -41,7 +41,7 @@
     "test": "tsc -p tsconfig.test.json"
   },
   "dependencies": {
-    "@smithy/types": "^4.16.1",
+    "@smithy/types": "^4.17.2",
     "tslib": "^2.6.2"
   },
   "devDependencies": {

package/node_modules/@aws-sdk/xml-builder/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/xml-builder",
-  "version": "3.972.39",
+  "version": "3.972.40",
   "description": "XML utilities for the AWS SDK",
   "homepage": "https://github.com/aws/aws-sdk-js-v3/tree/main/packages-internal/xml-builder",
   "license": "Apache-2.0",
@@ -47,7 +47,7 @@
     "test:fuzz": "jazzer tests/xml-parser.fuzz.js corpus --sync -i xml-parser -- -max_total_time=300"
   },
   "dependencies": {
-    "@smithy/types": "^4.16.1",
+    "@smithy/types": "^4.17.2",
     "tslib": "^2.6.2"
   },
   "devDependencies": {

package/node_modules/@earendil-works/pi-agent-core/dist/harness/env/nodejs.js

@@ -201,11 +201,13 @@ function getShellEnv(baseEnv, extraEnv, inheritEnv = true) {
 function killProcessTree(pid) {
     if (process.platform === "win32") {
         try {
-            spawn("taskkill", ["/F", "/T", "/PID", String(pid)], {
+            const child = spawn(join(process.env.SystemRoot ?? "C:\\Windows", "System32", "taskkill.exe"), ["/F", "/T", "/PID", String(pid)], {
                 stdio: "ignore",
                 detached: true,
                 windowsHide: true,
             });
+            // A failed spawn emits "error" asynchronously; consume it to avoid crashing Node.
+            child.once("error", () => { });
         }
         catch {
             // Ignore errors.

package/node_modules/@earendil-works/pi-agent-core/dist/harness/session/jsonl/repo.js

@@ -10,9 +10,57 @@ function validateSessionId(id) {
         throw new SessionError("invalid_payload", "Session id must be non-empty, contain only alphanumeric characters, '-', '_', and '.', and start and end with an alphanumeric character");
     }
 }
-function sessionDirectoryName(cwd) {
+function jsonlSessionDirectoryName(cwd) {
     return `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
 }
+async function jsonlSessionsRoot(options) {
+    return fileResult(await options.fs.absolutePath(options.sessionsRoot), `Failed to resolve sessions root ${options.sessionsRoot}`);
+}
+async function jsonlSessionDirectory(fs, sessionsRoot, cwd) {
+    return fileResult(await fs.joinPath([sessionsRoot, jsonlSessionDirectoryName(cwd)]), `Failed to resolve sessions directory for ${cwd}`);
+}
+async function jsonlSessionDirectories(options, cwd) {
+    const sessionsRoot = await jsonlSessionsRoot(options);
+    if (cwd !== undefined) {
+        const resolvedCwd = fileResult(await options.fs.absolutePath(cwd), `Failed to resolve session cwd ${cwd}`);
+        const directory = await jsonlSessionDirectory(options.fs, sessionsRoot, resolvedCwd);
+        return fileResult(await options.fs.exists(directory), `Failed to check sessions directory ${directory}`)
+            ? [directory]
+            : [];
+    }
+    if (!fileResult(await options.fs.exists(sessionsRoot), `Failed to check sessions directory ${sessionsRoot}`))
+        return [];
+    return fileResult(await options.fs.listDir(sessionsRoot), `Failed to list sessions directory ${sessionsRoot}`)
+        .filter((entry) => entry.kind === "directory" || entry.kind === "symlink")
+        .map((entry) => entry.path);
+}
+export async function listJsonlSessionMetadata(options, query = {}) {
+    const metadata = [];
+    for (const directory of await jsonlSessionDirectories(options, query.cwd)) {
+        const files = fileResult(await options.fs.listDir(directory), `Failed to list sessions directory ${directory}`).filter((entry) => entry.kind !== "directory" && entry.name.endsWith(".jsonl"));
+        for (const file of files) {
+            const [firstLine] = fileResult(await options.fs.readTextLines(file.path, { maxLines: 1 }), `Failed to read session header ${file.path}`);
+            if (!firstLine)
+                continue;
+            const headerResult = parseHeader(firstLine);
+            if (!headerResult.ok)
+                continue;
+            metadata.push(metadataFromHeader(headerResult.value, file.path, file.mtimeMs));
+        }
+    }
+    return metadata.sort((left, right) => right.modifiedAt - left.modifiedAt);
+}
+export async function loadJsonlSessionStorage(options, metadata) {
+    if (!fileResult(await options.fs.exists(metadata.path), `Failed to check session ${metadata.path}`)) {
+        throw new SessionError("not_found", `Session not found: ${metadata.id}`);
+    }
+    const storage = await JsonlSessionStorage.load(options.fs, metadata.path);
+    const loadedMetadata = await storage.getMetadata();
+    if (loadedMetadata.id !== metadata.id) {
+        throw new SessionError("invalid_entry", `Session id does not match header: ${metadata.id}`);
+    }
+    return storage;
+}
 function sessionFileName(createdAt, id) {
     const timestamp = new Date(createdAt).toISOString().replace(/[:.]/g, "-");
     return `${timestamp}_${id}.jsonl`;
@@ -55,15 +103,7 @@ export class JsonlSessionRepo {
         });
     }
     async loadStorage(metadata) {
-        if (!fileResult(await this.fs.exists(metadata.path), `Failed to check session ${metadata.path}`)) {
-            throw new SessionError("not_found", `Session not found: ${metadata.id}`);
-        }
-        const storage = await JsonlSessionStorage.load(this.fs, metadata.path);
-        const loadedMetadata = await storage.getMetadata();
-        if (loadedMetadata.id !== metadata.id) {
-            throw new SessionError("invalid_entry", `Session id does not match header: ${metadata.id}`);
-        }
-        return storage;
+        return loadJsonlSessionStorage({ fs: this.fs, sessionsRoot: this.sessionsRootInput }, metadata);
     }
     async resolveCreateDestination(options) {
         const id = options.id ?? uuidv7();
@@ -112,21 +152,7 @@ export class JsonlSessionRepo {
         return { header, path };
     }
     async listDirect(options) {
-        const directories = await this.sessionDirectories(options.cwd);
-        const metadata = [];
-        for (const directory of directories) {
-            const files = fileResult(await this.fs.listDir(directory), `Failed to list sessions directory ${directory}`).filter((entry) => entry.kind !== "directory" && entry.name.endsWith(".jsonl"));
-            for (const file of files) {
-                const [firstLine] = fileResult(await this.fs.readTextLines(file.path, { maxLines: 1 }), `Failed to read session header ${file.path}`);
-                if (!firstLine)
-                    continue;
-                const headerResult = parseHeader(firstLine);
-                if (!headerResult.ok)
-                    continue;
-                metadata.push(metadataFromHeader(headerResult.value, file.path, file.mtimeMs));
-            }
-        }
-        return metadata.sort((left, right) => right.modifiedAt - left.modifiedAt);
+        return listJsonlSessionMetadata({ fs: this.fs, sessionsRoot: this.sessionsRootInput }, options);
     }
     async sessionIdExists(id, cwd) {
         const suffix = `_${id}.jsonl`;
@@ -136,23 +162,8 @@ export class JsonlSessionRepo {
         const files = fileResult(await this.fs.listDir(directory), `Failed to list sessions directory ${directory}`);
         return files.some((entry) => entry.kind !== "directory" && entry.name.endsWith(suffix));
     }
-    async sessionDirectories(cwd) {
-        const root = await this.root();
-        if (cwd !== undefined) {
-            const resolvedCwd = fileResult(await this.fs.absolutePath(cwd), `Failed to resolve session cwd ${cwd}`);
-            const directory = await this.sessionDirectory(resolvedCwd);
-            return fileResult(await this.fs.exists(directory), `Failed to check sessions directory ${directory}`)
-                ? [directory]
-                : [];
-        }
-        if (!fileResult(await this.fs.exists(root), `Failed to check sessions directory ${root}`))
-            return [];
-        return fileResult(await this.fs.listDir(root), `Failed to list sessions directory ${root}`)
-            .filter((entry) => entry.kind === "directory" || entry.kind === "symlink")
-            .map((entry) => entry.path);
-    }
     async sessionDirectory(cwd) {
-        return fileResult(await this.fs.joinPath([await this.root(), sessionDirectoryName(cwd)]), `Failed to resolve sessions directory for ${cwd}`);
+        return fileResult(await this.fs.joinPath([await this.root(), jsonlSessionDirectoryName(cwd)]), `Failed to resolve sessions directory for ${cwd}`);
     }
     root() {
         this.rootPromise ??= this.fs

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

@@ -12,8 +12,9 @@ export function formatSkillInvocation(skill, additionalInstructions) {
 /**
  * Load skills from one or more directories.
  *
- * Traverses directories recursively, loads `SKILL.md` files, loads direct root `.md` files as skills, honors ignore files,
- * and returns diagnostics for invalid skill files. Missing input directories are skipped.
+ * Traverses directories recursively, loads `SKILL.md` files, loads direct root `.md` files with skill
+ * frontmatter, honors ignore files, and returns diagnostics for invalid declared skill files. Missing input
+ * directories are skipped.
  */
 export async function loadSkills(env, dirs) {
     const skills = [];
@@ -190,6 +191,10 @@ function prefixIgnorePattern(line, prefix) {
 }
 async function loadSkillFromFile(env, filePath, parentDirName) {
     const diagnostics = [];
+    const isDeclaredSkill = filePath
+        .replace(/[\\/]+$/, "")
+        .split(/[\\/]/)
+        .pop() === "SKILL.md";
     const rawContent = await env.readTextFile(filePath);
     if (!rawContent.ok) {
         diagnostics.push({ type: "warning", code: "read_failed", message: rawContent.error.message, path: filePath });
@@ -197,11 +202,16 @@ async function loadSkillFromFile(env, filePath, parentDirName) {
     }
     const parsed = parseFrontmatter(rawContent.value);
     if (!parsed.ok) {
-        diagnostics.push({ type: "warning", code: "parse_failed", message: parsed.error.message, path: filePath });
+        if (isDeclaredSkill) {
+            diagnostics.push({ type: "warning", code: "parse_failed", message: parsed.error.message, path: filePath });
+        }
         return { skill: null, diagnostics };
     }
     const { frontmatter, body } = parsed.value;
     const description = typeof frontmatter.description === "string" ? frontmatter.description : undefined;
+    if (!isDeclaredSkill && (!description || description.trim() === "")) {
+        return { skill: null, diagnostics };
+    }
     for (const error of validateDescription(description)) {
         diagnostics.push({ type: "warning", code: "invalid_metadata", message: error, path: filePath });
     }

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

@@ -14,6 +14,12 @@ const editSchema = Type.Object({
         description: "One or more targeted replacements. Each edit is matched against the original file, not incrementally. Do not include overlapping or nested edits. If two changes touch the same block or nearby lines, merge them into one edit instead.",
     }),
 }, {});
+function isSingleEditInput(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const edit = value;
+    return typeof edit.oldText === "string" && typeof edit.newText === "string";
+}
 function prepareEditArguments(input) {
     if (!input || typeof input !== "object")
         return input;
@@ -21,11 +27,18 @@ function prepareEditArguments(input) {
     if (typeof args.edits === "string") {
         try {
             const parsed = JSON.parse(args.edits);
-            if (Array.isArray(parsed))
+            if (Array.isArray(parsed)) {
                 args.edits = parsed;
+            }
+            else if (isSingleEditInput(parsed)) {
+                args.edits = [parsed];
+            }
         }
         catch { }
     }
+    else if (isSingleEditInput(args.edits)) {
+        args.edits = [args.edits];
+    }
     const legacy = args;
     if (typeof legacy.oldText !== "string" || typeof legacy.newText !== "string")
         return args;

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

@@ -12,7 +12,6 @@ export * from "./harness/prompt-templates.js";
 // Harness
 export * from "./harness/result.js";
 export * from "./harness/session/index.js";
-export * from "./harness/session/search.js";
 export * from "./harness/skills.js";
 export * from "./harness/system-prompt.js";
 export { AGENT_TELEMETRY_SCHEMAS, AI_TELEMETRY_SCHEMA, HARNESS_TELEMETRY_SCHEMA, startAiSpan, startHarnessSpan, } from "./harness/telemetry.js";
@@ -22,6 +21,7 @@ export * from "./harness/utils/shell-output.js";
 export * from "./harness/utils/truncate.js";
 // Proxy utilities
 export * from "./proxy.js";
+export * from "./search/index.js";
 // Stream defaults
 export { setDefaultStreamFn } from "./stream-fn.js";
 // Types

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

@@ -0,0 +1,2 @@
+export { createScanningSessionSearch, scanningEntries } from "./scanning.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,103 @@
+function defaultSearchText(_metadata, entry, label) {
+    return label === undefined ? JSON.stringify(entry) : `${JSON.stringify(entry)} ${label}`;
+}
+async function* scanReadableEntries(readable, metadata, options, query = {}) {
+    const projectText = options.projectText ?? defaultSearchText;
+    const pageSize = query.limit ?? options.pageSize ?? 100;
+    let afterSeq = query.afterSeq ?? 0;
+    const entryTypes = query.entryTypes === undefined ? undefined : new Set(query.entryTypes);
+    while (true) {
+        const entries = await readable.findEntries({
+            order: "oldestFirst",
+            limit: pageSize,
+            cursor: { afterSeq },
+            type: query.entryTypes?.length === 1 ? query.entryTypes[0] : undefined,
+        });
+        if (entries.length === 0)
+            break;
+        for (const entry of entries) {
+            if (entryTypes !== undefined && !entryTypes.has(entry.type))
+                continue;
+            const label = await readable.getLabel(entry.id);
+            yield {
+                entryId: entry.id,
+                seq: entry.seq,
+                type: entry.type,
+                timestamp: entry.timestamp,
+                text: projectText(metadata, entry, label),
+                fields: label === undefined ? undefined : { label },
+            };
+        }
+        afterSeq = entries[entries.length - 1]?.seq ?? afterSeq;
+        if (entries.length < pageSize)
+            break;
+    }
+}
+export async function* scanningEntries(readable, options = {}) {
+    yield* scanReadableEntries(readable, await readable.getMetadata(), options);
+}
+async function* arraySource(readables) {
+    yield* readables;
+}
+function readablesFor(source, options) {
+    return typeof source === "function" ? source(options) : arraySource(source);
+}
+function defaultMatch(queryText, candidate) {
+    return candidate.text.toLowerCase().includes(queryText);
+}
+function throwIfAborted(signal) {
+    if (!signal?.aborted)
+        return;
+    if (signal.reason instanceof Error)
+        throw signal.reason;
+    const error = new Error("The operation was aborted");
+    error.name = "AbortError";
+    throw error;
+}
+function createDefaultScanningHit(metadata, candidate) {
+    return {
+        sessionId: metadata.id,
+        entryId: candidate.entryId,
+        timestamp: candidate.timestamp,
+        snippet: candidate.text,
+    };
+}
+export function createScanningSessionSearch(source, options = {}) {
+    const createHit = options.createHit ??
+        ((metadata, candidate) => createDefaultScanningHit(metadata, candidate));
+    return {
+        async *search(text, searchOptions = {}) {
+            const normalizedText = text.trim().toLowerCase();
+            if (!normalizedText || (searchOptions.limit !== undefined && searchOptions.limit <= 0))
+                return;
+            if (searchOptions.entryTypes?.length === 0)
+                return;
+            let hitCount = 0;
+            const seenSessionIds = new Set();
+            const entryTypes = searchOptions.entryTypes === undefined ? undefined : new Set(searchOptions.entryTypes);
+            const sourceOptions = options.sourceOptions?.(normalizedText, searchOptions);
+            for await (const readable of readablesFor(source, sourceOptions)) {
+                throwIfAborted(searchOptions.signal);
+                const metadata = await readable.getMetadata();
+                if (seenSessionIds.has(metadata.id))
+                    throw new Error(`Duplicate sessionId: ${metadata.id}`);
+                seenSessionIds.add(metadata.id);
+                for await (const candidate of scanReadableEntries(readable, metadata, options, {
+                    entryTypes: searchOptions.entryTypes,
+                })) {
+                    throwIfAborted(searchOptions.signal);
+                    if (entryTypes !== undefined && !entryTypes.has(candidate.type))
+                        continue;
+                    const matches = options.match?.(normalizedText, candidate, metadata) ?? defaultMatch(normalizedText, candidate);
+                    if (!matches)
+                        continue;
+                    yield createHit(metadata, candidate);
+                    hitCount += 1;
+                    if (searchOptions.limit !== undefined && hitCount >= searchOptions.limit)
+                        return;
+                }
+            }
+        },
+    };
+}
+//# sourceMappingURL=scanning.js.map

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

@@ -1,6 +1,6 @@
 {
 	"name": "@earendil-works/pi-agent-core",
-	"version": "0.84.1",
+	"version": "0.84.3",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -35,8 +35,8 @@
 		"prepublishOnly": "npm run build"
 	},
 	"dependencies": {
-		"@earendil-works/pi-ai": "^0.84.1",
-		"@earendil-works/pi-telemetry": "^0.84.1",
+		"@earendil-works/pi-ai": "^0.84.3",
+		"@earendil-works/pi-telemetry": "^0.84.3",
 		"diff": "8.0.4",
 		"ignore": "7.0.5",
 		"typebox": "1.3.7",
@@ -60,7 +60,7 @@
 		"node": ">=22.19.0"
 	},
 	"devDependencies": {
-		"@types/node": "24.12.4",
+		"@types/node": "22.19.19",
 		"@vitest/coverage-v8": "4.1.9",
 		"typescript": "5.9.3",
 		"vitest": "4.1.9"

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

@@ -4,10 +4,11 @@ import { splitDeferredTools } from "../utils/deferred-tools.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
 import { parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse.js";
+import { getPiUserAgent } from "../utils/pi-user-agent.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 { getJsonSchemaToolParameters, 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";
@@ -109,6 +110,10 @@ function convertContentBlocks(content) {
 }
 const FINE_GRAINED_TOOL_STREAMING_BETA = "fine-grained-tool-streaming-2025-05-14";
 const INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
+const SERVER_SIDE_FALLBACK_BETA = "server-side-fallback-2026-07-01";
+function shouldUseServerSideFallbackBeta(model) {
+    return (model.compat?.allowedFallbackModels?.length ?? 0) > 0;
+}
 function getAnthropicCompat(model) {
     return {
         supportsEagerToolInputStreaming: model.compat?.supportsEagerToolInputStreaming ?? true,
@@ -145,6 +150,9 @@ function mergeHeaders(...headerSources) {
     }
     return merged;
 }
+function mergeClientHeaders(...headerSources) {
+    return mergeHeaders({ "User-Agent": getPiUserAgent() }, ...headerSources);
+}
 function hasHeader(headers, name) {
     if (!headers)
         return false;
@@ -339,6 +347,7 @@ export const stream = (model, context, options) => {
         try {
             let client;
             let isOAuth;
+            let usageModel = model;
             if (options?.client) {
                 client = options.client;
                 isOAuth = false;
@@ -356,7 +365,7 @@ export const stream = (model, context, options) => {
                 }
                 const cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env);
                 const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
-                const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, context), options?.headers, options?.fetch, copilotDynamicHeaders, cacheSessionId);
+                const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, context), shouldUseServerSideFallbackBeta(model), options?.headers, options?.fetch, copilotDynamicHeaders, cacheSessionId);
                 client = created.client;
                 isOAuth = created.isOAuthToken;
             }
@@ -381,6 +390,11 @@ export const stream = (model, context, options) => {
             for await (const event of iterateAnthropicEvents(response, options?.signal)) {
                 if (event.type === "message_start") {
                     output.responseId = event.message.id;
+                    output.model = event.message.model;
+                    const fallbackCost = output.model === model.id
+                        ? undefined
+                        : model.compat?.allowedFallbackModels?.find((fallback) => fallback.provider === model.provider && fallback.model === output.model)?.cost;
+                    usageModel = fallbackCost ? { ...model, id: output.model, cost: fallbackCost } : model;
                     // Capture initial token usage from message_start event
                     // This ensures we have input token counts even if the stream is aborted early
                     output.usage.input = event.message.usage.input_tokens || 0;
@@ -391,7 +405,7 @@ export const stream = (model, context, options) => {
                     // Anthropic doesn't provide total_tokens, compute from components
                     output.usage.totalTokens =
                         output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
-                    calculateCost(model, output.usage);
+                    calculateCost(usageModel, output.usage);
                 }
                 else if (event.type === "content_block_start") {
                     if (event.content_block.type === "text") {
@@ -560,7 +574,7 @@ export const stream = (model, context, options) => {
                     // Anthropic doesn't provide total_tokens, compute from components
                     output.usage.totalTokens =
                         output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
-                    calculateCost(model, output.usage);
+                    calculateCost(usageModel, output.usage);
                 }
             }
             if (options?.signal?.aborted) {
@@ -612,9 +626,15 @@ function mapThinkingLevelToEffort(model, level) {
 }
 export const streamSimple = (model, context, options) => {
     assertRequestAuth(model.provider, options?.apiKey, options?.headers);
-    const base = buildBaseOptions(model, context, options, options?.apiKey);
+    const base = {
+        ...buildBaseOptions(model, context, options, options?.apiKey),
+        toolChoice: options?.toolChoice,
+    };
     if (!options?.reasoning) {
-        return stream(model, context, { ...base, thinkingEnabled: false });
+        return stream(model, context, {
+            ...base,
+            thinkingEnabled: false,
+        });
     }
     // For models with adaptive thinking: use an effort level.
     // For older models: use budget-based thinking.
@@ -640,7 +660,7 @@ export const streamSimple = (model, context, options) => {
 function isOAuthToken(apiKey) {
     return apiKey.includes("sk-ant-oat");
 }
-function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStreamingBeta, optionsHeaders, fetch, dynamicHeaders, sessionId) {
+function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStreamingBeta, useServerSideFallbackBeta, optionsHeaders, fetch, dynamicHeaders, sessionId) {
     // Adaptive thinking models have interleaved thinking built in, so skip the beta header.
     const needsInterleavedBeta = interleavedThinking && model.compat?.forceAdaptiveThinking !== true;
     const betaFeatures = [];
@@ -650,6 +670,9 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
     if (needsInterleavedBeta) {
         betaFeatures.push(INTERLEAVED_THINKING_BETA);
     }
+    if (useServerSideFallbackBeta) {
+        betaFeatures.push(SERVER_SIDE_FALLBACK_BETA);
+    }
     // Copilot: Bearer auth, selective betas.
     if (model.provider === "github-copilot") {
         const client = new Anthropic({
@@ -658,7 +681,7 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
             baseURL: model.baseUrl,
             dangerouslyAllowBrowser: true,
             fetch,
-            defaultHeaders: mergeHeaders({
+            defaultHeaders: mergeClientHeaders({
                 accept: "application/json",
                 "anthropic-dangerous-direct-browser-access": "true",
                 ...(betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}),
@@ -674,7 +697,7 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
             baseURL: model.baseUrl,
             dangerouslyAllowBrowser: true,
             fetch,
-            defaultHeaders: mergeHeaders({
+            defaultHeaders: mergeClientHeaders({
                 accept: "application/json",
                 "anthropic-dangerous-direct-browser-access": "true",
                 "anthropic-beta": ["claude-code-20250219", "oauth-2025-04-20", ...betaFeatures].join(","),
@@ -686,7 +709,7 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
     }
     // API key or header-owned auth.
     const sessionAffinityHeaders = sessionId && getAnthropicCompat(model).sendSessionAffinityHeaders ? { "x-session-affinity": sessionId } : {};
-    const defaultHeaders = mergeHeaders({
+    const defaultHeaders = mergeClientHeaders({
         accept: "application/json",
         "anthropic-dangerous-direct-browser-access": "true",
         ...(betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}),
@@ -801,6 +824,10 @@ function buildParams(model, context, isOAuthToken, options) {
             params.tool_choice = options.toolChoice;
         }
     }
+    const allowedFallbackModels = model.compat?.allowedFallbackModels;
+    if (allowedFallbackModels && allowedFallbackModels.length > 0) {
+        params.fallbacks = allowedFallbackModels.map((fallback) => ({ model: fallback.model }));
+    }
     return params;
 }
 // Normalize tool call IDs to match Anthropic's required pattern and length
@@ -997,7 +1024,8 @@ function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, supp
         return [];
     return tools.map((tool, index) => {
         const strict = resolveJsonSchemaStrictSampling(tool, supportsStrictTools);
-        const schema = tool.parameters;
+        const parameters = getJsonSchemaToolParameters(tool, strict);
+        const schema = parameters;
         const legacyInputSchema = {
             type: "object",
             properties: schema.properties ?? {},
@@ -1005,7 +1033,7 @@ function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, supp
         };
         const inputSchema = strict === true
             ? {
-                ...tool.parameters,
+                ...parameters,
                 ...legacyInputSchema,
             }
             : legacyInputSchema;