@opencode/ai 0.0.0-beta-19275

package/dist/providers/meta.js

@@ -0,0 +1,113 @@
+import { OpenAIChat } from "../protocols/openai-chat.js";
+import { AnthropicMessages } from "../protocols/anthropic-messages.js";
+import { MetaResponses } from "../protocols/meta-responses.js";
+import { MetaMessages } from "../protocols/meta-messages.js";
+import { MetaImages } from "../protocols/meta-images.js";
+import { AuthOptions } from "../route/auth-options.js";
+import { Route } from "../route/client.js";
+import { Endpoint } from "../route/endpoint.js";
+import { HttpOptions, ProviderID, ToolDefinition } from "../schema/index.js";
+export const id = ProviderID.make("meta");
+const baseURL = "https://api.meta.ai/v1";
+export const webSearch = (options = {}) => ToolDefinition.make({
+    name: "web_search",
+    description: "Search the web with Meta's hosted search tool.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    native: {
+        meta: {
+            type: "web_search",
+            search_context_size: options.searchContextSize,
+            user_location: options.userLocation === undefined ? undefined : { type: "approximate", ...options.userLocation },
+        },
+    },
+});
+export const imageGeneration = (options = {}) => ToolDefinition.make({
+    name: "image_generation",
+    description: "Generate or edit an image with Muse Image.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    native: {
+        meta: {
+            type: "image_generation",
+            size: options.size,
+            output_format: options.outputFormat,
+            reasoning_strength: options.reasoningStrength,
+            enable_image_search: options.enableImageSearch,
+            enable_web_search: options.enableWebSearch,
+            enable_shell: options.enableShell,
+        },
+    },
+});
+const responsesRoute = Route.make({
+    id: "meta-responses",
+    provider: id,
+    providerMetadataKey: "meta",
+    protocol: MetaResponses.protocol,
+    endpoint: Endpoint.path("/responses", { baseURL }),
+    // Meta Responses does not support WebSocket upgrades; always use HTTP/SSE.
+    transport: MetaResponses.httpTransport,
+    defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
+});
+const chatRoute = Route.make({
+    id: "meta-chat",
+    provider: id,
+    providerMetadataKey: "meta",
+    protocol: OpenAIChat.protocol,
+    endpoint: Endpoint.path("/chat/completions", { baseURL }),
+    framing: OpenAIChat.framing,
+});
+const messagesRoute = Route.make({
+    id: "meta-messages",
+    provider: id,
+    providerMetadataKey: "meta",
+    protocol: MetaMessages.protocol,
+    endpoint: Endpoint.path("/messages", { baseURL }),
+    framing: AnthropicMessages.framing,
+    defaults: { providerOptions: { thinking: { type: "adaptive", display: "omitted" } } },
+});
+export const routes = [responsesRoute, chatRoute, messagesRoute];
+export const configure = (input = {}) => {
+    const { apiKey: _apiKey, auth: _auth, baseURL: endpoint, ...defaults } = input;
+    const options = {
+        ...defaults,
+        endpoint: { baseURL: endpoint ?? baseURL },
+        auth: AuthOptions.bearer(input, "META_API_KEY"),
+    };
+    const configuredResponses = responsesRoute.with(options);
+    const configuredChat = chatRoute.with(options);
+    const configuredMessages = messagesRoute.with(options);
+    const responses = (modelID) => configuredResponses.model({ id: modelID });
+    const chat = (modelID) => configuredChat.model({
+        id: modelID,
+        compatibility: { maxTokensField: "max_completion_tokens", supportsStore: false },
+    });
+    const messages = (modelID) => configuredMessages.model({
+        id: modelID,
+        compatibility: { requireSignature: false },
+    });
+    const image = (modelID) => MetaImages.model({
+        id: modelID,
+        baseURL: endpoint ?? baseURL,
+        auth: options.auth,
+        headers: input.headers,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    });
+    return { id, model: responses, responses, chat, messages, image, configure };
+};
+export const provider = configure();
+export const responses = provider.responses;
+export const chat = provider.chat;
+export const messages = provider.messages;
+export const image = provider.image;
+export const model = (modelID, settings) => fromSettings(settings).responses(modelID);
+export const chatModel = (modelID, settings) => fromSettings(settings).chat(modelID);
+export const messagesModel = (modelID, settings) => fromSettings(settings).messages(modelID);
+function fromSettings(settings) {
+    return configure({
+        apiKey: settings.apiKey,
+        baseURL: settings.baseURL,
+        headers: settings.headers,
+        http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+        providerOptions: settings.providerOptions,
+    });
+}
+export * as Meta from "./meta.js";

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

@@ -0,0 +1,4 @@
+import type { ProviderPackage } from "../../provider-package.js";
+import { MiniMax } from "../minimax.js";
+export type Settings = MiniMax.Settings<MiniMax.ChatOptionsInput>;
+export declare const model: ProviderPackage.Definition<Settings, MiniMax.ChatOptionsInput>["model"];

package/dist/providers/minimax/chat.js

@@ -0,0 +1,8 @@
+import { MiniMax } from "../minimax.js";
+export const model = (modelID, settings) => MiniMax.configure({
+    apiKey: settings.apiKey,
+    baseURL: settings.baseURL,
+    headers: settings.headers,
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    providerOptions: settings.providerOptions,
+}).chat(modelID);

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

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

package/dist/providers/minimax/messages.js

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

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

@@ -0,0 +1,4 @@
+import type { ProviderPackage } from "../../provider-package.js";
+import { MiniMax } from "../minimax.js";
+export type Settings = MiniMax.Settings<MiniMax.ResponsesOptionsInput>;
+export declare const model: ProviderPackage.Definition<Settings, MiniMax.ResponsesOptionsInput>["model"];

package/dist/providers/minimax/responses.js

@@ -0,0 +1,8 @@
+import { MiniMax } from "../minimax.js";
+export const model = (modelID, settings) => MiniMax.configure({
+    apiKey: settings.apiKey,
+    baseURL: settings.baseURL,
+    headers: settings.headers,
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    providerOptions: settings.providerOptions,
+}).responses(modelID);