@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-33f8ypwy.js

@@ -0,0 +1,231 @@
+import {
+  Service79
+} from "./aisdk-native-11nvngjf.js";
+import {
+  Service58
+} from "./aisdk-native-1xqm2dzv.js";
+import {
+  group2,
+  batch2,
+  shutdown2,
+  inherit2
+} from "./aisdk-native-kg06axw8.js";
+import {
+  Service27,
+  awaitActivation2
+} from "./aisdk-native-1x11rq2a.js";
+import {
+  make11,
+  requirements3,
+  storage2
+} from "./aisdk-native-62zc03d1.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/plugin.ts
+var exports_plugin2 = {};
+__export(exports_plugin2, {
+  Event: () => Event4,
+  ID: () => ID3,
+  Info: () => Info3,
+  Plugin: () => exports_plugin2,
+  Service: () => Service27,
+  Source: () => Source2,
+  State: () => State2,
+  awaitActivation: () => awaitActivation2,
+  node: () => node22
+});
+import { Event as Event4, ID as ID3, Info as Info3, Source as Source2, State as State2 } from "@opencode/schema/plugin";
+import { Plugin } from "@opencode/schema/plugin";
+import { Node } from "@opencode/util/effect/app-node";
+import { Cause, Context, Effect, Exit, Latch, Layer, Logger, Queue, References, Scope, Semaphore } from "effect";
+var layer = Layer.effect(Service27, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const kv = yield* Service58;
+  const scope = yield* Scope.make();
+  const active = new Map;
+  const lock = Semaphore.makeUnsafe(1);
+  const ready = yield* Latch.make(true);
+  const pending = new Set;
+  let closed = false;
+  const holdUnsafe = () => {
+    if (closed)
+      return Effect.void;
+    const token = {};
+    pending.add(token);
+    ready.closeUnsafe();
+    return Effect.sync(() => {
+      if (pending.delete(token) && pending.size === 0)
+        ready.openUnsafe();
+    });
+  };
+  const hold = () => Effect.sync(holdUnsafe);
+  const pendingFailures = yield* Queue.unbounded();
+  let discovered = [];
+  let inventory = [];
+  const list = Effect.fn("Plugin.list")(function* () {
+    return inventory;
+  });
+  const host = yield* make11({ list });
+  const load = Effect.fnUntraced(function* (plugin) {
+    const activation = { plugin, scope: yield* Scope.fork(scope) };
+    const inherit = yield* inherit2();
+    const grouped = group2((failure, refresh) => {
+      activation.failure = {
+        error: `Plugin disabled after ${failure.state}.transform failed. Check server logs for details.`,
+        ref: `err_${crypto.randomUUID().slice(0, 8)}`
+      };
+      Queue.offerUnsafe(pendingFailures, {
+        plugin,
+        scope: activation.scope,
+        failure,
+        refresh,
+        ref: activation.failure.ref,
+        release: holdUnsafe()
+      });
+    });
+    const exit = yield* Effect.suspend(() => plugin.effect({ ...host, storage: storage2(kv, plugin.id) })).pipe(grouped, inherit, Effect.updateContext((context) => Context.make(Scope.Scope, activation.scope).pipe(Context.add(Logger.CurrentLoggers, Context.get(context, Logger.CurrentLoggers)), Context.add(References.MinimumLogLevel, Context.get(context, References.MinimumLogLevel)))), Effect.withSpan("Plugin.load", { attributes: { "plugin.id": plugin.id } }), Effect.onExit((exit) => Exit.isFailure(exit) && !activation.failure ? Scope.close(activation.scope, exit) : Effect.void), Effect.exit);
+    if (activation.failure || Exit.isSuccess(exit))
+      return { activation };
+    yield* Effect.logWarning("failed to load plugin", {
+      "plugin.id": plugin.id,
+      cause: exit.cause
+    });
+    return { error: Cause.pretty(exit.cause) };
+  });
+  const activate = Effect.fn("Plugin.activate")(function* (plugins, failures = []) {
+    const definitions = plugins.map((plugin) => ({ ...plugin, id: Plugin.ID.make(plugin.id) }));
+    const ids = new Set;
+    for (const definition of definitions) {
+      if (ids.has(definition.id))
+        yield* Effect.die(new Error(`Duplicate plugin ID: ${definition.id}`));
+      ids.add(definition.id);
+    }
+    yield* Effect.acquireUseRelease(hold(), () => lock.withPermit(Effect.gen(function* () {
+      if (closed)
+        return;
+      discovered = failures;
+      const current = Array.from(active.values());
+      const changed = definitions.findIndex((definition, index) => {
+        const entry = current[index];
+        return entry?.plugin.id !== definition.id || entry.plugin.revision !== definition.revision;
+      });
+      const prefix = changed === -1 ? definitions.length : changed;
+      for (const definition of definitions.slice(0, prefix)) {
+        const entry = active.get(definition.id);
+        if (entry)
+          active.set(definition.id, { ...entry, plugin: definition });
+      }
+      if (prefix === definitions.length && active.size === definitions.length) {
+        const nextInventory = [...Array.from(active.values()).map(slotInfo), ...failures];
+        if (JSON.stringify(inventory) === JSON.stringify(nextInventory))
+          return;
+        inventory = nextInventory;
+        yield* bus.publish(Plugin.Event.Updated, {});
+        return;
+      }
+      yield* batch2(Effect.gen(function* () {
+        const previous = new Map(Array.from(active.entries()).slice(prefix));
+        yield* Effect.forEach(Array.from(previous.entries()).toReversed(), ([id, slot]) => Effect.gen(function* () {
+          active.delete(id);
+          if (slot.activation && !slot.activation.failure)
+            yield* Scope.close(slot.activation.scope, Exit.void);
+        }), { discard: true });
+        for (const definition of definitions.slice(prefix)) {
+          const slot = previous.get(definition.id);
+          if (slot?.activation?.failure && slot.plugin.revision === definition.revision) {
+            active.set(definition.id, { ...slot, plugin: definition });
+            continue;
+          }
+          const result = yield* load(definition);
+          if (result.activation !== undefined) {
+            active.set(definition.id, {
+              plugin: definition,
+              activation: result.activation
+            });
+            continue;
+          }
+          active.set(definition.id, { plugin: definition, error: result.error });
+          const fallback = slot?.activation;
+          if (!fallback || fallback.failure)
+            continue;
+          const restored = yield* load(fallback.plugin);
+          if (restored.activation !== undefined) {
+            active.set(definition.id, {
+              plugin: definition,
+              activation: restored.activation,
+              error: result.error
+            });
+            continue;
+          }
+          yield* Effect.logError("failed to restore plugin; deactivating", {
+            "plugin.id": definition.id
+          });
+        }
+        inventory = [...Array.from(active.values()).map(slotInfo), ...failures];
+      }));
+      yield* bus.publish(Plugin.Event.Updated, {});
+    })), (release) => release);
+  });
+  yield* Queue.take(pendingFailures).pipe(Effect.flatMap((item) => Effect.gen(function* () {
+    yield* Effect.logWarning("disabled plugin after transform failure", {
+      "plugin.id": item.plugin.id,
+      state: item.failure.state,
+      ref: item.ref,
+      cause: Cause.die(item.failure.cause)
+    });
+    yield* lock.withPermit(Effect.gen(function* () {
+      if (closed)
+        return;
+      inventory = [...Array.from(active.values()).map(slotInfo), ...discovered];
+      const refreshed = yield* batch2(item.refresh).pipe(Effect.exit);
+      yield* bus.publish(Plugin.Event.Updated, {});
+      if (Exit.isFailure(refreshed))
+        yield* Effect.logWarning("failed to refresh state after disabling plugin", {
+          "plugin.id": item.plugin.id,
+          ref: item.ref,
+          cause: refreshed.cause
+        });
+    }));
+  }).pipe(Effect.ensuring(Scope.close(item.scope, Exit.void).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to clean up disabled plugin", {
+    "plugin.id": item.plugin.id,
+    ref: item.ref,
+    cause
+  })), Effect.forkScoped({ startImmediately: true }))), Effect.catchCauseIf((cause) => !Cause.hasInterrupts(cause), (cause) => Effect.logError("failed to report disabled plugin", {
+    "plugin.id": item.plugin.id,
+    ref: item.ref,
+    cause
+  })), Effect.ensuring(item.release))), Effect.forever, Effect.forkScoped);
+  const close = (exit) => lock.withPermit(Effect.gen(function* () {
+    closed = true;
+    pending.clear();
+    ready.openUnsafe();
+    active.clear();
+    yield* shutdown2(Scope.close(scope, exit));
+  }));
+  yield* Effect.addFinalizer(close);
+  return Service27.of({
+    activate,
+    close,
+    awaitActivation: ready.await,
+    hold,
+    list
+  });
+}));
+function slotInfo(slot) {
+  const failure = slot.activation?.failure ?? (slot.error === undefined ? undefined : { error: slot.error });
+  return {
+    id: Plugin.ID.make(slot.plugin.id),
+    source: slot.plugin.source ?? { type: "builtin" },
+    state: failure === undefined ? { status: "active" } : { status: "failed", ...failure },
+    features: { server: true, ...slot.plugin.features }
+  };
+}
+var node22 = Node.makeLocationNode({
+  service: Service27,
+  layer,
+  deps: [requirements3]
+});
+
+export { node22, exports_plugin2, Event4, ID3, Info3, Source2, State2 };

package/dist/chunks/aisdk-native-33n3bzdy.js

@@ -0,0 +1,169 @@
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/provider.ts
+var exports_provider3 = {};
+__export(exports_provider3, {
+  AISDK_PREFIX: () => AISDK_PREFIX2,
+  ID: () => ID18,
+  Info: () => Info33,
+  LoadError: () => LoadError3,
+  Provider: () => exports_provider3,
+  Request: () => Request3,
+  Settings: () => Settings2,
+  aisdk: () => aisdk2,
+  isAISDK: () => isAISDK2,
+  loadPackage: () => loadPackage2,
+  mergeHeaders: () => mergeHeaders2,
+  mergeOverlay: () => mergeOverlay2,
+  nativeSettings: () => nativeSettings2,
+  packageName: () => packageName2
+});
+import { Effect, Schema, Struct } from "effect";
+import { Provider } from "@opencode/schema/provider";
+import { isRecord } from "@opencode/ai/utils/record";
+import { importModule, resolveModule } from "@opencode/util/runtime-import";
+var ID18 = Provider.ID;
+var AISDK_PREFIX2 = "aisdk:";
+var isAISDK2 = (value) => value?.startsWith(AISDK_PREFIX2) ?? false;
+var aisdk2 = (value) => isAISDK2(value) ? value : `${AISDK_PREFIX2}${value}`;
+function packageName2(value) {
+  if (value?.startsWith("@opencode-ai/ai/"))
+    return value.replace("@opencode-ai/", "@opencode/");
+  if (value === undefined || !isAISDK2(value))
+    return value;
+  return value.slice(AISDK_PREFIX2.length);
+}
+var JsonRecord = Schema.Record(Schema.String, Schema.Json);
+var decodeJsonRecord = Schema.decodeUnknownSync(JsonRecord);
+
+class LoadError3 extends Schema.TaggedError()("Provider.LoadError", {
+  package: Schema.String,
+  cause: Schema.Defect()
+}) {
+}
+var packages = new Map;
+var builtins = new Map([
+  ["@opencode/ai/providers/amazon-bedrock", () => import("@opencode/ai/providers/amazon-bedrock")],
+  ["@opencode/ai/providers/amazon-bedrock/mantle", () => import("@opencode/ai/providers/amazon-bedrock/mantle")],
+  [
+    "@opencode/ai/providers/amazon-bedrock/mantle/chat",
+    () => import("@opencode/ai/providers/amazon-bedrock/mantle/chat")
+  ],
+  [
+    "@opencode/ai/providers/amazon-bedrock/mantle/responses",
+    () => import("@opencode/ai/providers/amazon-bedrock/mantle/responses")
+  ],
+  ["@opencode/ai/providers/anthropic", () => import("@opencode/ai/providers/anthropic")],
+  ["@opencode/ai/providers/azure", () => import("@opencode/ai/providers/azure")],
+  ["@opencode/ai/providers/azure/chat", () => import("@opencode/ai/providers/azure/chat")],
+  ["@opencode/ai/providers/azure/responses", () => import("@opencode/ai/providers/azure/responses")],
+  ["@opencode/ai/providers/baseten", () => import("@opencode/ai/providers/baseten")],
+  ["@opencode/ai/providers/cerebras", () => import("@opencode/ai/providers/cerebras")],
+  ["@opencode/ai/providers/cloudflare-ai-gateway", () => import("@opencode/ai/providers/cloudflare-ai-gateway")],
+  ["@opencode/ai/providers/cloudflare-workers-ai", () => import("@opencode/ai/providers/cloudflare-workers-ai")],
+  ["@opencode/ai/providers/deepinfra", () => import("@opencode/ai/providers/deepinfra")],
+  ["@opencode/ai/providers/deepseek", () => import("@opencode/ai/providers/deepseek")],
+  ["@opencode/ai/providers/fireworks", () => import("@opencode/ai/providers/fireworks")],
+  ["@opencode/ai/providers/google", () => import("@opencode/ai/providers/google")],
+  ["@opencode/ai/providers/google-vertex", () => import("@opencode/ai/providers/google-vertex")],
+  ["@opencode/ai/providers/google-vertex/gemini", () => import("@opencode/ai/providers/google-vertex/gemini")],
+  ["@opencode/ai/providers/google-vertex/chat", () => import("@opencode/ai/providers/google-vertex/chat")],
+  ["@opencode/ai/providers/google-vertex/responses", () => import("@opencode/ai/providers/google-vertex/responses")],
+  ["@opencode/ai/providers/google-vertex/messages", () => import("@opencode/ai/providers/google-vertex/messages")],
+  ["@opencode/ai/providers/groq", () => import("@opencode/ai/providers/groq")],
+  ["@opencode/ai/providers/mistral", () => import("@opencode/ai/providers/mistral")],
+  ["@opencode/ai/providers/openai", () => import("@opencode/ai/providers/openai")],
+  ["@opencode/ai/providers/openai/chat", () => import("@opencode/ai/providers/openai/chat")],
+  ["@opencode/ai/providers/openai/responses", () => import("@opencode/ai/providers/openai/responses")],
+  ["@opencode/ai/providers/openai-compatible", () => import("@opencode/ai/providers/openai-compatible")],
+  ["@opencode/ai/providers/openrouter", () => import("@opencode/ai/providers/openrouter")],
+  ["@opencode/ai/providers/togetherai", () => import("@opencode/ai/providers/togetherai")],
+  ["@opencode/ai/providers/xai", () => import("@opencode/ai/providers/xai")]
+]);
+var loadPackage2 = Effect.fn("Provider.loadPackage")(function* (input, npm) {
+  const specifier = packageName2(input);
+  const builtin = builtins.get(specifier);
+  if (builtin)
+    return yield* importPackage(specifier, specifier, builtin);
+  const resolved = yield* Effect.sync(() => {
+    if (specifier.startsWith("file://") || specifier.startsWith("@opencode/ai/"))
+      return specifier;
+    try {
+      return import.meta.resolve(specifier);
+    } catch {
+      return;
+    }
+  });
+  if (resolved)
+    return yield* importPackage(specifier, resolved);
+  if (!npm) {
+    return yield* new LoadError3({
+      package: specifier,
+      cause: new Error(`Provider package ${specifier} is not installed`)
+    });
+  }
+  const parts = specifier.split("/");
+  const root = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0] ?? specifier;
+  const installed = yield* npm.add(root).pipe(Effect.mapError((cause) => new LoadError3({ package: specifier, cause })));
+  const entrypoint = yield* Effect.try({
+    try: () => resolveModule(specifier, installed.directory),
+    catch: (cause) => new LoadError3({ package: specifier, cause })
+  });
+  return yield* importPackage(specifier, entrypoint);
+});
+var TRANSPORT_KEYS = ["chunkTimeout", "fetch", "timeout"];
+function nativeSettings2(settings) {
+  return Struct.omit(settings, TRANSPORT_KEYS);
+}
+function mergeOverlay2(base, overlay) {
+  if (base === undefined)
+    return overlay && decodeJsonRecord({ ...overlay });
+  if (overlay === undefined)
+    return decodeJsonRecord({ ...base });
+  return decodeJsonRecord(Object.fromEntries(new Set([...Object.keys(base), ...Object.keys(overlay)]).values().map((key) => {
+    const left = base[key];
+    const right = overlay[key];
+    if (right === undefined)
+      return [key, left];
+    if (isRecord(left) && isRecord(right))
+      return [key, mergeOverlay2(left, right) ?? {}];
+    return [key, right];
+  })));
+}
+function mergeHeaders2(base, overlay) {
+  if (base === undefined)
+    return overlay && { ...overlay };
+  if (overlay === undefined)
+    return { ...base };
+  return Object.fromEntries([...Object.entries(base), ...Object.entries(overlay)].reduce((result, entry) => {
+    result.set(entry[0].toLowerCase(), entry);
+    return result;
+  }, new Map).values());
+}
+var Request3 = Provider.Request;
+var Settings2 = Provider.Settings;
+var Info33 = Provider.Info;
+var importPackage = Effect.fn("Provider.importPackage")(function* (specifier, entrypoint, load = () => importModule(entrypoint)) {
+  const module = yield* Effect.tryPromise({
+    try: () => {
+      const existing = packages.get(entrypoint);
+      if (existing)
+        return existing;
+      const loaded = load();
+      packages.set(entrypoint, loaded);
+      return loaded;
+    },
+    catch: (cause) => new LoadError3({ package: specifier, cause })
+  });
+  if (typeof module !== "object" || module === null || typeof module.model !== "function") {
+    return yield* new LoadError3({
+      package: specifier,
+      cause: new Error(`Provider package ${specifier} does not export model(modelID, settings)`)
+    });
+  }
+  return module;
+});
+
+export { ID18, AISDK_PREFIX2, isAISDK2, aisdk2, packageName2, LoadError3, loadPackage2, nativeSettings2, mergeOverlay2, mergeHeaders2, Request3, Settings2, Info33, exports_provider3 };

package/dist/chunks/aisdk-native-359p4xyc.js

@@ -0,0 +1,25 @@
+// src/database/migration/20260823191254_nullable_workspace_binding.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260823191254_nullable_workspace_binding",
+  foreignKeys: false,
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`__new_workspace\` (
+          \`id\` text PRIMARY KEY,
+          \`provider\` text NOT NULL,
+          \`binding\` text,
+          \`created_at\` integer NOT NULL,
+          \`last_used_at\` integer NOT NULL
+        );
+      `);
+      yield* tx.run(`INSERT INTO \`__new_workspace\`(\`id\`, \`provider\`, \`binding\`, \`created_at\`, \`last_used_at\`) SELECT \`id\`, \`provider\`, \`binding\`, \`created_at\`, \`last_used_at\` FROM \`workspace\`;`);
+      yield* tx.run(`DROP TABLE \`workspace\`;`);
+      yield* tx.run(`ALTER TABLE \`__new_workspace\` RENAME TO \`workspace\`;`);
+    });
+  }
+};
+var _20260823191254_nullable_workspace_binding_default = migration;
+
+export { _20260823191254_nullable_workspace_binding_default };

package/dist/chunks/aisdk-native-35wynegs.js

@@ -0,0 +1,170 @@
+import {
+  mergeOverlay2,
+  mergeHeaders2
+} from "./aisdk-native-33n3bzdy.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/aisdk-native.ts
+var exports_aisdk_native = {};
+__export(exports_aisdk_native, {
+  AISDKNative: () => exports_aisdk_native,
+  map: () => map2
+});
+import { Effect, Option, Schema, Struct } from "effect";
+var lenient = (schema) => Schema.optional(Schema.UndefinedOr(schema).pipe(Schema.catchDecoding(() => Effect.succeed(Option.some(undefined)))));
+var Credentials = Schema.Struct({
+  accessKeyId: Schema.String,
+  secretAccessKey: Schema.String,
+  sessionToken: lenient(Schema.String),
+  region: lenient(Schema.String)
+});
+var Legacy = Schema.StructWithRest(Schema.Struct({
+  apiKey: lenient(Schema.String),
+  baseURL: lenient(Schema.String),
+  headers: lenient(Schema.Record(Schema.String, Schema.String)),
+  extraBody: lenient(Schema.Record(Schema.String, Schema.Unknown)),
+  useCompletionUrls: lenient(Schema.Boolean),
+  auth: lenient(Schema.Literals(["bearer", "sigv4"])),
+  bearerToken: lenient(Schema.String),
+  endpoint: lenient(Schema.String),
+  region: lenient(Schema.String),
+  credentials: lenient(Credentials),
+  accessKeyId: lenient(Schema.String),
+  secretAccessKey: lenient(Schema.String),
+  sessionToken: lenient(Schema.String),
+  anthropicBeta: lenient(Schema.Array(Schema.String)),
+  serviceTier: lenient(Schema.String),
+  reasoningConfig: lenient(Schema.Struct({
+    type: lenient(Schema.String),
+    display: lenient(Schema.String),
+    maxReasoningEffort: lenient(Schema.String),
+    budgetTokens: lenient(Schema.Number)
+  })),
+  additionalModelRequestFields: lenient(Schema.StructWithRest(Schema.Struct({
+    anthropic_beta: lenient(Schema.Array(Schema.String)),
+    output_config: lenient(Schema.Record(Schema.String, Schema.Unknown)),
+    reasoning: lenient(Schema.Record(Schema.String, Schema.Unknown))
+  }), [Schema.Record(Schema.String, Schema.Unknown)])),
+  appName: lenient(Schema.String),
+  appUrl: lenient(Schema.String),
+  api_keys: lenient(Schema.Record(Schema.String, Schema.String))
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+var decode = Schema.decodeUnknownSync(Legacy);
+function map2(input) {
+  const settings = decode(input.settings);
+  const native = mapPackage(input.packageName, input.modelID, settings);
+  if (!native)
+    return;
+  const converse = native === "@opencode/ai/providers/amazon-bedrock";
+  const mapped = {
+    ...Struct.omit(settings, ["headers", "extraBody", "useCompletionUrls", ...OPENROUTER_KEYS]),
+    ...native === "@opencode/ai/providers/openai-compatible" ? { provider: input.providerID } : {}
+  };
+  return {
+    package: native,
+    settings: native.startsWith("@opencode/ai/providers/amazon-bedrock") ? bedrockSettings(mapped, converse) : mapped,
+    ...settings.headers === undefined ? {} : { headers: settings.headers },
+    ...settings.extraBody === undefined ? {} : { body: settings.extraBody },
+    ...converse ? bedrockRequest(input.modelID, settings) : {},
+    ...native === "@opencode/ai/providers/openrouter" ? openRouterRequest(settings) : {}
+  };
+}
+function mapPackage(packageName, modelID, settings) {
+  switch (packageName) {
+    case "@ai-sdk/anthropic":
+    case "@ai-sdk/cerebras":
+    case "@ai-sdk/deepinfra":
+    case "@ai-sdk/google":
+    case "@ai-sdk/google-vertex":
+    case "@ai-sdk/groq":
+    case "@ai-sdk/mistral":
+    case "@ai-sdk/openai":
+    case "@ai-sdk/togetherai":
+    case "@ai-sdk/xai":
+    case "@ai-sdk/amazon-bedrock":
+      return `@opencode/ai/providers/${packageName.slice("@ai-sdk/".length)}`;
+    case "@ai-sdk/amazon-bedrock/mantle":
+      return `@opencode/ai/providers/amazon-bedrock/mantle/${modelID.includes("gpt-oss") ? "chat" : "responses"}`;
+    case "@ai-sdk/azure":
+      return `@opencode/ai/providers/azure/${settings.useCompletionUrls === true ? "chat" : "responses"}`;
+    case "@ai-sdk/google-vertex/anthropic":
+      return "@opencode/ai/providers/google-vertex/messages";
+    case "@ai-sdk/openai-compatible":
+      return settings.baseURL === undefined ? undefined : "@opencode/ai/providers/openai-compatible";
+    case "@openrouter/ai-sdk-provider":
+      return "@opencode/ai/providers/openrouter";
+  }
+}
+var BEDROCK_KEYS = [
+  "bearerToken",
+  "endpoint",
+  "credentials",
+  "credentialProvider",
+  "accessKeyId",
+  "secretAccessKey",
+  "sessionToken"
+];
+var CONVERSE_KEYS = ["additionalModelRequestFields", "reasoningConfig", "anthropicBeta", "serviceTier"];
+function bedrockSettings(settings, converse) {
+  const region = settings.region ?? settings.credentials?.region;
+  const credentials = settings.credentials ?? settings;
+  const baseURL = settings.baseURL ?? settings.endpoint;
+  return {
+    ...Struct.omit(settings, converse ? [...BEDROCK_KEYS, ...CONVERSE_KEYS] : BEDROCK_KEYS),
+    ...baseURL === undefined ? {} : { baseURL: region === undefined ? baseURL : baseURL.replaceAll("${AWS_REGION}", region) },
+    ...settings.apiKey === undefined && settings.bearerToken !== undefined ? { apiKey: settings.bearerToken } : {},
+    ...region === undefined || credentials.accessKeyId === undefined || credentials.secretAccessKey === undefined ? {} : {
+      credentials: {
+        region,
+        accessKeyId: credentials.accessKeyId,
+        secretAccessKey: credentials.secretAccessKey,
+        ...credentials.sessionToken === undefined ? {} : { sessionToken: credentials.sessionToken }
+      }
+    }
+  };
+}
+function bedrockRequest(modelID, settings) {
+  const additional = settings.additionalModelRequestFields ?? {};
+  const reasoning = settings.reasoningConfig;
+  const anthropic = modelID.includes("anthropic");
+  const openai = modelID.includes("openai.");
+  const harmony = modelID.includes("openai.gpt-oss");
+  const effort = reasoning?.maxReasoningEffort;
+  const type = reasoning?.type;
+  const budget = reasoning?.budgetTokens;
+  const display = reasoning?.display;
+  const betas = settings.anthropicBeta ?? [];
+  const fields = mergeOverlay2(additional, {
+    ...betas.length > 0 ? { anthropic_beta: [...additional.anthropic_beta ?? [], ...betas] } : {},
+    ...anthropic && type === "enabled" && budget !== undefined ? { thinking: { type: "enabled", budget_tokens: budget } } : {},
+    ...anthropic && type === "adaptive" ? { thinking: { type: "adaptive", ...display === undefined ? {} : { display } } } : {},
+    ...anthropic && effort !== undefined ? { output_config: { ...additional.output_config, effort } } : {},
+    ...!anthropic && openai && harmony && effort !== undefined ? { reasoning_effort: effort } : {},
+    ...!anthropic && openai && !harmony && effort !== undefined ? { reasoning: { ...additional.reasoning, effort } } : {},
+    ...!anthropic && !openai && effort !== undefined ? {
+      reasoningConfig: {
+        ...type === undefined || type === "adaptive" ? {} : { type },
+        ...budget === undefined ? {} : { budgetTokens: budget },
+        maxReasoningEffort: effort
+      }
+    } : {}
+  });
+  const body = {
+    ...fields && Object.keys(fields).length > 0 ? { additionalModelRequestFields: fields } : {},
+    ...settings.serviceTier === undefined ? {} : { serviceTier: { type: settings.serviceTier } }
+  };
+  return Object.keys(body).length === 0 ? {} : { body };
+}
+var OPENROUTER_KEYS = ["appName", "appUrl", "api_keys", "compatibility"];
+function openRouterRequest(settings) {
+  const headers = mergeHeaders2({
+    ...settings.appName === undefined ? {} : { "X-OpenRouter-Title": settings.appName },
+    ...settings.appUrl === undefined ? {} : { "HTTP-Referer": settings.appUrl },
+    ...settings.api_keys === undefined || Object.keys(settings.api_keys).length === 0 ? {} : { "X-Provider-API-Keys": JSON.stringify(settings.api_keys) }
+  }, settings.headers) ?? {};
+  return Object.keys(headers).length === 0 ? {} : { headers };
+}
+
+export { map2, exports_aisdk_native };

package/dist/chunks/aisdk-native-361ty1x8.js

@@ -0,0 +1,42 @@
+import {
+  jitCompatCheck2
+} from "./aisdk-native-emrn6kk6.js";
+import {
+  SQLiteEffectDatabase2
+} from "./aisdk-native-ch22x6z2.js";
+import {
+  EffectSQLiteSession2
+} from "./aisdk-native-mb3974r6.js";
+
+// src/database/drizzle/effect-sqlite/driver.ts
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+import { EffectCache } from "drizzle-orm/cache/core/cache-effect";
+import { EffectLogger } from "drizzle-orm/effect-core";
+import { entityKind } from "drizzle-orm/entity";
+import { SQLiteDialect } from "drizzle-orm/sqlite-core/dialect";
+class EffectSQLiteDatabase2 extends SQLiteEffectDatabase2 {
+  static [entityKind] = "EffectSQLiteDatabase";
+}
+var DefaultServices2 = Layer.merge(EffectCache.Default, EffectLogger.Default);
+var make23 = Effect.fn("SQLiteDrizzle.make")(function* (config = {}) {
+  const client = yield* SqlClient;
+  const cache = yield* EffectCache;
+  const logger = yield* EffectLogger;
+  const useJitMappers = jitCompatCheck2(config.jit);
+  const dialect = new SQLiteDialect({ useJitMappers });
+  const relations = config.relations ?? {};
+  const session = new EffectSQLiteSession2(client, dialect, relations, {
+    logger,
+    cache,
+    useJitMappers
+  });
+  const db = new EffectSQLiteDatabase2(dialect, session, relations);
+  db.$client = client;
+  db.$cache.invalidate = cache.onMutate;
+  return db;
+});
+var makeWithDefaults2 = (config = {}) => make23(config).pipe(Effect.provide(DefaultServices2));
+
+export { EffectSQLiteDatabase2, DefaultServices2, make23, makeWithDefaults2 };