@opencode/ai 0.0.0-dev-19364 → 0.0.0-dev-19367

package/dist/protocols/alibaba-responses.js

@@ -0,0 +1,80 @@
+import { Effect, Schema } from "effect";
+import { Protocol } from "../route/protocol.js";
+import { OpenResponses } from "./open-responses.js";
+import { JsonObject, optionalArray, ProviderShared } from "./shared.js";
+import { OpenResponsesOptions } from "./utils/open-responses-options.js";
+import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js";
+const Options = Schema.Struct({
+    reasoningEffort: OpenResponsesOptions.Options.fields.reasoningEffort,
+    enableThinking: Schema.optional(Schema.Boolean),
+    store: OpenResponsesOptions.Options.fields.store,
+    previousResponseId: Schema.optional(Schema.String),
+    conversation: Schema.optional(Schema.String),
+});
+const NativeTool = Schema.Struct({ type: Schema.Literals(["web_search", "web_extractor", "code_interpreter"]) });
+const WebExtractorItem = Schema.StructWithRest(Schema.Struct({
+    type: Schema.Literal("web_extractor_call"),
+    id: Schema.String,
+    urls: Schema.optional(Schema.Array(Schema.String)),
+    goal: Schema.optional(Schema.String),
+}), [JsonObject]);
+const Body = Schema.Struct({
+    ...OpenResponses.coreFields,
+    input: Schema.Array(Schema.Union([OpenResponses.InputItem, WebExtractorItem])),
+    tools: optionalArray(Schema.Union([OpenResponses.Tool, NativeTool])),
+    enable_thinking: Options.fields.enableThinking,
+    previous_response_id: Options.fields.previousResponseId,
+    conversation: Options.fields.conversation,
+    stream: Schema.Literal(true),
+});
+const adapter = {
+    id: "alibaba-responses",
+    name: "Alibaba Responses",
+    nativeTool: (native) => ProviderShared.validateWith(Schema.decodeUnknownEffect(NativeTool))(native.alibaba),
+    restoreHostedToolItem: (item) => (Schema.is(WebExtractorItem)(item) ? item : undefined),
+};
+const tools = {
+    web_search_call: { name: "web_search", input: (item) => item.action ?? {} },
+    code_interpreter_call: { name: "code_interpreter", input: (item) => ({ code: item.code }) },
+};
+export const protocol = Protocol.make({
+    id: adapter.id,
+    body: {
+        schema: Body,
+        from: Effect.fn("AlibabaResponses.fromRequest")(function* (req) {
+            const opts = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Options))(req.providerOptions ?? {});
+            const body = yield* OpenResponses.fromRequestWithAdapter(req, adapter);
+            const choice = body.tool_choice;
+            return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))({
+                ...body,
+                enable_thinking: opts.enableThinking,
+                previous_response_id: opts.previousResponseId,
+                conversation: opts.conversation,
+                // Model Studio expresses named selection through allowed_tools.
+                tool_choice: typeof choice === "object" && choice.type === "function"
+                    ? { type: "allowed_tools", mode: "required", tools: [choice] }
+                    : choice,
+            });
+        }),
+    },
+    stream: {
+        event: OpenResponses.protocol.stream.event,
+        initial: (req) => OpenResponses.initial(req, adapter),
+        step: (state, input) => Effect.gen(function* () {
+            const event = OpenResponses.normalize(state, input);
+            if (event.type !== "response.output_item.done" || !event.item)
+                return yield* OpenResponses.step(state, event);
+            if (event.item.type === "web_extractor_call") {
+                const item = yield* Schema.decodeUnknownEffect(WebExtractorItem)(event.item).pipe(Effect.mapError((cause) => ProviderShared.eventError(adapter.id, "Alibaba returned an invalid web extraction item", ProviderShared.encodeJson(event), cause)));
+                return yield* ResponsesHostedTools.onDone(state, item, {
+                    web_extractor_call: { name: "web_extractor", input: () => ({ urls: item.urls, goal: item.goal }) },
+                });
+            }
+            if (ResponsesHostedTools.isItem(event.item, tools))
+                return yield* ResponsesHostedTools.onDone(state, event.item, tools);
+            return yield* OpenResponses.step(state, event);
+        }),
+        terminal: OpenResponses.terminal,
+    },
+});
+export * as AlibabaResponses from "./alibaba-responses.js";

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

@@ -656,6 +656,9 @@ export type NormalizedEvent = Event & {
 export interface ProviderAdapter {
     readonly id: string;
     readonly name: string;
+    readonly nativeTool?: (native: NonNullable<ToolDefinition["native"]>) => Effect.Effect<{
+        readonly type: string;
+    }, AIError>;
     readonly lowerMedia?: (input: {
         readonly part: MediaPart;
         readonly media: ProviderShared.NormalizedMedia;
@@ -750,13 +753,7 @@ export declare const fromRequestWithAdapter: (request: LLMRequest<import("../sch
     readonly [x: string]: unknown;
 }, import("../route.js").CompactionOperations | undefined>>, adapter: ProviderAdapter) => Effect.Effect<{
     tools: {
-        type: "function";
-        name: string;
-        description: string;
-        parameters: {
-            readonly [x: string]: unknown;
-        };
-        strict: boolean;
+        readonly type: string;
     }[] | undefined;
     tool_choice: "required" | "auto" | "none" | {
         type: "allowed_tools";

package/dist/protocols/open-responses.js

@@ -597,7 +597,9 @@ export const fromRequestWithAdapter = Effect.fn("OpenResponses.fromRequestWithAd
         ...lowerGeneration(request),
         tools: projected.tools.length === 0
             ? undefined
-            : yield* Effect.forEach(projected.tools, (tool) => lowerTool(adapter.name, tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility))),
+            : yield* Effect.forEach(projected.tools, (tool) => tool.native !== undefined && adapter.nativeTool
+                ? adapter.nativeTool(tool.native)
+                : lowerTool(adapter.name, tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility))),
         tool_choice: allowedToolChoice(request) ??
             (request.toolChoice ? yield* lowerToolChoice(adapter.name, request.toolChoice) : undefined),
     };

package/dist/providers/alibaba/chat.d.ts

@@ -0,0 +1 @@
+export { model, type Settings } from "../alibaba.js";

package/dist/providers/alibaba/chat.js

@@ -0,0 +1 @@
+export { model } from "../alibaba.js";

package/dist/providers/alibaba/messages.d.ts

@@ -0,0 +1,3 @@
+import type { Alibaba } from "../alibaba.js";
+export { messagesModel as model } from "../alibaba.js";
+export type Settings = Alibaba.Settings<Alibaba.MessagesOptionsInput>;

package/dist/providers/alibaba/messages.js

@@ -0,0 +1 @@
+export { messagesModel as model } from "../alibaba.js";

package/dist/providers/alibaba/responses.d.ts

@@ -0,0 +1,3 @@
+import type { Alibaba } from "../alibaba.js";
+export { responsesModel as model } from "../alibaba.js";
+export type Settings = Alibaba.Settings<Alibaba.ResponsesOptionsInput>;

package/dist/providers/alibaba/responses.js

@@ -0,0 +1 @@
+export { responsesModel as model } from "../alibaba.js";