@opencode/ai 2.0.2 → 2.0.4

package/dist/cache-policy.js

@@ -12,6 +12,7 @@
 // count against the four-breakpoint budget; auto only fills remaining slots.
 import { CacheHint } from "./schema/options.js";
 import { LLMRequest, Message, ToolDefinition } from "./schema/messages.js";
+import { effortUpdate } from "./effort-updates.js";
 const AUTO = {
     tools: true,
     system: true,
@@ -100,10 +101,17 @@ const markMessages = (messages, strategy, hint, budget) => {
         return markMessageAt(messages, lastIndexOfRole(messages, "user"), hint, budget);
     if (strategy === "latest-assistant")
         return markMessageAt(messages, lastIndexOfRole(messages, "assistant"), hint, budget);
-    const start = Math.max(0, messages.length - strategy.tail);
+    let start = messages.length;
+    let remaining = strategy.tail;
+    while (remaining > 0 && start > 0) {
+        start -= 1;
+        if (effortUpdate(messages[start]) === undefined)
+            remaining -= 1;
+    }
     let next = messages;
     for (let i = start; i < messages.length; i++)
-        next = markMessageAt(next, i, hint, budget);
+        if (effortUpdate(messages[i]) === undefined)
+            next = markMessageAt(next, i, hint, budget);
     return next;
 };
 const countHints = (request) => countToolHints(request.tools) +

package/dist/effort-updates.d.ts

@@ -0,0 +1,12 @@
+import { LLMRequest, type EffortPart, type Message } from "./schema/messages.js";
+export declare const effortUpdate: (message: Message) => EffortPart | undefined;
+export declare const stripEffortUpdates: (request: LLMRequest) => LLMRequest<import("./index.js").LanguageModel<{
+    readonly [x: string]: unknown;
+}, import("./route.js").CompactionOperations | undefined>>;
+export declare const applyEffortUpdates: (request: LLMRequest) => LLMRequest;
+export declare const resolveEffortUpdates: (request: LLMRequest, current: string | undefined) => {
+    request: LLMRequest<import("./index.js").LanguageModel<{
+        readonly [x: string]: unknown;
+    }, import("./route.js").CompactionOperations | undefined>>;
+    effort: string | undefined;
+};

package/dist/effort-updates.js

@@ -0,0 +1,23 @@
+// Changing the top-level reasoning effort invalidates the provider prompt cache. Protocols with a native
+// per-message update keep it frozen and lower `Message.effort(...)` markers instead; other routes strip them.
+import { LLMRequest } from "./schema/messages.js";
+export const effortUpdate = (message) => {
+    if (message.role !== "system" || message.content.length !== 1)
+        return undefined;
+    const part = message.content[0];
+    return part.type === "effort" ? part : undefined;
+};
+export const stripEffortUpdates = (request) => {
+    const messages = request.messages.filter((message) => effortUpdate(message) === undefined);
+    return messages.length === request.messages.length ? request : LLMRequest.update(request, { messages });
+};
+export const applyEffortUpdates = (request) => request.model.route.supportsEffortUpdates?.(request) ? request : stripEffortUpdates(request);
+// Reverted or forked history can leave the last marker disagreeing with the requested effort.
+export const resolveEffortUpdates = (request, current) => {
+    const updates = request.messages.flatMap((message) => effortUpdate(message) ?? []);
+    if (updates.length === 0)
+        return { request, effort: current };
+    if (updates.at(-1)?.effort !== current)
+        return { request: stripEffortUpdates(request), effort: current };
+    return { request, effort: updates[0]?.previous };
+};

package/dist/protocols/alibaba-messages.d.ts

@@ -187,7 +187,6 @@ export declare const protocol: Protocol<{
             readonly content: string | null;
         })[];
     } | {
-        readonly role: "system";
         readonly content: readonly {
             readonly type: "text";
             readonly text: string;
@@ -196,6 +195,10 @@ export declare const protocol: Protocol<{
                 readonly ttl?: "1h" | "5m" | undefined;
             } | undefined;
         }[];
+        readonly role: "system";
+        readonly output_config?: {
+            readonly effort: string;
+        } | undefined;
     })[];
     readonly stream: true;
     readonly metadata?: {

package/dist/protocols/alibaba-responses.d.ts

@@ -61,12 +61,15 @@ export declare const protocol: Protocol<{
         readonly encrypted_content: string;
         readonly id?: string | null | undefined;
     } | {
+        readonly type: "message";
         readonly role: "system";
         readonly content: string;
     } | {
+        readonly type: "message";
         readonly role: "developer";
         readonly content: string;
     } | {
+        readonly type: "message";
         readonly content: readonly ({
             readonly type: "input_image";
             readonly image_url: string;
@@ -83,7 +86,6 @@ export declare const protocol: Protocol<{
         })[];
         readonly role: "user";
         readonly id?: string | undefined;
-        readonly type?: "message" | undefined;
         readonly status?: string | undefined;
     } | {
         readonly type: "message";

package/dist/protocols/anthropic-messages.d.ts

@@ -286,6 +286,9 @@ export declare const AnthropicMessagesBody: Schema.Struct<{
                 readonly ttl: Schema.optional<Schema.Literals<readonly ["5m", "1h"]>>;
             }>>;
         }>>;
+        readonly output_config: Schema.optional<Schema.Struct<{
+            readonly effort: Schema.String;
+        }>>;
     }>]>>;
     tools: Schema.optional<Schema.$Array<Schema.Struct<{
         readonly name: Schema.String;
@@ -529,7 +532,6 @@ export declare const protocol: Protocol<{
             readonly content: string | null;
         })[];
     } | {
-        readonly role: "system";
         readonly content: readonly {
             readonly type: "text";
             readonly text: string;
@@ -538,6 +540,10 @@ export declare const protocol: Protocol<{
                 readonly ttl?: "1h" | "5m" | undefined;
             } | undefined;
         }[];
+        readonly role: "system";
+        readonly output_config?: {
+            readonly effort: string;
+        } | undefined;
     })[];
     readonly stream: true;
     readonly metadata?: {
@@ -883,7 +889,6 @@ export declare const route: Route<{
             readonly content: string | null;
         })[];
     } | {
-        readonly role: "system";
         readonly content: readonly {
             readonly type: "text";
             readonly text: string;
@@ -892,6 +897,10 @@ export declare const route: Route<{
                 readonly ttl?: "1h" | "5m" | undefined;
             } | undefined;
         }[];
+        readonly role: "system";
+        readonly output_config?: {
+            readonly effort: string;
+        } | undefined;
     })[];
     readonly stream: true;
     readonly metadata?: {

package/dist/protocols/anthropic-messages.js

@@ -11,6 +11,7 @@ import { HttpTransport } from "../route/transport/index.js";
 import { AIError, HttpOptions, LLMRequest, LLMEvent, mergeJsonRecords, Usage, } from "../schema/index.js";
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { classifyProviderFailure } from "../provider-error.js";
+import { effortUpdate, resolveEffortUpdates } from "../effort-updates.js";
 import * as Cache from "./utils/cache.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 import { ToolSchemaProjection } from "./utils/tool-schema.js";
@@ -19,6 +20,7 @@ const ADAPTER = "anthropic-messages";
 export const DEFAULT_BASE_URL = "https://api.anthropic.com/v1";
 export const PATH = "/messages";
 export const DEFAULT_MAX_TOKENS = 32_000;
+const DEFAULT_EFFORT = "high";
 const SSE_EVENTS = new Set([
     "message",
     "message_start",
@@ -183,7 +185,11 @@ const AnthropicAssistantBlock = Schema.Union([
 const AnthropicMessage = Schema.Union([
     Schema.Struct({ role: Schema.Literal("user"), content: Schema.Array(AnthropicUserBlock) }),
     Schema.Struct({ role: Schema.Literal("assistant"), content: Schema.Array(AnthropicAssistantBlock) }),
-    Schema.Struct({ role: Schema.Literal("system"), content: Schema.Array(AnthropicTextBlock) }),
+    Schema.Struct({
+        role: Schema.Literal("system"),
+        content: Schema.Array(AnthropicTextBlock),
+        output_config: Schema.optional(Schema.Struct({ effort: Schema.String })),
+    }),
 ]).pipe(Schema.toTaggedUnion("role"));
 const AnthropicTool = Schema.Struct({
     name: Schema.String,
@@ -697,6 +703,12 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (re
     const providerMetadataKey = request.model.route.providerMetadataKey ?? String(request.model.provider);
     for (const [index, message] of request.messages.entries()) {
         if (message.role === "system") {
+            const update = effortUpdate(message);
+            if (update) {
+                // Accepted at any position, so the text-update placement rules do not apply.
+                messages.push({ role: "system", content: [], output_config: { effort: update.effort ?? DEFAULT_EFFORT } });
+                continue;
+            }
             if (splitsLocalToolResults(request.messages, index))
                 return yield* invalid("Anthropic Messages system updates cannot split a local tool call from its tool result");
             if (supportsNativeSystemUpdates(request) && canUseNativeSystemUpdate(request, index)) {
@@ -842,17 +854,11 @@ const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (
     const outputConfigFormat = ProviderShared.isRecord(rawOutputConfig) && ProviderShared.isRecord(rawOutputConfig.format)
         ? rawOutputConfig.format
         : undefined;
-    const output_config = outputConfigEffort === undefined && outputConfigFormat === undefined
-        ? undefined
-        : {
-            ...(outputConfigEffort === undefined ? {} : { effort: outputConfigEffort }),
-            ...(outputConfigFormat === undefined ? {} : { format: outputConfigFormat }),
-        };
     const thinking = yield* resolveThinking(input?.thinking);
     return {
         thinking: applyThinkingBindingDefault(request.model, thinking),
         effort: outputConfigEffort,
-        output_config,
+        format: outputConfigFormat,
         service_tier,
         metadata,
         container,
@@ -860,17 +866,32 @@ const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (
         cache_control,
     };
 });
+// Accept gateway namespaces and Vertex suffixes without treating a snapshot date as a minor version.
+const claudeVersion = (id) => {
+    const match = /(?:^|[./])claude-(?<family>[a-z]+)-(?<major>\d+)(?:[.-](?<minor>\d{1,2}))?(?:$|[-:@])/.exec(id.toLowerCase())?.groups;
+    if (!match)
+        return undefined;
+    return { family: match.family, major: Number(match.major), minor: Number(match.minor ?? 0) };
+};
 const supportsThinkingBlockBinding = (model) => {
     const override = model.compatibility?.supportsThinkingBlockBinding;
     if (override !== undefined)
         return override;
-    // Accept gateway namespaces and Vertex suffixes without treating a snapshot date as a minor version.
-    const version = /(?:^|[./])claude-[a-z]+-(?<major>\d+)(?:[.-](?<minor>\d{1,2}))?(?:$|[-:@])/i.exec(model.id)?.groups;
-    if (!version)
+    const version = claudeVersion(model.id);
+    return version !== undefined && (version.major > 5 || (version.major === 5 && version.minor >= 1));
+};
+const supportsEffortUpdates = (model) => {
+    const override = model.compatibility?.supportsEffortUpdates;
+    if (override !== undefined)
+        return override;
+    const version = claudeVersion(model.id);
+    if (version === undefined)
         return false;
-    const major = Number(version.major);
-    const minor = Number(version.minor ?? 0);
-    return major > 5 || (major === 5 && minor >= 1);
+    if (version.family === "opus")
+        return version.major >= 5;
+    if (version.family !== "fable" && version.family !== "mythos")
+        return false;
+    return version.major > 5 || (version.major === 5 && version.minor >= 1);
 };
 const applyThinkingBindingDefault = (model, thinking) => {
     if (thinking?.type === "disabled")
@@ -909,13 +930,15 @@ const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function*
 });
 const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (request) {
     const management = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Schema.UndefinedOr(ContextManagement)))(request.providerOptions?.contextManagement);
+    const options = yield* resolveOptions(request);
+    const updates = resolveEffortUpdates(request, options.effort);
     const generation = request.generation;
     const toolSchemaCompatibility = request.model.compatibility?.toolSchema;
     // Allocate the 4-breakpoint budget in invalidation order: tools → system →
     // messages. Tools live highest in the cache hierarchy, so when callers
     // over-mark we keep their tool hints and shed the message-tail ones first.
     const breakpoints = Cache.newBreakpoints(ANTHROPIC_BREAKPOINT_CAP);
-    const flattened = ProviderShared.flattenToolRequest(request);
+    const flattened = ProviderShared.flattenToolRequest(updates.request);
     const tools = flattened.tools.length === 0
         ? undefined
         : flattened.tools.map((tool) => lowerTool(breakpoints, tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)));
@@ -933,7 +956,12 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
     if (breakpoints.dropped > 0) {
         yield* Effect.logWarning(`Anthropic Messages: dropped ${breakpoints.dropped} cache breakpoint(s); the API allows at most ${ANTHROPIC_BREAKPOINT_CAP} per request.`);
     }
-    const options = yield* resolveOptions(request);
+    const output_config = updates.effort === undefined && options.format === undefined
+        ? undefined
+        : {
+            ...(updates.effort === undefined ? {} : { effort: updates.effort }),
+            ...(options.format === undefined ? {} : { format: options.format }),
+        };
     const body = {
         model: request.model.id,
         system,
@@ -947,7 +975,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
         top_k: generation?.topK,
         stop_sequences: generation?.stop,
         thinking: options.thinking,
-        output_config: options.output_config,
+        output_config,
         // top-level passthrough per SDK MessageCreateParamsBase:4638,4643,4649,4654,4670
         cache_control: options.cache_control,
         container: options.container,
@@ -1404,6 +1432,7 @@ export const protocol = Protocol.make({
         }),
         step,
     },
+    supportsEffortUpdates: (request) => supportsEffortUpdates(request.model),
 });
 export const transport = () => {
     const http = HttpTransport.httpJson({ framing });
@@ -1440,6 +1469,8 @@ function requiredBetaHeaders(body) {
     const replaysCompaction = body.messages.some((message) => message.content.some((block) => block.type === "compaction"));
     if (requestsCompaction || replaysCompaction)
         betas.push("compact-2026-01-12");
+    if (body.messages.some((message) => message.role === "system" && message.output_config !== undefined))
+        betas.push("mid-conversation-output-config-2026-07-01");
     const thinking = body.thinking;
     if (thinking && thinking.type !== "disabled" && thinking.block_binding)
         betas.push("thinking-binding-controls-2026-08-01");

package/dist/protocols/bedrock-converse.js

@@ -10,6 +10,7 @@ import { BedrockAuth } from "./utils/bedrock-auth.js";
 import { BedrockCache } from "./utils/bedrock-cache.js";
 import { BedrockMedia } from "./utils/bedrock-media.js";
 import { Lifecycle } from "./utils/lifecycle.js";
+import { MistralToolID } from "./utils/mistral-tool-id.js";
 import { ToolSchemaProjection } from "./utils/tool-schema.js";
 import { ToolStream } from "./utils/tool-stream.js";
 const ADAPTER = "bedrock-converse";
@@ -201,14 +202,15 @@ const removeEmptyToolInputKeys = (input) => {
         return input;
     return Object.fromEntries(Object.entries(input).flatMap(([key, value]) => (key === "" ? [] : [[key, removeEmptyToolInputKeys(value)]])));
 };
-const lowerToolCall = (part) => ({
+const lowerToolCall = (part, normalizeID) => ({
     toolUse: {
-        toolUseId: part.id,
-        name: part.name,
+        toolUseId: normalizeID(part.id),
+        // Models can emit names that Converse rejects when replayed in history.
+        name: part.name.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64) || "_",
         input: removeEmptyToolInputKeys(part.input),
     },
 });
-const lowerToolResultContent = Effect.fn("BedrockConverse.lowerToolResultContent")(function* (part) {
+const lowerToolResultContent = Effect.fn("BedrockConverse.lowerToolResultContent")(function* (part, documentNames) {
     if (part.result.type === "text" || part.result.type === "error")
         return [{ text: ProviderShared.toolResultText(part) }];
     if (part.result.type === "json")
@@ -224,22 +226,25 @@ const lowerToolResultContent = Effect.fn("BedrockConverse.lowerToolResultContent
             mediaType: item.mime,
             data: item.uri,
             filename: item.name,
-        });
-        content.push(media);
+        }, documentNames);
+        content.push(...media);
     }
     return content;
 });
-const lowerToolResult = Effect.fn("BedrockConverse.lowerToolResult")(function* (part) {
+const lowerToolResult = Effect.fn("BedrockConverse.lowerToolResult")(function* (part, documentNames, normalizeID) {
     return {
         toolResult: {
-            toolUseId: part.id,
-            content: yield* lowerToolResultContent(part),
+            toolUseId: normalizeID(part.id),
+            content: yield* lowerToolResultContent(part, documentNames),
             status: part.result.type === "error" ? "error" : "success",
         },
     };
 });
 const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (request, breakpoints) {
     const messages = [];
+    const documentNames = new Set();
+    // Mistral can reject replay IDs even when they satisfy Converse's broader ID syntax.
+    const normalizeID = request.model.id.includes("mistral.") ? MistralToolID.normalizer(request) : (id) => id;
     const providerMetadataKey = request.model.route.providerMetadataKey ?? String(request.model.provider);
     for (const message of request.messages) {
         if (message.role === "system") {
@@ -262,7 +267,7 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (requ
                     continue;
                 }
                 if (part.type === "media") {
-                    content.push(yield* BedrockMedia.lower(part));
+                    content.push(...(yield* BedrockMedia.lower(part, documentNames)));
                     continue;
                 }
             }
@@ -304,7 +309,7 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (requ
                     continue;
                 }
                 if (part.type === "tool-call") {
-                    content.push(lowerToolCall(part));
+                    content.push(lowerToolCall(part, normalizeID));
                     continue;
                 }
             }
@@ -316,7 +321,7 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (requ
         for (const part of message.content) {
             if (!ProviderShared.supportsContent(part, ["tool-result"]))
                 return yield* ProviderShared.unsupportedContent("Bedrock Converse", "tool", ["tool-result"]);
-            content.push(yield* lowerToolResult(part));
+            content.push(yield* lowerToolResult(part, documentNames, normalizeID));
             const cachePoint = BedrockCache.block(breakpoints, part.cache);
             if (cachePoint)
                 content.push(cachePoint);

package/dist/protocols/meta-messages.d.ts

@@ -175,7 +175,6 @@ export declare const protocol: Protocol<{
             readonly content: string | null;
         })[];
     } | {
-        readonly role: "system";
         readonly content: readonly {
             readonly type: "text";
             readonly text: string;
@@ -184,6 +183,10 @@ export declare const protocol: Protocol<{
                 readonly ttl?: "1h" | "5m" | undefined;
             } | undefined;
         }[];
+        readonly role: "system";
+        readonly output_config?: {
+            readonly effort: string;
+        } | undefined;
     })[];
     readonly stream: true;
     readonly metadata?: {

package/dist/protocols/meta-responses.d.ts

@@ -76,12 +76,15 @@ export declare const protocol: Protocol<{
         readonly encrypted_content: string;
         readonly id?: string | null | undefined;
     } | {
+        readonly type: "message";
         readonly role: "system";
         readonly content: string;
     } | {
+        readonly type: "message";
         readonly role: "developer";
         readonly content: string;
     } | {
+        readonly type: "message";
         readonly content: readonly ({
             readonly type: "input_image";
             readonly image_url: string;
@@ -98,7 +101,6 @@ export declare const protocol: Protocol<{
         })[];
         readonly role: "user";
         readonly id?: string | undefined;
-        readonly type?: "message" | undefined;
         readonly status?: string | undefined;
     } | {
         readonly type: "message";
@@ -153,7 +155,7 @@ export declare const protocol: Protocol<{
     readonly instructions?: string | undefined;
     readonly reasoning?: {
         readonly summary?: "auto" | "concise" | "detailed" | undefined;
-        readonly effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
+        readonly effort?: import("../schema/options.js").ReasoningEffort | undefined;
     } | undefined;
     readonly tools?: readonly ({
         readonly type: "function";
@@ -332,12 +334,15 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         readonly encrypted_content: string;
         readonly id?: string | null | undefined;
     } | {
+        readonly type: "message";
         readonly role: "system";
         readonly content: string;
     } | {
+        readonly type: "message";
         readonly role: "developer";
         readonly content: string;
     } | {
+        readonly type: "message";
         readonly content: readonly ({
             readonly type: "input_image";
             readonly image_url: string;
@@ -354,7 +359,6 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         })[];
         readonly role: "user";
         readonly id?: string | undefined;
-        readonly type?: "message" | undefined;
         readonly status?: string | undefined;
     } | {
         readonly type: "message";
@@ -409,7 +413,7 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
     readonly instructions?: string | undefined;
     readonly reasoning?: {
         readonly summary?: "auto" | "concise" | "detailed" | undefined;
-        readonly effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
+        readonly effort?: import("../schema/options.js").ReasoningEffort | undefined;
     } | undefined;
     readonly tools?: readonly ({
         readonly type: "function";

package/dist/protocols/mistral-chat.js

@@ -9,10 +9,10 @@ import { AIError, InvalidProviderOutputError, LLMEvent, ProviderInternalError, U
 import { classifyProviderFailure } from "../provider-error.js";
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { Lifecycle } from "./utils/lifecycle.js";
+import { MistralToolID } from "./utils/mistral-tool-id.js";
 import { ToolStream } from "./utils/tool-stream.js";
 const ADAPTER = "mistral-chat";
 const DONE = "[DONE]";
-const TOOL_ID = /^[A-Za-z0-9]{9}$/;
 export const DEFAULT_BASE_URL = "https://api.mistral.ai/v1";
 export const PATH = "/chat/completions";
 const MistralTextContent = Schema.Struct({
@@ -140,34 +140,6 @@ const MistralEvent = Schema.StructWithRest(Schema.Struct({
     error: optionalNull(MistralError),
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
 const MistralStreamEvent = Schema.Union([Schema.Literal(DONE), Protocol.jsonEvent(MistralEvent)]);
-const hashID = (value) => {
-    const hash = (seed) => {
-        let result = seed;
-        for (const char of value)
-            result = Math.imul(result ^ char.charCodeAt(0), 16777619);
-        return (result >>> 0).toString(36);
-    };
-    return `${hash(2166136261).padStart(7, "0")}${hash(2246822519).padStart(7, "0")}`.slice(-9);
-};
-const toolIDNormalizer = (request) => {
-    const ids = request.messages.flatMap((message) => message.content.flatMap((part) => (part.type === "tool-call" || part.type === "tool-result" ? [part.id] : [])));
-    const used = new Set(ids.filter((id) => TOOL_ID.test(id)));
-    const normalized = new Map();
-    return (id) => {
-        if (TOOL_ID.test(id))
-            return id;
-        const previous = normalized.get(id);
-        if (previous)
-            return previous;
-        let attempt = 0;
-        let candidate = hashID(id);
-        while (used.has(candidate))
-            candidate = hashID(`${id}:${++attempt}`);
-        used.add(candidate);
-        normalized.set(id, candidate);
-        return candidate;
-    };
-};
 const lowerMedia = Effect.fn("MistralChat.lowerMedia")(function* (part) {
     const media = ProviderShared.normalizeMedia(part);
     const url = typeof part.data === "string" && /^(?:https?:|data:)/.test(part.data) ? part.data : media.dataUrl;
@@ -269,7 +241,7 @@ const lowerToolResults = Effect.fn("MistralChat.lowerToolResults")(function* (me
     return output;
 });
 const lowerMessages = Effect.fn("MistralChat.lowerMessages")(function* (request) {
-    const normalizeID = toolIDNormalizer(request);
+    const normalizeID = MistralToolID.normalizer(request);
     const messages = request.system.length === 0 ? [] : [{ role: "system", content: ProviderShared.joinText(request.system) }];
     for (const message of request.messages) {
         if (message.role === "system") {
@@ -439,15 +411,15 @@ const appendContent = (state, events, content) => {
     }, state);
 };
 const normalizeStreamToolID = (state, source) => {
-    if (TOOL_ID.test(source))
+    if (MistralToolID.valid.test(source))
         return { id: source, state: { ...state, usedToolIDs: new Set([...state.usedToolIDs, source]) } };
     const previous = state.toolIDs.get(source);
     if (previous)
         return { id: previous, state };
     let attempt = 0;
-    let id = hashID(source);
+    let id = MistralToolID.hash(source);
     while (state.usedToolIDs.has(id))
-        id = hashID(`${source}:${++attempt}`);
+        id = MistralToolID.hash(`${source}:${++attempt}`);
     return {
         id,
         state: {

package/dist/protocols/open-responses-channel.js

@@ -101,6 +101,10 @@ export const transport = (options) => {
                     };
                 })
                 : undefined;
+            if (input.webSocket && !channel)
+                yield* Effect.logWarning(`${options.name} does not offer WebSocket for this endpoint; using HTTP`, {
+                    url: parts.url,
+                });
             return {
                 http: {
                     request: ProviderShared.jsonPost({ url: parts.url, body: parts.bodyText, headers: parts.headers }),