@opencode-ai/ai 0.0.0-beta-18050 → 0.0.0-beta-18138

package/dist/protocols/utils/partial-json.js

@@ -0,0 +1,224 @@
+/*
+ * Adapted from partial-json by the Promplate Dev Team:
+ * https://github.com/promplate/partial-json-parser-js
+ *
+ * MIT License
+ *
+ * Copyright (c) 2023 Promplate Dev Team
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { Schema } from "effect";
+import { Allow } from "./partial-json-options.js";
+export * from "./partial-json-options.js";
+export class PartialJSON extends Error {
+}
+export class MalformedJSON extends Error {
+}
+const decodeJson = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown));
+/** Parse complete or incomplete JSON, restricted by the supplied partial-value flags. */
+export function parseJSON(jsonString, allowPartial = Allow.ALL) {
+    if (typeof jsonString !== "string")
+        throw new TypeError(`expecting str, got ${typeof jsonString}`);
+    const input = jsonString.trim();
+    if (!input)
+        throw new Error(`${jsonString} is empty`);
+    try {
+        return decodeJson(input);
+    }
+    catch { }
+    return _parseJSON(input, allowPartial);
+}
+const _parseJSON = (jsonString, allow) => {
+    const length = jsonString.length;
+    let index = 0;
+    const markPartialJSON = (message) => {
+        throw new PartialJSON(`${message} at position ${index}`);
+    };
+    const throwMalformedError = (message) => {
+        throw new MalformedJSON(`${message} at position ${index}`);
+    };
+    const parseAny = () => {
+        skipBlank();
+        if (index >= length)
+            markPartialJSON("Unexpected end of input");
+        if (jsonString[index] === '"')
+            return parseStr();
+        if (jsonString[index] === "{")
+            return parseObj();
+        if (jsonString[index] === "[")
+            return parseArr();
+        if (jsonString.substring(index, index + 4) === "null" ||
+            (Allow.NULL & allow && length - index < 4 && "null".startsWith(jsonString.substring(index)))) {
+            index += 4;
+            return null;
+        }
+        if (jsonString.substring(index, index + 4) === "true" ||
+            (Allow.BOOL & allow && length - index < 4 && "true".startsWith(jsonString.substring(index)))) {
+            index += 4;
+            return true;
+        }
+        if (jsonString.substring(index, index + 5) === "false" ||
+            (Allow.BOOL & allow && length - index < 5 && "false".startsWith(jsonString.substring(index)))) {
+            index += 5;
+            return false;
+        }
+        if (jsonString.substring(index, index + 8) === "Infinity" ||
+            (Allow.INFINITY & allow && length - index < 8 && "Infinity".startsWith(jsonString.substring(index)))) {
+            index += 8;
+            return Infinity;
+        }
+        if (jsonString.substring(index, index + 9) === "-Infinity" ||
+            (Allow._INFINITY & allow &&
+                1 < length - index &&
+                length - index < 9 &&
+                "-Infinity".startsWith(jsonString.substring(index)))) {
+            index += 9;
+            return -Infinity;
+        }
+        if (jsonString.substring(index, index + 3) === "NaN" ||
+            (Allow.NAN & allow && length - index < 3 && "NaN".startsWith(jsonString.substring(index)))) {
+            index += 3;
+            return NaN;
+        }
+        return parseNum();
+    };
+    const parseStr = () => {
+        const start = index;
+        let escape = false;
+        index++;
+        while (index < length && (jsonString[index] !== '"' || (escape && jsonString[index - 1] === "\\"))) {
+            escape = jsonString[index] === "\\" ? !escape : false;
+            index++;
+        }
+        if (jsonString.charAt(index) === '"') {
+            try {
+                return decodeJson(jsonString.substring(start, ++index - Number(escape)));
+            }
+            catch (error) {
+                throwMalformedError(String(error));
+            }
+        }
+        if (Allow.STR & allow) {
+            try {
+                return decodeJson(`${jsonString.substring(start, index - Number(escape))}"`);
+            }
+            catch {
+                return decodeJson(`${jsonString.substring(start, jsonString.lastIndexOf("\\"))}"`);
+            }
+        }
+        return markPartialJSON("Unterminated string literal");
+    };
+    const parseObj = () => {
+        index++;
+        skipBlank();
+        const object = {};
+        try {
+            while (jsonString[index] !== "}") {
+                skipBlank();
+                if (index >= length && Allow.OBJ & allow)
+                    return object;
+                const key = parseStr();
+                skipBlank();
+                index++;
+                try {
+                    object[key] = parseAny();
+                }
+                catch (error) {
+                    if (Allow.OBJ & allow)
+                        return object;
+                    throw error;
+                }
+                skipBlank();
+                if (jsonString[index] === ",")
+                    index++;
+            }
+        }
+        catch {
+            if (Allow.OBJ & allow)
+                return object;
+            return markPartialJSON("Expected '}' at end of object");
+        }
+        index++;
+        return object;
+    };
+    const parseArr = () => {
+        index++;
+        const array = [];
+        try {
+            while (jsonString[index] !== "]") {
+                array.push(parseAny());
+                skipBlank();
+                if (jsonString[index] === ",")
+                    index++;
+            }
+        }
+        catch {
+            if (Allow.ARR & allow)
+                return array;
+            return markPartialJSON("Expected ']' at end of array");
+        }
+        index++;
+        return array;
+    };
+    const parseNum = () => {
+        if (index === 0) {
+            if (jsonString === "-")
+                throwMalformedError("Not sure what '-' is");
+            try {
+                return decodeJson(jsonString);
+            }
+            catch (error) {
+                if (Allow.NUM & allow) {
+                    try {
+                        return decodeJson(jsonString.substring(0, jsonString.lastIndexOf("e")));
+                    }
+                    catch { }
+                }
+                throwMalformedError(String(error));
+            }
+        }
+        const start = index;
+        if (jsonString[index] === "-")
+            index++;
+        while (jsonString[index] && !",]}".includes(jsonString[index]))
+            index++;
+        if (index === length && !(Allow.NUM & allow))
+            markPartialJSON("Unterminated number literal");
+        try {
+            return decodeJson(jsonString.substring(start, index));
+        }
+        catch (error) {
+            if (jsonString.substring(start, index) === "-")
+                markPartialJSON("Not sure what '-' is");
+            try {
+                return decodeJson(jsonString.substring(start, jsonString.lastIndexOf("e")));
+            }
+            catch {
+                throwMalformedError(String(error));
+            }
+        }
+    };
+    const skipBlank = () => {
+        while (index < length && " \n\r\t".includes(jsonString[index]))
+            index++;
+    };
+    return parseAny();
+};
+export const parse = parseJSON;

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

@@ -89,6 +89,7 @@ export declare const protocol: Protocol<{
         readonly verbosity?: import("./utils/open-responses-options.js").TextVerbosity | undefined;
     } | undefined;
     readonly temperature?: number | undefined;
+    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
     readonly tool_choice?: "required" | "auto" | "none" | {
         readonly type: "function";
         readonly name: string;
@@ -112,7 +113,6 @@ export declare const protocol: Protocol<{
     readonly presence_penalty?: number | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
     readonly parallel_tool_calls?: boolean | undefined;

package/dist/protocols/xai-responses.js

@@ -1,7 +1,5 @@
-import { Effect } from "effect";
 import { Protocol } from "../route/protocol.js";
 import { OpenResponses } from "./open-responses.js";
-import { ProviderShared } from "./shared.js";
 import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js";
 const ADAPTER = "xai-responses";
 const NAME = "xAI Responses";
@@ -23,15 +21,9 @@ const HOSTED_TOOLS = {
         input: (item) => ({ server_label: item.server_label, name: item.name, arguments: item.arguments }),
     },
 };
+// Grok speaks the standard Responses reasoning dialect (`reasoning_summary_text.*`,
+// handled by the baseline); only its hosted tool vocabulary differs.
 const step = (state, event) => {
-    if (event.type === "response.reasoning_text.delta" || event.type === "response.reasoning_summary.delta")
-        return event.item_id
-            ? Effect.succeed(OpenResponses.onReasoningDelta(state, event, event.item_id))
-            : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`);
-    if (event.type === "response.reasoning_text.done" || event.type === "response.reasoning_summary.done")
-        return event.item_id
-            ? Effect.succeed(OpenResponses.onReasoningDone(state, event))
-            : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`);
     if (event.type === "response.output_item.done" && event.item && ResponsesHostedTools.isItem(event.item, HOSTED_TOOLS))
         return ResponsesHostedTools.onDone(state, event.item, HOSTED_TOOLS);
     return OpenResponses.step(state, event);

package/dist/providers/amazon-bedrock-mantle.d.ts

@@ -85,11 +85,12 @@ export declare const routes: (RouteDef<{
     readonly max_tokens?: number | undefined;
     readonly tools?: readonly {
         readonly function: {
-            readonly name: string;
             readonly description: string;
+            readonly name: string;
             readonly parameters: {
                 readonly [x: string]: unknown;
             };
+            readonly strict?: boolean | undefined;
         };
         readonly type: "function";
         readonly cache_control?: {
@@ -113,6 +114,7 @@ export declare const routes: (RouteDef<{
     } | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly reasoning_effort?: import("../protocols/utils/open-responses-options.js").ReasoningEffort | undefined;
+    readonly tool_stream?: boolean | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
 }, import("../route/transport/http.js").HttpPrepared<string>> | RouteDef<{
@@ -214,6 +216,7 @@ export declare const routes: (RouteDef<{
         readonly verbosity?: import("../protocols/utils/open-responses-options.js").TextVerbosity | undefined;
     } | undefined;
     readonly temperature?: number | undefined;
+    readonly service_tier?: import("../protocols/utils/open-responses-options.js").ServiceTier | undefined;
     readonly tool_choice?: "required" | "auto" | "none" | {
         readonly type: "function";
         readonly name: string;
@@ -239,7 +242,6 @@ export declare const routes: (RouteDef<{
     readonly presence_penalty?: number | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly service_tier?: import("../protocols/utils/open-responses-options.js").ServiceTier | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
     readonly parallel_tool_calls?: boolean | undefined;

package/dist/providers/anthropic-compatible.d.ts

@@ -41,22 +41,46 @@ export declare const routes: import("../route/client.js").Route<{
                 readonly type: "base64";
                 readonly media_type: string;
                 readonly data: string;
+            } | {
+                readonly type: "url";
+                readonly url: string;
+            } | {
+                readonly type: "file";
+                readonly file_id: string;
             };
             readonly cache_control?: {
                 readonly type: "ephemeral";
                 readonly ttl?: "1h" | "5m" | undefined;
             } | undefined;
+            readonly transformations?: {
+                readonly oversized_image?: "error" | "downsize" | undefined;
+            } | undefined;
         } | {
             readonly type: "document";
             readonly source: {
                 readonly type: "base64";
                 readonly media_type: "application/pdf";
                 readonly data: string;
+            } | {
+                readonly type: "text";
+                readonly media_type: "text/plain";
+                readonly data: string;
+            } | {
+                readonly type: "url";
+                readonly url: string;
+            } | {
+                readonly type: "file";
+                readonly file_id: string;
             };
+            readonly title?: string | undefined;
+            readonly context?: string | undefined;
             readonly cache_control?: {
                 readonly type: "ephemeral";
                 readonly ttl?: "1h" | "5m" | undefined;
             } | undefined;
+            readonly citations?: {
+                readonly enabled: boolean;
+            } | undefined;
         } | {
             readonly type: "tool_result";
             readonly content: string | readonly ({
@@ -72,22 +96,46 @@ export declare const routes: import("../route/client.js").Route<{
                     readonly type: "base64";
                     readonly media_type: string;
                     readonly data: string;
+                } | {
+                    readonly type: "url";
+                    readonly url: string;
+                } | {
+                    readonly type: "file";
+                    readonly file_id: string;
                 };
                 readonly cache_control?: {
                     readonly type: "ephemeral";
                     readonly ttl?: "1h" | "5m" | undefined;
                 } | undefined;
+                readonly transformations?: {
+                    readonly oversized_image?: "error" | "downsize" | undefined;
+                } | undefined;
             } | {
                 readonly type: "document";
                 readonly source: {
                     readonly type: "base64";
                     readonly media_type: "application/pdf";
                     readonly data: string;
+                } | {
+                    readonly type: "text";
+                    readonly media_type: "text/plain";
+                    readonly data: string;
+                } | {
+                    readonly type: "url";
+                    readonly url: string;
+                } | {
+                    readonly type: "file";
+                    readonly file_id: string;
                 };
+                readonly title?: string | undefined;
+                readonly context?: string | undefined;
                 readonly cache_control?: {
                     readonly type: "ephemeral";
                     readonly ttl?: "1h" | "5m" | undefined;
                 } | undefined;
+                readonly citations?: {
+                    readonly enabled: boolean;
+                } | undefined;
             })[];
             readonly tool_use_id: string;
             readonly cache_control?: {
@@ -134,11 +182,11 @@ export declare const routes: import("../route/client.js").Route<{
         } | {
             readonly type: "thinking";
             readonly thinking: string;
+            readonly signature: string;
             readonly cache_control?: {
                 readonly type: "ephemeral";
                 readonly ttl?: "1h" | "5m" | undefined;
             } | undefined;
-            readonly signature?: string | undefined;
         } | {
             readonly data: string;
             readonly type: "redacted_thinking";
@@ -159,6 +207,9 @@ export declare const routes: import("../route/client.js").Route<{
         }[];
     })[];
     readonly stream: true;
+    readonly metadata?: {
+        readonly user_id?: string | null | undefined;
+    } | undefined;
     readonly tools?: readonly {
         readonly description: string;
         readonly name: string;
@@ -189,18 +240,38 @@ export declare const routes: import("../route/client.js").Route<{
     } | {
         readonly type: "disabled";
     } | undefined;
+    readonly service_tier?: "auto" | "standard_only" | undefined;
+    readonly container?: string | {
+        readonly id?: string | null | undefined;
+        readonly skills?: readonly {
+            readonly [x: string]: unknown;
+        }[] | null | undefined;
+    } | null | undefined;
+    readonly inference_geo?: string | null | undefined;
+    readonly cache_control?: {
+        readonly type: "ephemeral";
+        readonly ttl?: "1h" | "5m" | undefined;
+    } | undefined;
+    readonly output_config?: {
+        readonly format?: {
+            readonly type: "json_schema";
+            readonly schema: {
+                readonly [x: string]: unknown;
+            };
+        } | null | undefined;
+        readonly effort?: string | undefined;
+    } | undefined;
     readonly tool_choice?: {
         readonly type: "auto" | "none" | "any";
+        readonly disable_parallel_tool_use?: boolean | undefined;
     } | {
         readonly type: "tool";
         readonly name: string;
+        readonly disable_parallel_tool_use?: boolean | undefined;
     } | undefined;
     readonly top_p?: number | undefined;
     readonly top_k?: number | undefined;
     readonly stop_sequences?: readonly string[] | undefined;
-    readonly output_config?: {
-        readonly effort?: string | undefined;
-    } | undefined;
 }, import("../route/transport/http.js").HttpPrepared<string>>[];
 export declare const configure: (input: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;

package/dist/providers/anthropic.d.ts

@@ -25,22 +25,46 @@ export declare const routes: import("../route/client.js").Route<{
                 readonly type: "base64";
                 readonly media_type: string;
                 readonly data: string;
+            } | {
+                readonly type: "url";
+                readonly url: string;
+            } | {
+                readonly type: "file";
+                readonly file_id: string;
             };
             readonly cache_control?: {
                 readonly type: "ephemeral";
                 readonly ttl?: "1h" | "5m" | undefined;
             } | undefined;
+            readonly transformations?: {
+                readonly oversized_image?: "error" | "downsize" | undefined;
+            } | undefined;
         } | {
             readonly type: "document";
             readonly source: {
                 readonly type: "base64";
                 readonly media_type: "application/pdf";
                 readonly data: string;
+            } | {
+                readonly type: "text";
+                readonly media_type: "text/plain";
+                readonly data: string;
+            } | {
+                readonly type: "url";
+                readonly url: string;
+            } | {
+                readonly type: "file";
+                readonly file_id: string;
             };
+            readonly title?: string | undefined;
+            readonly context?: string | undefined;
             readonly cache_control?: {
                 readonly type: "ephemeral";
                 readonly ttl?: "1h" | "5m" | undefined;
             } | undefined;
+            readonly citations?: {
+                readonly enabled: boolean;
+            } | undefined;
         } | {
             readonly type: "tool_result";
             readonly content: string | readonly ({
@@ -56,22 +80,46 @@ export declare const routes: import("../route/client.js").Route<{
                     readonly type: "base64";
                     readonly media_type: string;
                     readonly data: string;
+                } | {
+                    readonly type: "url";
+                    readonly url: string;
+                } | {
+                    readonly type: "file";
+                    readonly file_id: string;
                 };
                 readonly cache_control?: {
                     readonly type: "ephemeral";
                     readonly ttl?: "1h" | "5m" | undefined;
                 } | undefined;
+                readonly transformations?: {
+                    readonly oversized_image?: "error" | "downsize" | undefined;
+                } | undefined;
             } | {
                 readonly type: "document";
                 readonly source: {
                     readonly type: "base64";
                     readonly media_type: "application/pdf";
                     readonly data: string;
+                } | {
+                    readonly type: "text";
+                    readonly media_type: "text/plain";
+                    readonly data: string;
+                } | {
+                    readonly type: "url";
+                    readonly url: string;
+                } | {
+                    readonly type: "file";
+                    readonly file_id: string;
                 };
+                readonly title?: string | undefined;
+                readonly context?: string | undefined;
                 readonly cache_control?: {
                     readonly type: "ephemeral";
                     readonly ttl?: "1h" | "5m" | undefined;
                 } | undefined;
+                readonly citations?: {
+                    readonly enabled: boolean;
+                } | undefined;
             })[];
             readonly tool_use_id: string;
             readonly cache_control?: {
@@ -118,11 +166,11 @@ export declare const routes: import("../route/client.js").Route<{
         } | {
             readonly type: "thinking";
             readonly thinking: string;
+            readonly signature: string;
             readonly cache_control?: {
                 readonly type: "ephemeral";
                 readonly ttl?: "1h" | "5m" | undefined;
             } | undefined;
-            readonly signature?: string | undefined;
         } | {
             readonly data: string;
             readonly type: "redacted_thinking";
@@ -143,6 +191,9 @@ export declare const routes: import("../route/client.js").Route<{
         }[];
     })[];
     readonly stream: true;
+    readonly metadata?: {
+        readonly user_id?: string | null | undefined;
+    } | undefined;
     readonly tools?: readonly {
         readonly description: string;
         readonly name: string;
@@ -173,18 +224,38 @@ export declare const routes: import("../route/client.js").Route<{
     } | {
         readonly type: "disabled";
     } | undefined;
+    readonly service_tier?: "auto" | "standard_only" | undefined;
+    readonly container?: string | {
+        readonly id?: string | null | undefined;
+        readonly skills?: readonly {
+            readonly [x: string]: unknown;
+        }[] | null | undefined;
+    } | null | undefined;
+    readonly inference_geo?: string | null | undefined;
+    readonly cache_control?: {
+        readonly type: "ephemeral";
+        readonly ttl?: "1h" | "5m" | undefined;
+    } | undefined;
+    readonly output_config?: {
+        readonly format?: {
+            readonly type: "json_schema";
+            readonly schema: {
+                readonly [x: string]: unknown;
+            };
+        } | null | undefined;
+        readonly effort?: string | undefined;
+    } | undefined;
     readonly tool_choice?: {
         readonly type: "auto" | "none" | "any";
+        readonly disable_parallel_tool_use?: boolean | undefined;
     } | {
         readonly type: "tool";
         readonly name: string;
+        readonly disable_parallel_tool_use?: boolean | undefined;
     } | undefined;
     readonly top_p?: number | undefined;
     readonly top_k?: number | undefined;
     readonly stop_sequences?: readonly string[] | undefined;
-    readonly output_config?: {
-        readonly effort?: string | undefined;
-    } | undefined;
 }, import("../route/transport/http.js").HttpPrepared<string>>[];
 export type Config = RouteDefaultsInput & ProviderAuthOption<"optional"> & {
     readonly baseURL?: string;

package/dist/providers/azure.d.ts

@@ -88,11 +88,12 @@ export declare const routes: (RouteDef<{
     readonly max_tokens?: number | undefined;
     readonly tools?: readonly {
         readonly function: {
-            readonly name: string;
             readonly description: string;
+            readonly name: string;
             readonly parameters: {
                 readonly [x: string]: unknown;
             };
+            readonly strict?: boolean | undefined;
         };
         readonly type: "function";
         readonly cache_control?: {
@@ -116,6 +117,7 @@ export declare const routes: (RouteDef<{
     } | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly reasoning_effort?: import("../protocols/utils/open-responses-options.js").ReasoningEffort | undefined;
+    readonly tool_stream?: boolean | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
 }, import("../route/transport/http.js").HttpPrepared<string>> | RouteDef<{
@@ -217,6 +219,7 @@ export declare const routes: (RouteDef<{
         readonly verbosity?: import("../protocols/utils/open-responses-options.js").TextVerbosity | undefined;
     } | undefined;
     readonly temperature?: number | undefined;
+    readonly service_tier?: import("../protocols/utils/open-responses-options.js").ServiceTier | undefined;
     readonly tool_choice?: "required" | "auto" | "none" | {
         readonly type: "function";
         readonly name: string;
@@ -242,7 +245,6 @@ export declare const routes: (RouteDef<{
     readonly presence_penalty?: number | undefined;
     readonly safety_identifier?: string | undefined;
     readonly top_logprobs?: number | undefined;
-    readonly service_tier?: import("../protocols/utils/open-responses-options.js").ServiceTier | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
     readonly parallel_tool_calls?: boolean | undefined;