@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-3mfgaav1.js

@@ -0,0 +1,321 @@
+import {
+  exports_provider_options
+} from "./ripgrep-y0x38cee.js";
+import {
+  exports_model
+} from "./ripgrep-xfd1xnk3.js";
+import {
+  exports_provider
+} from "./ripgrep-d6vvk673.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/v1/config/migrate.ts
+var exports_migrate = {};
+__export(exports_migrate, {
+  providerID: () => providerID,
+  normalizeAction: () => normalizeAction,
+  migrateProvider: () => migrateProvider,
+  migrateMcp: () => migrateMcp,
+  migrateAgent: () => migrateAgent,
+  migrate: () => migrate,
+  commands: () => commands,
+  ConfigMigrateV1: () => exports_migrate
+});
+import { Info } from "@opencode-ai/schema/config";
+import { ConfigAgent } from "@opencode-ai/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 migrate(info) {
+  return encodeInfo(decodeInfo(JSON.stringify({
+    $schema: info.$schema,
+    shell: info.shell,
+    model: modelSelection(info.model),
+    default_agent: info.default_agent,
+    autoupdate: info.autoupdate,
+    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: commands(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: providerID(resource),
+        effect: "allow"
+      }))
+    ],
+    ...(info.disabled_providers ?? []).map((resource) => ({
+      action: "provider.use",
+      resource: providerID(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: normalizeAction(action),
+    resource: "*",
+    effect: enabled ? "allow" : "deny"
+  }));
+  for (const [key, rule] of Object.entries(info ?? {})) {
+    if (!rule)
+      continue;
+    const action = normalizeAction(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 normalizeAction(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, migrateAgent(agent)]] : []));
+  const small = modelSelection(info.small_model);
+  if (!small)
+    return entries.length ? result : undefined;
+  return {
+    ...result,
+    title: {
+      model: small,
+      ...result.title
+    }
+  };
+}
+function migrateAgent(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 commands(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),
+      subtask: command.subtask
+    }
+  ]));
+}
+function modelSelection(input, variant) {
+  if (input === undefined || !/^[^/#]+\/[^#]+$/.test(input))
+    return;
+  const separator = input.indexOf("/");
+  return {
+    providerID: providerID(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, migrateMcp(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 migrateMcp(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 = providerID(name);
+    if (id !== name && info[id])
+      return [];
+    return [[id, migrateProvider(name, provider)]];
+  }));
+}
+function migrateProvider(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 = exports_provider_options.provider(info.options ?? {});
+  return {
+    name: info.name,
+    env: info.env,
+    package: info.npm ? exports_provider.aisdk(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 ?? exports_provider.aisdk("@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 providerID(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 && exports_provider_options.model(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 capabilities = info.tool_call !== undefined || info.modalities?.input !== undefined || info.modalities?.output !== undefined ? { tools: info.tool_call ?? false, input: info.modalities?.input ?? [], output: info.modalities?.output ?? [] } : undefined;
+  return {
+    modelID: info.id,
+    family: info.family,
+    name: info.name,
+    compatibility: exports_model.compatibility(info.interleaved),
+    package: info.provider?.npm ? exports_provider.aisdk(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: exports_provider_options.model(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 { migrate, normalizeAction, migrateAgent, commands, migrateMcp, migrateProvider, providerID, exports_migrate };

package/dist/chunks/ripgrep-3q6gbwmd.js

@@ -0,0 +1,26 @@
+// src/plugin/provider/dynamic.ts
+import { Effect } from "effect";
+import { pathToFileURL } from "url";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Npm } from "@opencode-ai/util/npm";
+import { importModule } from "@opencode-ai/util/runtime-import";
+var DynamicProviderPlugin = define({
+  id: "opencode.provider.dynamic",
+  effect: Effect.fn(function* (ctx) {
+    const npm = yield* Npm.Service;
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.sdk)
+        return;
+      const installedPath = evt.package.startsWith("file://") ? evt.package : (yield* npm.add(evt.package).pipe(Effect.orDie)).entrypoint;
+      if (!installedPath)
+        throw new Error(`Package ${evt.package} has no import entrypoint`);
+      const mod = yield* Effect.promise(() => importModule(installedPath.startsWith("file://") ? installedPath : pathToFileURL(installedPath).href)).pipe(Effect.orDie);
+      const match = Object.keys(mod).find((name) => name.startsWith("create"));
+      if (!match)
+        throw new Error(`Package ${evt.package} has no provider factory export`);
+      evt.sdk = mod[match](evt.options);
+    }));
+  })
+});
+
+export { DynamicProviderPlugin };

package/dist/chunks/ripgrep-3thh6229.js

@@ -0,0 +1,18 @@
+import {
+  createProviderPlugin
+} from "./ripgrep-0zz82cjq.js";
+import {
+  __require
+} from "./ripgrep-rvfvac9x.js";
+
+// src/plugin/provider/mistral.ts
+var MistralPlugin = createProviderPlugin({
+  id: "opencode.provider.mistral",
+  package: "@ai-sdk/mistral",
+  load: async (options) => {
+    const { createMistral } = await import("@ai-sdk/mistral");
+    return createMistral(options);
+  }
+});
+
+export { MistralPlugin };

package/dist/chunks/ripgrep-3vh42rcr.js

@@ -0,0 +1,35 @@
+import {
+  exports_model
+} from "./ripgrep-xfd1xnk3.js";
+import {
+  exports_provider
+} from "./ripgrep-d6vvk673.js";
+
+// src/plugin/provider/openrouter.ts
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+var OpenRouterPlugin = define({
+  id: "opencode.provider.openrouter",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (!exports_provider.isAISDK(item.provider.package))
+          continue;
+        if (exports_provider.packageName(item.provider.package) !== "@openrouter/ai-sdk-provider")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = { ...provider.headers, "HTTP-Referer": "https://opencode.ai/", "X-Title": "opencode" };
+        });
+        for (const modelID of [exports_model.ID.make("gpt-5-chat-latest"), exports_model.ID.make("openai/gpt-5-chat")]) {
+          if (!item.models.has(modelID))
+            continue;
+          evt.model.update(item.provider.id, modelID, (model) => {
+            model.enabled = false;
+          });
+        }
+      }
+    });
+  })
+});
+
+export { OpenRouterPlugin };