@psnext/slingcli 3.0.20260820-2 → 3.0.20260827-1

package/node_modules/@earendil-works/pi-ai/dist/api/azure-openai-responses.js

@@ -3,6 +3,7 @@ import { clampThinkingLevel } from "../models.js";
 import { formatProviderError, normalizeProviderError } from "../utils/error-body.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
+import { getPiUserAgent } from "../utils/pi-user-agent.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
 import { retryProviderRequest } from "../utils/provider-retry.js";
 import { createGrammarToolInputProperties } from "./constrained-sampling.js";
@@ -121,7 +122,10 @@ export const streamSimple = (model, context, options) => {
     if (!apiKey) {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
-    const base = buildBaseOptions(model, context, options, apiKey);
+    const base = {
+        ...buildBaseOptions(model, context, options, apiKey),
+        toolChoice: options?.toolChoice,
+    };
     const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
     const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
     return stream(model, context, {
@@ -179,7 +183,7 @@ function resolveAzureConfig(model, options) {
     };
 }
 function createClient(model, apiKey, options) {
-    const headers = { ...model.headers };
+    const headers = { "User-Agent": getPiUserAgent(), ...model.headers };
     if (options?.headers) {
         Object.assign(headers, options.headers);
     }
@@ -216,6 +220,9 @@ function buildParams(model, context, options, deploymentName, grammarToolInputPr
             supportsOpenAIGrammarTools: model.compat?.supportsOpenAIGrammarTools ?? false,
         });
     }
+    if (options?.toolChoice !== undefined) {
+        params.tool_choice = options.toolChoice;
+    }
     if (model.reasoning) {
         if (options?.reasoningEffort || options?.reasoningSummary) {
             const effort = options?.reasoningEffort

package/node_modules/@earendil-works/pi-ai/dist/api/bedrock-converse-stream.js

@@ -11,10 +11,12 @@ import { parseStreamingJson } from "../utils/json-parse.js";
 import { resolveHttpProxyUrlForTarget } from "../utils/node-http-proxy.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
-import { resolveJsonSchemaStrictSampling } from "./constrained-sampling.js";
+import { getJsonSchemaToolParameters, resolveJsonSchemaStrictSampling } from "./constrained-sampling.js";
 import { adjustMaxTokensForThinking, buildBaseOptions, clampMaxTokensToContext, clampReasoning, } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
 const EMPTY_TEXT_PLACEHOLDER = "<empty>";
+/** Matches the placeholder the Anthropic API path uses for redacted thinking. */
+const REDACTED_THINKING_PLACEHOLDER = "[Reasoning redacted]";
 export const stream = (model, context, options = {}) => {
     const stream = new AssistantMessageEventStream();
     (async () => {
@@ -120,7 +122,14 @@ export const stream = (model, context, options = {}) => {
         // exceptions delivered as stream events carry no HTTP metadata of their own.
         let responseRequestId;
         try {
+            const supportsStrictMode = model.compat?.supportsStrictMode ?? false;
             const client = new BedrockRuntimeClient(config);
+            let observedRawResponse = false;
+            if (options.onResponse) {
+                addResponseHeadersMiddleware(client, options.onResponse, model, () => {
+                    observedRawResponse = true;
+                });
+            }
             const customHeaders = providerHeadersToRecord(options.headers);
             if (customHeaders) {
                 addCustomHeadersMiddleware(client, customHeaders);
@@ -135,7 +144,7 @@ export const stream = (model, context, options = {}) => {
                     ...(inferenceMaxTokens !== undefined && { maxTokens: inferenceMaxTokens }),
                     ...(options.temperature !== undefined && { temperature: options.temperature }),
                 },
-                toolConfig: convertToolConfig(context.tools, options.toolChoice, model.compat?.supportsStrictMode ?? false),
+                toolConfig: convertToolConfig(context.tools, options.toolChoice, supportsStrictMode),
                 additionalModelRequestFields: buildAdditionalModelRequestFields(model, options),
                 ...(options.requestMetadata !== undefined && { requestMetadata: options.requestMetadata }),
             };
@@ -146,7 +155,7 @@ export const stream = (model, context, options = {}) => {
             const command = new ConverseStreamCommand(commandInput);
             const response = await client.send(command, { abortSignal: options.signal });
             responseRequestId = normalizeDiagnosticValue(response.$metadata.requestId);
-            if (response.$metadata.httpStatusCode !== undefined) {
+            if (!observedRawResponse && response.$metadata.httpStatusCode !== undefined) {
                 const responseHeaders = {};
                 if (response.$metadata.requestId) {
                     responseHeaders["x-amzn-requestid"] = response.$metadata.requestId;
@@ -205,14 +214,15 @@ export const stream = (model, context, options = {}) => {
             if (output.stopReason === "error" || output.stopReason === "aborted") {
                 throw new Error(output.errorMessage || "An unknown error occurred");
             }
+            // A stream can settle without stopping every block, so finalize here too.
+            for (const block of output.content)
+                finalizeStreamingBlock(block);
             stream.push({ type: "done", reason: output.stopReason, message: output });
             stream.end();
         }
         catch (error) {
             for (const block of output.content) {
-                delete block.index;
-                // partialJson is only a streaming scratch buffer; never persist it.
-                delete block.partialJson;
+                finalizeStreamingBlock(block);
             }
             output.stopReason = options.signal?.aborted ? "aborted" : "error";
             output.errorMessage = formatBedrockError(error);
@@ -341,8 +351,40 @@ function addCustomHeadersMiddleware(client, headers) {
     };
     client.middlewareStack.add(middleware, { step: "build", name: "pi-ai-custom-headers", priority: "low" });
 }
+function isSmithyHttpResponse(response) {
+    if (!response || typeof response !== "object")
+        return false;
+    const candidate = response;
+    return typeof candidate.statusCode === "number" && !!candidate.headers && typeof candidate.headers === "object";
+}
+function toProviderResponse(response) {
+    if (!isSmithyHttpResponse(response))
+        return undefined;
+    return { status: response.statusCode, headers: { ...response.headers } };
+}
+/**
+ * Bedrock's modeled `$metadata` only preserves selected HTTP metadata (for example
+ * requestId), so custom gateway headers are otherwise lost before callers see
+ * `onResponse`. Capture the raw Smithy HTTP response at the deserialize step,
+ * after the SDK receives the response but before the event stream is consumed.
+ */
+function addResponseHeadersMiddleware(client, onResponse, model, onObserved) {
+    const middleware = (next) => async (args) => {
+        const result = await next(args);
+        const providerResponse = toProviderResponse(result.response);
+        if (providerResponse) {
+            onObserved();
+            await onResponse(providerResponse, model);
+        }
+        return result;
+    };
+    client.middlewareStack.add(middleware, { step: "deserialize", name: "pi-ai-response-headers" });
+}
 export const streamSimple = (model, context, options) => {
-    const base = buildBaseOptions(model, context, options, undefined);
+    const base = {
+        ...buildBaseOptions(model, context, options, undefined),
+        toolChoice: options?.toolChoice,
+    };
     if (!options?.reasoning) {
         return stream(model, context, { ...base, reasoning: undefined });
     }
@@ -434,13 +476,54 @@ function handleContentBlockDelta(event, blocks, output, stream) {
                     partial: output,
                 });
             }
-            if (delta.reasoningContent.signature) {
+            // `thinkingSignature` holds either an Anthropic signature or an opaque redacted
+            // payload, never both: mixing them would corrupt whichever arrived first.
+            if (delta.reasoningContent.signature && !thinkingBlock.redacted) {
                 thinkingBlock.thinkingSignature =
                     (thinkingBlock.thinkingSignature || "") + delta.reasoningContent.signature;
             }
+            if (delta.reasoningContent.redactedContent?.length) {
+                // Encrypted reasoning from non-Anthropic models on Bedrock (e.g. OpenAI GPT-5.6).
+                // The payload is opaque, so keep it verbatim in `thinkingSignature` the way the
+                // Anthropic path stores redacted thinking, and replay it on the next turn.
+                if (!thinkingBlock.redacted) {
+                    thinkingBlock.redacted = true;
+                    thinkingBlock.thinkingSignature = "";
+                    thinkingBlock.thinking += REDACTED_THINKING_PLACEHOLDER;
+                    stream.push({
+                        type: "thinking_delta",
+                        contentIndex: thinkingIndex,
+                        delta: REDACTED_THINKING_PLACEHOLDER,
+                        partial: output,
+                    });
+                }
+                thinkingBlock.redactedChunks ??= [];
+                thinkingBlock.redactedChunks.push(delta.reasoningContent.redactedContent);
+            }
         }
     }
 }
+/**
+ * Encodes buffered encrypted reasoning into `thinkingSignature` and drops the scratch
+ * buffer, which must never reach a persisted message: `Uint8Array` serializes to an
+ * index-keyed object roughly ten times the size of the base64 payload.
+ */
+function flushRedactedContent(block) {
+    if (block.type !== "thinking" || !block.redactedChunks)
+        return;
+    block.thinkingSignature = bytesToBase64(block.redactedChunks);
+    delete block.redactedChunks;
+}
+/**
+ * Strips every streaming scratch field. Runs from the terminal paths as well as
+ * `contentBlockStop`, because a stream can settle without stopping each block.
+ */
+function finalizeStreamingBlock(block) {
+    delete block.index;
+    // partialJson is only a streaming scratch buffer; never persist it.
+    delete block.partialJson;
+    flushRedactedContent(block);
+}
 function handleMetadata(event, model, output) {
     if (event.usage) {
         output.usage.input = event.usage.inputTokens || 0;
@@ -462,6 +545,7 @@ function handleContentBlockStop(event, blocks, output, stream) {
             stream.push({ type: "text_end", contentIndex: index, content: block.text, partial: output });
             break;
         case "thinking":
+            flushRedactedContent(block);
             stream.push({ type: "thinking_end", contentIndex: index, content: block.thinking, partial: output });
             break;
         case "toolCall":
@@ -704,6 +788,15 @@ function convertMessages(context, model, cacheRetention, env) {
                             });
                             break;
                         case "thinking": {
+                            // Encrypted reasoning is opaque: replay the stored payload as the
+                            // `redactedContent` member instead of lowering it to reasoning text.
+                            if (c.redacted) {
+                                const redactedContent = decodeRedactedContent(c.thinkingSignature);
+                                if (redactedContent?.length) {
+                                    contentBlocks.push({ reasoningContent: { redactedContent } });
+                                }
+                                continue;
+                            }
                             // Skip empty thinking blocks
                             const thinking = sanitizeSurrogates(c.thinking);
                             if (thinking.trim().length === 0)
@@ -814,7 +907,7 @@ function convertToolConfig(tools, toolChoice, supportsStrictMode) {
             toolSpec: {
                 name: tool.name,
                 description: tool.description,
-                inputSchema: { json: tool.parameters },
+                inputSchema: { json: getJsonSchemaToolParameters(tool, strict) },
                 ...(strict === true ? { strict: true } : {}),
             },
         };
@@ -956,11 +1049,43 @@ function createImageBlock(mimeType, data) {
         default:
             throw new Error(`Unknown image type: ${mimeType}`);
     }
+    return { source: { bytes: base64ToBytes(data) }, format };
+}
+function base64ToBytes(data) {
     const binaryString = atob(data);
     const bytes = new Uint8Array(binaryString.length);
     for (let i = 0; i < binaryString.length; i++) {
         bytes[i] = binaryString.charCodeAt(i);
     }
-    return { source: { bytes }, format };
+    return bytes;
+}
+/**
+ * Decodes a stored redacted payload. The AWS SDK hands the blob over as bytes, but a
+ * persisted session carries it as base64. A hand-edited or externally produced session
+ * can hold a signature that is not base64; drop that block instead of failing the
+ * whole request.
+ */
+function decodeRedactedContent(signature) {
+    if (!signature)
+        return undefined;
+    try {
+        return base64ToBytes(signature);
+    }
+    catch {
+        return undefined;
+    }
+}
+function bytesToBase64(chunks) {
+    // Encrypted reasoning runs to tens of KB, so build the binary string in slices
+    // rather than one concatenation per byte. The window stays under the engine's
+    // argument-count limit for spread calls.
+    const WINDOW = 0x8000;
+    let binary = "";
+    for (const chunk of chunks) {
+        for (let i = 0; i < chunk.length; i += WINDOW) {
+            binary += String.fromCharCode(...chunk.subarray(i, i + WINDOW));
+        }
+    }
+    return btoa(binary);
 }
 //# sourceMappingURL=bedrock-converse-stream.js.map

package/node_modules/@earendil-works/pi-ai/dist/api/cloudflare-gateway-binding.js

@@ -0,0 +1,159 @@
+/**
+ * AI Gateway transport over the Workers AI binding.
+ *
+ * pi's Cloudflare AI Gateway support speaks HTTPS
+ * (`gateway.ai.cloudflare.com/v1/{account}/{gateway}/{provider}/...`, see `api/cloudflare.ts`),
+ * which needs a Cloudflare API token even when the caller is a Worker in the gateway's own
+ * account.
+ *
+ * In order to solve for this problem, `createGatewayBindingFetch` returns a {@link FetchFunction}
+ * that translates requests under a gateway HTTPS prefix into calls to the Workers AI binding's
+ * universal endpoint, `env.AI.gateway(id).run({provider, endpoint, headers, query})`.
+ * Binding calls are pre-authenticated in-account and return the provider's native wire format as a
+ * regular (streaming) `Response`, so API implementations behave identically over either
+ * transport.
+ *
+ * The result is the transport for one gateway-bound client, not a general-purpose fetch:
+ * requests it cannot serve — URLs outside the prefix, or in-prefix requests the universal
+ * endpoint cannot express (non-POST, non-JSON body) — reject with a descriptive error.
+ * Transport selection is the caller's job, per client: route such traffic over HTTPS with
+ * real gateway auth instead of through this shim.
+ */
+/**
+ * Placeholder value for auth headers on binding-routed requests. API implementations
+ * require an API key or a recognized auth header (`authorization`, `x-api-key`,
+ * `cf-aig-authorization`) before dispatch; binding calls are pre-authenticated, so pass
+ * `cf-aig-authorization: Bearer ${CLOUDFLARE_GATEWAY_BINDING_AUTH_SENTINEL}` to satisfy
+ * the check. The shim strips `cf-aig-authorization` before calling the binding. Pair it with
+ * `Authorization: null` / `x-api-key: null` so the SDKs' placeholder auth headers never reach
+ * the gateway, which would treat a request-supplied auth header as a BYOK provider key that
+ * overrides its stored keys — the same as it would over HTTPS.
+ */
+export const CLOUDFLARE_GATEWAY_BINDING_AUTH_SENTINEL = "cloudflare-gateway-binding";
+// Never forwarded to the binding: hop-by-hop/derived headers, and gateway auth
+// (binding calls are pre-authenticated; the sentinel must not reach the wire).
+const STRIP_HEADERS = new Set(["content-length", "host", "cf-aig-authorization"]);
+/**
+ * Create a `fetch` that routes AI Gateway requests through the Workers AI binding.
+ * See the module docs for behavior and composition notes.
+ */
+export function createGatewayBindingFetch(options) {
+    const { binding, gateway } = options;
+    // Prefix matching runs on URL-normalized components (origin + pathname), not raw strings:
+    // dot segments resolve away and fragments drop, matching what real fetch would put on the
+    // wire, so a lexical variant can't split provider/endpoint differently than HTTPS would.
+    const base = new URL(options.baseUrl);
+    const basePath = base.pathname.endsWith("/") ? base.pathname : `${base.pathname}/`;
+    return async (input, init) => {
+        const request = input instanceof Request ? input : undefined;
+        const url = request ? request.url : input.toString();
+        const method = (init?.method ?? request?.method ?? "GET").toUpperCase();
+        let parsed;
+        try {
+            parsed = new URL(url);
+        }
+        catch {
+            parsed = undefined;
+        }
+        // Out-of-prefix URLs are a configuration bug, not passthrough traffic: silently
+        // forwarding would ship the auth sentinel to whatever host the URL names.
+        if (parsed === undefined || parsed.origin !== base.origin || !parsed.pathname.startsWith(basePath)) {
+            throw new Error(`createGatewayBindingFetch: ${method} ${url} is outside the configured gateway ` +
+                `prefix (${base.origin}${basePath}); this fetch only serves its gateway-bound client`);
+        }
+        // In-prefix requests the universal endpoint cannot express always reject: forwarding
+        // them over HTTPS would send the sentinel to the gateway and fail with a misleading
+        // auth error instead of naming the real problem. Callers that need such endpoints
+        // route them over HTTPS with real gateway auth themselves.
+        const unexpressible = (reason) => {
+            throw new Error(`createGatewayBindingFetch: cannot express ${method} ${url} as a universal ` +
+                `gateway request (${reason}); route it over HTTPS with gateway auth instead`);
+        };
+        if (method !== "POST")
+            return unexpressible("only POST is supported");
+        const rest = parsed.pathname.slice(basePath.length);
+        const slash = rest.indexOf("/");
+        if (slash <= 0) {
+            return unexpressible("missing provider/endpoint path");
+        }
+        const provider = rest.slice(0, slash);
+        // Keep the query string on the endpoint — it's part of what HTTPS would have sent.
+        const endpoint = rest.slice(slash + 1) + parsed.search;
+        const bodyText = await readBodyText(request, init);
+        let query;
+        try {
+            query = bodyText === undefined ? undefined : JSON.parse(bodyText);
+        }
+        catch {
+            return unexpressible("non-JSON body");
+        }
+        if (query === undefined) {
+            return unexpressible("missing body");
+        }
+        const headers = collectHeaders(request, init);
+        // Per the fetch spec an explicit `signal: null` in init clears a Request input's signal.
+        const signal = init?.signal ?? (init && "signal" in init && init.signal === null ? undefined : request?.signal);
+        return binding.gateway(gateway).run({ provider, endpoint, headers, query }, signal ? { signal } : {});
+    };
+}
+async function readBodyText(request, init) {
+    const body = init?.body;
+    if (body === undefined || body === null) {
+        // Per the fetch spec an explicit `body: null` in init clears a Request input's body.
+        if (init && "body" in init && body === null)
+            return undefined;
+        if (request && request.body !== null)
+            return request.clone().text();
+        return undefined;
+    }
+    if (typeof body === "string")
+        return body;
+    if (body instanceof Uint8Array)
+        return new TextDecoder().decode(body);
+    if (body instanceof ArrayBuffer)
+        return new TextDecoder().decode(new Uint8Array(body));
+    // URLSearchParams, FormData, Blob, ReadableStream in init: read via a Request wrapper.
+    // Consuming a one-shot stream here is fine — unexpressible requests reject rather than
+    // replay, so nothing downstream needs the body again.
+    return new Request("http://body.local", {
+        method: "POST",
+        body,
+        // The fetch spec requires `duplex: "half"` to construct a Request with a stream body
+        // (Node's undici enforces it; it is ignored for the replayable body types). TypeScript's
+        // RequestInit does not declare the field yet, hence the cast.
+        duplex: "half",
+    }).text();
+}
+// Entry header names are lowercased so case-variant duplicates collapse and stripping is
+// uniform. Per the fetch spec, `init.headers` replaces a Request input's headers entirely.
+function collectHeaders(request, init) {
+    const result = {};
+    const add = (key, value) => {
+        const name = key.toLowerCase();
+        if (!STRIP_HEADERS.has(name))
+            result[name] = value;
+    };
+    const headers = init?.headers;
+    if (headers === undefined) {
+        if (request) {
+            for (const [key, value] of request.headers)
+                add(key, value);
+        }
+    }
+    else if (headers instanceof Headers) {
+        for (const [key, value] of headers)
+            add(key, value);
+    }
+    else if (Array.isArray(headers)) {
+        for (const [key, value] of headers)
+            add(key, value);
+    }
+    else {
+        for (const [key, value] of Object.entries(headers)) {
+            if (value !== undefined)
+                add(key, String(value));
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=cloudflare-gateway-binding.js.map

package/node_modules/@earendil-works/pi-ai/dist/api/constrained-sampling.js

@@ -1,3 +1,116 @@
+class UnsupportedStrictJsonSchemaError extends Error {
+}
+const UNSUPPORTED_STRICT_SCHEMA_KEYS = [
+    "$ref",
+    "$defs",
+    "definitions",
+    "allOf",
+    "oneOf",
+    "patternProperties",
+    "dependentSchemas",
+    "dependencies",
+    "unevaluatedProperties",
+    "propertyNames",
+    "contains",
+    "prefixItems",
+    "not",
+    "if",
+    "then",
+    "else",
+];
+function isJsonSchemaObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStructuredSchema(schema) {
+    if (!isJsonSchemaObject(schema))
+        return false;
+    const types = typeof schema.type === "string" ? [schema.type] : Array.isArray(schema.type) ? schema.type : [];
+    return (types.includes("object") ||
+        types.includes("array") ||
+        schema.properties !== undefined ||
+        schema.items !== undefined);
+}
+function schemaAllowsNull(schema) {
+    if (!isJsonSchemaObject(schema))
+        return false;
+    if (schema.type === "null" || (Array.isArray(schema.type) && schema.type.includes("null")))
+        return true;
+    if (schema.const === null || (Array.isArray(schema.enum) && schema.enum.includes(null)))
+        return true;
+    return Array.isArray(schema.anyOf) && schema.anyOf.some((variant) => schemaAllowsNull(variant));
+}
+function makeJsonSchemaNodeStrict(schema) {
+    if (!isJsonSchemaObject(schema)) {
+        throw new UnsupportedStrictJsonSchemaError("boolean schemas are unsupported");
+    }
+    for (const key of UNSUPPORTED_STRICT_SCHEMA_KEYS) {
+        if (schema[key] !== undefined) {
+            throw new UnsupportedStrictJsonSchemaError(`${key} schemas are unsupported`);
+        }
+    }
+    if (schema.anyOf !== undefined) {
+        if (!Array.isArray(schema.anyOf) || schema.anyOf.length === 0) {
+            throw new UnsupportedStrictJsonSchemaError("anyOf must contain at least one schema");
+        }
+        for (const variant of schema.anyOf) {
+            if (isStructuredSchema(variant)) {
+                throw new UnsupportedStrictJsonSchemaError("object and array unions are unsupported");
+            }
+            makeJsonSchemaNodeStrict(variant);
+        }
+    }
+    if (schema.items !== undefined) {
+        if (Array.isArray(schema.items)) {
+            throw new UnsupportedStrictJsonSchemaError("tuple schemas are unsupported");
+        }
+        makeJsonSchemaNodeStrict(schema.items);
+    }
+    const isObjectSchema = schema.type === "object";
+    if (schema.properties !== undefined && !isObjectSchema) {
+        throw new UnsupportedStrictJsonSchemaError("properties require type object");
+    }
+    if (!isObjectSchema)
+        return;
+    if (schema.additionalProperties !== undefined && schema.additionalProperties !== false) {
+        throw new UnsupportedStrictJsonSchemaError("schema-valued or true additionalProperties is unsupported");
+    }
+    if (schema.properties !== undefined && !isJsonSchemaObject(schema.properties)) {
+        throw new UnsupportedStrictJsonSchemaError("object properties must be a schema map");
+    }
+    if (schema.required !== undefined &&
+        (!Array.isArray(schema.required) || schema.required.some((key) => typeof key !== "string"))) {
+        throw new UnsupportedStrictJsonSchemaError("object required must be a string array");
+    }
+    const properties = schema.properties ?? {};
+    const propertyNames = Object.keys(properties);
+    const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+    if ([...required].some((key) => !propertyNames.includes(key))) {
+        throw new UnsupportedStrictJsonSchemaError("required contains an unknown property");
+    }
+    for (const [key, property] of Object.entries(properties)) {
+        makeJsonSchemaNodeStrict(property);
+        if (!required.has(key) && !schemaAllowsNull(property)) {
+            properties[key] = { anyOf: [property, { type: "null" }] };
+        }
+    }
+    schema.required = propertyNames;
+    schema.additionalProperties = false;
+}
+/** Convert a tool schema to the strict subset expected by provider constrained sampling. */
+export function makeStrictJsonSchema(schema) {
+    const cloned = structuredClone(schema);
+    if (!isJsonSchemaObject(cloned)) {
+        throw new UnsupportedStrictJsonSchemaError("root schema must have type object");
+    }
+    makeJsonSchemaNodeStrict(cloned);
+    if (cloned.type !== "object") {
+        throw new UnsupportedStrictJsonSchemaError("root schema must have type object");
+    }
+    return cloned;
+}
+export function getJsonSchemaToolParameters(tool, strict) {
+    return (strict === true ? makeStrictJsonSchema(tool.parameters) : tool.parameters);
+}
 export function getGrammarToolInput(toolName, arguments_, inputProperty) {
     const input = arguments_[inputProperty];
     if (typeof input !== "string") {
@@ -49,11 +162,20 @@ function inferGrammarInputProperty(tool) {
 }
 export function resolveJsonSchemaStrictSampling(tool, supportsStrictMode) {
     const config = tool.constrainedSampling;
-    if (!config || config.type !== "json_schema") {
+    if (!config || config.type !== "json_schema")
         return undefined;
-    }
     if (supportsStrictMode) {
-        return true;
+        try {
+            makeStrictJsonSchema(tool.parameters);
+            return true;
+        }
+        catch (error) {
+            if (!(error instanceof UnsupportedStrictJsonSchemaError))
+                throw error;
+            if (config.strict !== "require")
+                return undefined;
+            throw new Error(`Tool "${tool.name}" requires JSON-schema constrained sampling, but ${error.message}.`);
+        }
     }
     if (config.strict === "require") {
         throw new Error(`Tool "${tool.name}" requires JSON-schema constrained sampling, but strict tools are unsupported.`);