@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-4ph0a4gn.js

@@ -0,0 +1,207 @@
+import {
+  ID15,
+  Service73
+} from "./worktree-7vcja736.js";
+import {
+  Service74
+} from "./worktree-z82wee6n.js";
+import {
+  Service54
+} from "./worktree-r82b328h.js";
+import {
+  Service48,
+  args2
+} from "./worktree-w55j1d38.js";
+import {
+  Service17
+} from "./worktree-p9690q97.js";
+import {
+  make5
+} from "./worktree-qt1vhyrn.js";
+import {
+  parseOption2
+} from "./worktree-5daktx2q.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/config/plugin/command.ts
+var exports_command = {};
+__export(exports_command, {
+  ConfigCommandPlugin: () => exports_command,
+  Plugin: () => Plugin23
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { ConfigCommand } from "@opencode/schema/config/command";
+import { Model } from "@opencode/schema/model";
+import { Provider } from "@opencode/schema/provider";
+import { AppProcess } from "@opencode/util/process";
+import path from "path";
+import { Effect, Option, PubSub, Schema, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { FSUtil } from "@opencode/util/fs-util";
+var decodeCommand = Schema.decodeUnknownOption(ConfigCommand.Info);
+var Plugin23 = define({
+  id: "opencode.config.command",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service54;
+    const fs = yield* FSUtil.Service;
+    const loadEntry = Effect.fnUntraced(function* (entry) {
+      if (entry.type === "document")
+        return [{ commands: entry.info.commands }];
+      if (entry.type !== "directory")
+        return [];
+      const commands = yield* loadDirectory(fs, entry.path);
+      return [{ commands: Object.fromEntries(commands.map((command) => [command.name, command.info])) }];
+    });
+    const location = yield* Service74;
+    const processes = yield* AppProcess.Service;
+    const shell = yield* Service48;
+    const sessions = yield* Service17;
+    const agents = yield* Service73;
+    const subagents = yield* make5;
+    const load = Effect.fn("ConfigCommandPlugin.load")(function* () {
+      return yield* Effect.forEach(yield* config.entries(), loadEntry).pipe(Effect.map((documents) => documents.flat()));
+    });
+    const loaded = { documents: [] };
+    const reload = load().pipe(Effect.tap((documents) => Effect.sync(() => loaded.documents = documents)), Effect.andThen(ctx.command.reload()));
+    const changes = yield* PubSub.sliding(1);
+    const notify = () => PubSub.publish(changes, undefined);
+    yield* config.changes().pipe(Stream.filterEffect((update) => Effect.map(config.entries(), (entries) => isCommandSource(entries, update.path))), Stream.runForEach(notify), Effect.forkScoped({ startImmediately: true }));
+    yield* ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(notify), Effect.forkScoped({ startImmediately: true }));
+    const updates = yield* PubSub.subscribe(changes);
+    yield* Stream.fromSubscription(updates).pipe(Stream.debounce("100 millis"), Stream.runForEach(() => reload), Effect.forkScoped({ startImmediately: true }));
+    loaded.documents = yield* load();
+    yield* ctx.command.transform((editor) => {
+      for (const document of loaded.documents) {
+        for (const [name, command] of Object.entries(document.commands ?? {})) {
+          const subagent = command.subagent ?? command.subtask;
+          editor.add({
+            name,
+            description: command.description,
+            execute: (input) => Effect.gen(function* () {
+              const agent = command.agent === undefined ? undefined : ID15.make(command.agent);
+              const commandAgent = agent === undefined ? undefined : (yield* ctx.agent.get({ agentID: agent })).data;
+              const model = command.model === undefined ? commandAgent?.model : {
+                id: Model.ID.make(command.model.model),
+                providerID: Provider.ID.make(command.model.providerID),
+                ...command.model.variant === undefined ? {} : { variant: Model.VariantID.make(command.model.variant) }
+              };
+              const text = yield* evaluateTemplate(command.template, input.prompt.text, {
+                location,
+                processes,
+                shell
+              });
+              if (subagent ?? commandAgent?.mode === "subagent") {
+                const parent = yield* sessions.get(input.sessionID);
+                const selected = yield* agents.select(agent ?? parent.agent);
+                const child = yield* sessions.create({
+                  parentID: parent.id,
+                  title: command.description ?? name,
+                  agent: selected.id,
+                  model: model ?? selected.info?.model ?? parent.model
+                });
+                yield* sessions.prompt({
+                  ...input.prompt,
+                  sessionID: child.id,
+                  text: ["You are a subagent spawned by another session.", text].join(`
+`),
+                  resume: false
+                });
+                const recovery = {
+                  kind: "subagent",
+                  parentSessionID: parent.id,
+                  childSessionID: child.id,
+                  agent: selected.id,
+                  description: command.description ?? name
+                };
+                yield* subagents.start(recovery);
+                yield* subagents.background(recovery);
+                return;
+              }
+              if (agent !== undefined) {
+                const session = yield* ctx.session.get({ sessionID: input.sessionID });
+                if (session.agent !== agent)
+                  yield* ctx.session.switchAgent({ sessionID: input.sessionID, agent });
+              }
+              if (model !== undefined)
+                yield* ctx.session.switchModel({ sessionID: input.sessionID, model });
+              yield* ctx.session.prompt({
+                ...input.prompt,
+                sessionID: input.sessionID,
+                text,
+                delivery: input.delivery
+              });
+            }).pipe(Effect.asVoid)
+          });
+        }
+      }
+    });
+  })
+});
+var sourceDirectories = ["command", "commands"];
+function isCommandSource(entries, file) {
+  return entries.some((entry) => entry.type === "directory" && sourceDirectories.some((name) => FSUtil.contains(path.join(entry.path, name), file)));
+}
+function loadDirectory(fs, directory) {
+  return Effect.gen(function* () {
+    const files = yield* fs.scan("{command,commands}/**/*.md", { cwd: directory, absolute: true, dot: true, symlink: true }).pipe(Effect.orElseSucceed(() => []));
+    return yield* Effect.forEach(files.toSorted(), (filepath) => fs.readFileStringSafe(filepath).pipe(Effect.map((content) => content === undefined ? undefined : decode(directory, filepath, content)), Effect.orElseSucceed(() => {
+      return;
+    }))).pipe(Effect.map((commands) => commands.filter((command) => command !== undefined)));
+  });
+}
+function decode(directory, filepath, content) {
+  const markdown = parseOption2(content);
+  if (!markdown)
+    return;
+  const info = Option.getOrUndefined(decodeCommand({ ...markdown.data, template: markdown.content.trim() }));
+  if (!info)
+    return;
+  return {
+    name: path.relative(directory, filepath).replaceAll("\\", "/").replace(/^(command|commands)\//, "").replace(/\.md$/, ""),
+    info
+  };
+}
+function evaluateTemplate(template, input, services) {
+  return Effect.gen(function* () {
+    const args = parseArguments(input);
+    const placeholders = template.match(placeholderRegex) ?? [];
+    const last = Math.max(0, ...placeholders.map((item) => Number(item.slice(1))));
+    const expanded = template.replaceAll(placeholderRegex, (_, index) => {
+      const position = Number(index);
+      const argIndex = position - 1;
+      if (argIndex >= args.length)
+        return "";
+      if (position === last)
+        return args.slice(argIndex).join(" ");
+      return args[argIndex];
+    });
+    const withArguments = expanded.replaceAll("$ARGUMENTS", input);
+    const text = placeholders.length === 0 && !template.includes("$ARGUMENTS") && input.trim() ? `${withArguments}
+
+${input}`.trim() : withArguments.trim();
+    const matches = Array.from(text.matchAll(shellRegex));
+    if (matches.length === 0)
+      return text;
+    const shell = yield* services.shell.resolve({ priority: "config" });
+    const outputs = yield* Effect.forEach(matches, (match) => {
+      const source = match[1] ?? "";
+      return services.processes.run(ChildProcess.make(shell, args2(shell, source), {
+        cwd: services.location.directory,
+        stdin: "ignore"
+      }), { combineOutput: true }).pipe(Effect.map((result) => (result.output ?? Buffer.concat([result.stdout, result.stderr])).toString("utf8")), Effect.mapError((error) => new Error(`Shell interpolation failed for ${JSON.stringify(source)}: ${error.message}`)));
+    }, { concurrency: 2 });
+    const iterator = outputs[Symbol.iterator]();
+    return text.replace(shellRegex, () => iterator.next().value ?? "");
+  });
+}
+function parseArguments(input) {
+  return (input.match(argsRegex) ?? []).map((arg) => arg.replace(quoteTrimRegex, ""));
+}
+var argsRegex = /(?:\[Image\s+\d+\]|"[^"]*"|'[^']*'|[^\s"']+)/gi;
+var placeholderRegex = /\$(\d+)/g;
+var quoteTrimRegex = /^["']|["']$/g;
+var shellRegex = /!`([^`]+)`/g;
+
+export { Plugin23, exports_command };

package/dist/chunks/worktree-4vfmzcq2.js

@@ -0,0 +1,328 @@
+import {
+  provider2,
+  model2
+} from "./worktree-0paq2nw3.js";
+import {
+  aisdk2
+} from "./worktree-9qn3qky1.js";
+import {
+  Capabilities2,
+  compatibility2
+} from "./worktree-esam66tc.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/v1/config/migrate.ts
+var exports_migrate = {};
+__export(exports_migrate, {
+  ConfigMigrateV1: () => exports_migrate,
+  commands: () => commands2,
+  migrate: () => migrate2,
+  migrateAgent: () => migrateAgent2,
+  migrateMcp: () => migrateMcp2,
+  migrateProvider: () => migrateProvider2,
+  normalizeAction: () => normalizeAction2,
+  providerID: () => providerID2
+});
+import { Info } from "@opencode/schema/config";
+import { ConfigAgent } from "@opencode/schema/config/agent";
+import { Schema } from "effect";
+var decodeOptions = { errors: "all", onExcessProperty: "ignore", propertyOrder: "original" };
+var decodeInfo = Schema.decodeUnknownSync(Schema.fromJsonString(Info), decodeOptions);
+var encodeInfo = Schema.encodeSync(Info);
+var decodeAgent = Schema.decodeUnknownSync(Schema.fromJsonString(ConfigAgent.Info), decodeOptions);
+var encodeAgent = Schema.encodeSync(ConfigAgent.Info);
+function migrate2(info) {
+  return encodeInfo(decodeInfo(JSON.stringify({
+    $schema: info.$schema,
+    shell: info.shell,
+    model: modelSelection(info.model),
+    default_agent: info.default_agent,
+    update: info.autoupdate === false ? "disable" : info.autoupdate === "notify" ? "notify" : info.autoupdate === true ? "auto" : undefined,
+    share: info.share ?? (info.autoshare ? "auto" : undefined),
+    enterprise: info.enterprise,
+    username: info.username,
+    permissions: permissions(info.permission, info.tools),
+    agents: agents(info),
+    snapshots: info.snapshot,
+    watcher: info.watcher,
+    formatter: info.formatter,
+    lsp: info.lsp,
+    media: info.attachment,
+    tool_output: info.tool_output,
+    mcp: mcp(info),
+    compaction: info.compaction && {
+      auto: info.compaction.auto,
+      prune: info.compaction.prune,
+      keep: {
+        tokens: info.compaction.preserve_recent_tokens
+      },
+      buffer: info.compaction.reserved
+    },
+    skills: info.skills && [...info.skills.paths ?? [], ...info.skills.urls ?? []],
+    commands: commands2(info.command),
+    instructions: info.instructions,
+    references: info.references ?? info.reference,
+    experimental: experimental(info),
+    plugins: info.plugin?.map((plugin) => typeof plugin === "string" ? plugin : { package: plugin[0], options: plugin[1] }),
+    providers: providers(info.provider)
+  })));
+}
+function experimental(info) {
+  const policies = [
+    ...info.enabled_providers === undefined ? [] : [
+      { action: "provider.use", resource: "*", effect: "deny" },
+      ...info.enabled_providers.map((resource) => ({
+        action: "provider.use",
+        resource: providerID2(resource),
+        effect: "allow"
+      }))
+    ],
+    ...(info.disabled_providers ?? []).map((resource) => ({
+      action: "provider.use",
+      resource: providerID2(resource),
+      effect: "deny"
+    }))
+  ];
+  if (info.experimental?.subagent_depth === undefined && !policies.length)
+    return;
+  return {
+    subagent_depth: info.experimental?.subagent_depth,
+    policies: policies.length ? policies : undefined
+  };
+}
+function permissions(info, tools) {
+  const rules = Object.entries(tools ?? {}).map(([action, enabled]) => ({
+    action: normalizeAction2(action),
+    resource: "*",
+    effect: enabled ? "allow" : "deny"
+  }));
+  for (const [key, rule] of Object.entries(info ?? {})) {
+    if (!rule)
+      continue;
+    const action = normalizeAction2(key);
+    if (typeof rule === "string") {
+      rules.push({ action, resource: "*", effect: rule });
+      continue;
+    }
+    rules.push(...Object.entries(rule).map(([resource, effect]) => ({ action, resource, effect })));
+  }
+  return rules.length ? rules : undefined;
+}
+function normalizeAction2(action) {
+  if (action === "write" || action === "patch")
+    return "edit";
+  if (action === "task")
+    return "subagent";
+  if (action === "bash")
+    return "shell";
+  return action;
+}
+function agents(info) {
+  const entries = [
+    ...Object.entries(info.agent ?? {}),
+    ...Object.entries(info.mode ?? {}).map(([name, agent]) => [name, { ...agent, mode: "primary" }])
+  ];
+  const result = Object.fromEntries(entries.flatMap(([name, agent]) => agent ? [[name, migrateAgent2(agent)]] : []));
+  const small = modelSelection(info.small_model);
+  if (!small)
+    return entries.length ? result : undefined;
+  return {
+    ...result,
+    title: {
+      model: small,
+      ...result.title
+    }
+  };
+}
+function migrateAgent2(info) {
+  const body = {
+    ...info.options,
+    ...info.temperature === undefined ? {} : { temperature: info.temperature },
+    ...info.top_p === undefined ? {} : { top_p: info.top_p }
+  };
+  return encodeAgent(decodeAgent(JSON.stringify({
+    model: modelSelection(info.model, info.variant),
+    request: Object.keys(body).length ? { body } : undefined,
+    system: info.prompt,
+    description: info.description,
+    mode: info.mode,
+    hidden: info.hidden,
+    color: info.color === undefined ? undefined : info.color.startsWith("#") ? info.color : "#aaaaaa",
+    steps: info.steps,
+    disabled: info.disable,
+    permissions: permissions(info.permission)
+  })));
+}
+function commands2(info) {
+  if (!info)
+    return;
+  return Object.fromEntries(Object.entries(info).map(([id, command]) => [
+    id,
+    {
+      template: command.template,
+      description: command.description,
+      agent: command.agent,
+      model: modelSelection(command.model, command.variant),
+      subagent: command.subtask
+    }
+  ]));
+}
+function modelSelection(input, variant) {
+  if (input === undefined || !/^[^/#]+\/[^#]+$/.test(input))
+    return;
+  const separator = input.indexOf("/");
+  return {
+    providerID: providerID2(input.slice(0, separator)),
+    model: input.slice(separator + 1),
+    ...variant === undefined || variant.length === 0 || variant.includes("#") ? {} : { variant }
+  };
+}
+function mcp(info) {
+  const servers = Object.fromEntries(Object.entries(info.mcp ?? {}).flatMap(([name, server]) => ("type" in server) ? [[name, migrateMcp2(server)]] : []));
+  const timeout = info.experimental?.mcp_timeout;
+  if (!timeout && !Object.keys(servers).length)
+    return;
+  return { timeout: timeout === undefined ? undefined : { catalog: timeout, execution: timeout }, servers };
+}
+function migrateMcp2(info) {
+  const disabled = info.enabled === undefined ? undefined : !info.enabled;
+  if (info.type === "local")
+    return {
+      type: info.type,
+      command: info.command,
+      cwd: info.cwd,
+      environment: info.environment,
+      disabled,
+      timeout: info.timeout === undefined ? undefined : { catalog: info.timeout, execution: info.timeout }
+    };
+  return {
+    type: info.type,
+    url: info.url,
+    headers: info.headers,
+    oauth: info.oauth && {
+      client_id: info.oauth.clientId,
+      client_secret: info.oauth.clientSecret,
+      scope: info.oauth.scope,
+      callback_port: info.oauth.callbackPort,
+      redirect_uri: info.oauth.redirectUri
+    },
+    disabled,
+    timeout: info.timeout === undefined ? undefined : { catalog: info.timeout, execution: info.timeout }
+  };
+}
+function providers(info) {
+  if (!info)
+    return;
+  return Object.fromEntries(Object.entries(info).flatMap(([name, provider]) => {
+    const id = providerID2(name);
+    if (id !== name && info[id])
+      return [];
+    return [[id, migrateProvider2(name, provider)]];
+  }));
+}
+function migrateProvider2(sourceID, info) {
+  if (sourceID === "azure-cognitive-services")
+    return migrateAzureCognitiveServicesProvider(info);
+  if (sourceID === "google-vertex-anthropic")
+    return migrateGoogleVertexAnthropicProvider(info);
+  return migrateStandardProvider(info);
+}
+function migrateStandardProvider(info) {
+  const options = provider2(info.options ?? {});
+  return {
+    name: info.name,
+    env: info.env,
+    package: info.npm ? aisdk2(info.npm) : undefined,
+    settings: info.api ? { ...options.settings, baseURL: info.api } : info.options ? options.settings : undefined,
+    headers: info.options && options.headers,
+    body: info.options && options.body,
+    models: info.models && Object.fromEntries(Object.entries(info.models).map(([name, model]) => [name, migrateModel(model)]))
+  };
+}
+function migrateAzureCognitiveServicesProvider(info) {
+  const standard = migrateStandardProvider(info);
+  const migrated = {
+    ...standard,
+    env: standard.env?.filter((name) => name !== "AZURE_COGNITIVE_SERVICES_RESOURCE_NAME")
+  };
+  if (info.npm !== "@ai-sdk/openai-compatible" || info.api)
+    return migrated;
+  return {
+    ...migrated,
+    settings: {
+      ...migrated.settings,
+      baseURL: "https://${AZURE_COGNITIVE_SERVICES_RESOURCE_NAME}.cognitiveservices.azure.com/openai"
+    }
+  };
+}
+function migrateGoogleVertexAnthropicProvider(info) {
+  const migrated = migrateStandardProvider(info);
+  const packageName = migrated.package ?? aisdk2("@ai-sdk/google-vertex/anthropic");
+  return {
+    ...migrated,
+    package: undefined,
+    models: migrated.models && Object.fromEntries(Object.entries(migrated.models).map(([name, model]) => [
+      name,
+      model.package ? model : { ...model, package: packageName }
+    ]))
+  };
+}
+function providerID2(input) {
+  if (input === "azure-cognitive-services")
+    return "azure";
+  if (input === "google-vertex-anthropic")
+    return "google-vertex";
+  return input;
+}
+function migrateModel(info) {
+  const settings = info.options && model2(info.options);
+  const costs = info.cost && [
+    {
+      input: info.cost.input,
+      output: info.cost.output,
+      cache: { read: info.cost.cache_read, write: info.cost.cache_write }
+    },
+    ...info.cost.context_over_200k ? [
+      {
+        tier: { type: "context", size: 200000 },
+        input: info.cost.context_over_200k.input,
+        output: info.cost.context_over_200k.output,
+        cache: { read: info.cost.context_over_200k.cache_read, write: info.cost.context_over_200k.cache_write }
+      }
+    ] : []
+  ];
+  const defaults = Capabilities2.default();
+  const capabilities = info.tool_call !== undefined || info.modalities?.input !== undefined || info.modalities?.output !== undefined ? {
+    tools: info.tool_call ?? defaults.tools,
+    input: info.modalities?.input ?? defaults.input,
+    output: info.modalities?.output ?? defaults.output
+  } : undefined;
+  return {
+    modelID: info.id,
+    family: info.family,
+    name: info.name,
+    compatibility: compatibility2(info.interleaved),
+    package: info.provider?.npm ? aisdk2(info.provider.npm) : undefined,
+    settings: info.provider?.api ? { ...settings, baseURL: info.provider.api } : settings,
+    capabilities,
+    headers: info.headers,
+    variants: info.variants && Object.entries(info.variants).map(([id, options]) => ({
+      id,
+      settings: model2(options)
+    })),
+    cost: costs,
+    disabled: info.status === "deprecated" ? true : undefined,
+    limit: info.limit && {
+      context: int(info.limit.context),
+      input: info.limit.input === undefined ? undefined : int(info.limit.input),
+      output: int(info.limit.output)
+    }
+  };
+}
+function int(value) {
+  return Math.max(Number.MIN_SAFE_INTEGER, Math.min(Number.MAX_SAFE_INTEGER, Math.trunc(value)));
+}
+
+export { migrate2, normalizeAction2, migrateAgent2, commands2, migrateMcp2, migrateProvider2, providerID2, exports_migrate };

package/dist/chunks/worktree-4y7fprxs.js

@@ -0,0 +1,22 @@
+// src/github-copilot/responses/tool/image-generation.ts
+import { z } from "zod/v4";
+var imageGenerationArgsSchema2 = z.object({
+  background: z.enum(["auto", "opaque", "transparent"]).optional(),
+  inputFidelity: z.enum(["low", "high"]).optional(),
+  inputImageMask: z.object({
+    fileId: z.string().optional(),
+    imageUrl: z.string().optional()
+  }).optional(),
+  model: z.string().optional(),
+  moderation: z.enum(["auto"]).optional(),
+  outputCompression: z.number().int().min(0).max(100).optional(),
+  outputFormat: z.enum(["png", "jpeg", "webp"]).optional(),
+  partialImages: z.number().int().min(0).max(3).optional(),
+  quality: z.enum(["auto", "low", "medium", "high"]).optional(),
+  size: z.enum(["1024x1024", "1024x1536", "1536x1024", "auto"]).optional()
+}).strict();
+var imageGenerationOutputSchema2 = z.object({
+  result: z.string()
+});
+
+export { imageGenerationArgsSchema2, imageGenerationOutputSchema2 };

package/dist/chunks/worktree-4zbdsexc.js

@@ -0,0 +1,113 @@
+import {
+  useragent2
+} from "./worktree-xrd4famk.js";
+import {
+  ID12,
+  isAISDK2
+} from "./worktree-9qn3qky1.js";
+import {
+  iife2
+} from "./worktree-1kg9ymc8.js";
+import {
+  configuredSettings2
+} from "./worktree-asseqh46.js";
+
+// src/plugin/provider/cloudflare-workers-ai.ts
+import os from "os";
+import { Effect } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+import { Form } from "@opencode/schema/form";
+var providerID = ID12.make("cloudflare-workers-ai");
+var CloudflareWorkersAIPlugin2 = define({
+  id: "opencode.provider.cloudflare.workers.ai",
+  effect: Effect.fn(function* (ctx) {
+    const configured = yield* configuredSettings2(providerID);
+    const form = iife2(() => {
+      if (typeof configured?.baseURL === "string" || resolveAccountId(configured ?? {}))
+        return;
+      return Form.Fields.make([
+        {
+          type: "string",
+          key: "accountId",
+          title: "Enter your Cloudflare Account ID",
+          placeholder: "e.g. 1234567890abcdef1234567890abcdef",
+          required: true
+        }
+      ]);
+    });
+    yield* ctx.integration.transform((editor) => {
+      editor.method.update({
+        integrationID: providerID,
+        method: {
+          type: "key",
+          label: "API key",
+          form
+        }
+      });
+    });
+    yield* ctx.catalog.transform((evt) => {
+      const item = evt.provider.get(providerID);
+      if (!item)
+        return;
+      evt.provider.update(item.provider.id, (provider) => {
+        if (!isAISDK2(provider.package))
+          return;
+        if (typeof provider.settings?.baseURL === "string")
+          return;
+        const accountId = resolveAccountId(provider.settings ?? {});
+        if (accountId)
+          provider.settings = { ...provider.settings, baseURL: workersEndpoint(accountId) };
+      });
+    });
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== providerID)
+        return;
+      if (evt.package !== "@ai-sdk/openai-compatible")
+        return;
+      const accountId = resolveAccountId(evt.options);
+      if (!hasWorkersEndpoint(evt.model) && !accountId)
+        return;
+      const mod = yield* Effect.promise(() => import("@ai-sdk/openai-compatible"));
+      evt.sdk = mod.createOpenAICompatible(sdkOptions({
+        ...evt.options,
+        baseURL: evt.options.baseURL ?? (accountId ? workersEndpoint(accountId) : undefined)
+      }, ctx.app));
+    }));
+    yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== providerID)
+        return;
+      evt.language = evt.sdk.languageModel(evt.model.modelID ?? evt.model.id);
+    }));
+  })
+});
+function resolveAccountId(options) {
+  return process.env.CLOUDFLARE_ACCOUNT_ID ?? stringOption(options, "accountId");
+}
+function workersEndpoint(accountId) {
+  return `https://api.cloudflare.com/client/v4/accounts/${accountId}/ai/v1`;
+}
+function hasWorkersEndpoint(model) {
+  return isAISDK2(model.package) && typeof model.settings?.baseURL === "string";
+}
+function sdkOptions(options, app) {
+  return {
+    ...options,
+    baseURL: expandAccountId(options.baseURL),
+    apiKey: process.env.CLOUDFLARE_API_KEY ?? options.apiKey,
+    headers: {
+      "User-Agent": `${useragent2(app)} cloudflare-workers-ai (${os.platform()} ${os.release()}; ${os.arch()})`,
+      ...options.headers
+    },
+    name: providerID
+  };
+}
+function expandAccountId(baseURL) {
+  if (typeof baseURL !== "string")
+    return baseURL;
+  return baseURL.replaceAll("${CLOUDFLARE_ACCOUNT_ID}", process.env.CLOUDFLARE_ACCOUNT_ID ?? "${CLOUDFLARE_ACCOUNT_ID}");
+}
+function stringOption(options, key) {
+  return typeof options[key] === "string" ? options[key] : undefined;
+}
+
+export { CloudflareWorkersAIPlugin2 };