@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-cvtmmhw6.js

@@ -0,0 +1,32 @@
+import {
+  isAISDK2,
+  packageName2
+} from "./aisdk-native-33n3bzdy.js";
+
+// src/plugin/provider/zenmux.ts
+import { Effect } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+var ZenmuxPlugin2 = define({
+  id: "opencode.provider.zenmux",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (!isAISDK2(item.provider.package))
+          continue;
+        if (packageName2(item.provider.package) !== "@ai-sdk/openai-compatible")
+          continue;
+        if (item.provider.settings?.baseURL !== "https://zenmux.ai/api/v1")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = {
+            "HTTP-Referer": "https://opencode.ai/",
+            "X-Title": "opencode",
+            ...provider.headers
+          };
+        });
+      }
+    });
+  })
+});
+
+export { ZenmuxPlugin2 };

package/dist/chunks/aisdk-native-cvy3z8tj.js

@@ -0,0 +1,15 @@
+// src/database/migration/20260622142730_simplify_session_context_epoch.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260622142730_simplify_session_context_epoch",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`session_context_epoch\` DROP COLUMN \`agent\`;`);
+      yield* tx.run(`ALTER TABLE \`session_context_epoch\` DROP COLUMN \`replacement_seq\`;`);
+      yield* tx.run(`ALTER TABLE \`session_context_epoch\` DROP COLUMN \`revision\`;`);
+    });
+  }
+};
+var _20260622142730_simplify_session_context_epoch_default = migration;
+
+export { _20260622142730_simplify_session_context_epoch_default };

package/dist/chunks/aisdk-native-cxvbe4d1.js

@@ -0,0 +1,170 @@
+import {
+  Service79,
+  node84
+} from "./aisdk-native-11nvngjf.js";
+import {
+  Service73,
+  node78
+} from "./aisdk-native-6fyvx278.js";
+import {
+  reconcile2,
+  create3
+} from "./aisdk-native-kg06axw8.js";
+import {
+  PATCH_CONTEXT_LINES2,
+  MAX_TOTAL_PATCH_BYTES2,
+  emptyPatch2
+} from "./aisdk-native-tazgh4e4.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/vcs.ts
+var exports_vcs = {};
+__export(exports_vcs, {
+  Base: () => Base2,
+  BranchList: () => BranchList2,
+  DiffError: () => DiffError2,
+  FileStatus: () => FileStatus2,
+  Info: () => Info28,
+  Mode: () => Mode2,
+  Service: () => Service69,
+  Vcs: () => exports_vcs,
+  node: () => node73
+});
+import path from "path";
+import { Cause, Context, Effect, FiberSet, Layer, Schema, Semaphore, Stream } from "effect";
+import { FileDiff } from "@opencode/schema/file-diff";
+import { FileSystem } from "@opencode/schema/filesystem";
+import { Base as Base2, BranchList as BranchList2, FileStatus as FileStatus2, Info as Info28, Mode as Mode2 } from "@opencode/schema/vcs";
+import { VcsEvent } from "@opencode/schema/vcs-event";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { FSUtil } from "@opencode/util/fs-util";
+class DiffError2 extends Schema.TaggedError()("Vcs.DiffError", {
+  message: Schema.String
+}) {
+}
+
+class Service69 extends Context.Service()("@opencode/Vcs") {
+}
+var layer = Layer.effect(Service69, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const location = yield* Service73;
+  const bus = yield* Service79;
+  const root = yield* Effect.scope;
+  const fork = yield* FiberSet.makeRuntime();
+  const vcs = location.vcs;
+  const current = { info: { branch: {} } };
+  const refreshLock = Semaphore.makeUnsafe(1);
+  const scope = {
+    directory: location.directory,
+    worktree: location.project.directory,
+    canonical: location.project.canonical,
+    ...vcs ? { store: vcs.store } : {}
+  };
+  const decodeInfo = Schema.decodeUnknownEffect(Schema.toType(Info28));
+  const decodeBase = Schema.decodeUnknownEffect(Schema.NullOr(Base2));
+  const decodeBranches = Schema.decodeUnknownEffect(BranchList2);
+  const decodeStatus = Schema.decodeUnknownEffect(Schema.Array(FileStatus2));
+  const decodeDiff = Schema.decodeUnknownEffect(Schema.Array(FileDiff.Info));
+  const state = create3({
+    name: "vcs",
+    initial: () => ({ providers: new Map }),
+    editor: (editor) => ({
+      add: (provider) => editor.providers.set(provider.id, provider),
+      default: {
+        get: () => editor.selection,
+        set: (selection) => editor.selection = selection
+      }
+    }),
+    notify: () => reconcile2(root, fork, () => refresh())
+  });
+  const selected = () => {
+    const value = state.get();
+    const id = value.selection ?? vcs?.type;
+    return id ? value.providers.get(id) : undefined;
+  };
+  const protect = (provider, operation, effect, fallback) => effect.pipe(Effect.catchCause((cause) => Cause.hasInterrupts(cause) ? Effect.failCause(cause).pipe(Effect.orDie) : Effect.logWarning("vcs provider failed", { provider: provider.id, operation, cause }).pipe(Effect.as(fallback))));
+  const review = (provider, operation, effect) => effect.pipe(Effect.catchCause((cause) => {
+    if (Cause.hasInterrupts(cause))
+      return Effect.failCause(cause).pipe(Effect.orDie);
+    const error = Cause.squash(cause);
+    return Effect.logWarning("vcs provider failed", { provider: provider.id, operation, cause }).pipe(Effect.andThen(Effect.fail(error instanceof DiffError2 ? error : new DiffError2({
+      message: operation === "base" ? "VCS provider could not resolve a review base" : "VCS provider could not produce a diff"
+    }))));
+  }));
+  const refresh = Effect.fn("Vcs.refresh")(function* () {
+    const changed = yield* Effect.gen(function* () {
+      const provider = selected();
+      const next = provider ? yield* protect(provider, "info", provider.info(scope).pipe(Effect.flatMap(decodeInfo)), { branch: {} }) : { branch: {} };
+      const changed = current.info.branch.current !== next.branch.current;
+      current.info = next;
+      return changed;
+    }).pipe(Semaphore.withPermit(refreshLock));
+    if (!changed)
+      return;
+    while (true) {
+      const branch = current.info.branch.current;
+      yield* bus.publish(VcsEvent.BranchUpdated, { branch });
+      if (branch === current.info.branch.current)
+        return;
+    }
+  });
+  if (vcs) {
+    const store = yield* fs.realPath(vcs.store).pipe(Effect.orElseSucceed(() => vcs.store));
+    const isBranchMetadata = vcs.type === "git" ? (file) => path.basename(file) === "HEAD" && FSUtil.contains(store, file) : (file) => path.resolve(file) === path.join(store, "branch");
+    yield* bus.subscribe(FileSystem.Event.Changed).pipe(Stream.filter((event) => isBranchMetadata(event.data.file)), Stream.runForEach((event) => refresh().pipe(Effect.catchCauseIf((cause) => !Cause.hasInterrupts(cause), (cause) => Effect.logWarning("vcs refresh failed", { file: event.data.file, cause })), Effect.withSpan("Vcs.refreshBranch", { attributes: { file: event.data.file } }))), Effect.forkScoped({ startImmediately: true }));
+  }
+  return Service69.of({
+    transform: state.transform,
+    reload: state.reload,
+    info: Effect.fn("Vcs.info")(function* () {
+      return current.info;
+    }),
+    base: Effect.fn("Vcs.base")(function* () {
+      const provider = selected();
+      if (!provider?.base)
+        return null;
+      return yield* review(provider, "base", provider.base(scope).pipe(Effect.flatMap(decodeBase)));
+    }),
+    branches: Effect.fn("Vcs.branches")(function* (options) {
+      const provider = selected();
+      if (provider)
+        return yield* protect(provider, "branches", provider.branches({ ...scope, ...options }).pipe(Effect.flatMap(decodeBranches)), []);
+      return [];
+    }),
+    status: Effect.fn("Vcs.status")(function* () {
+      const provider = selected();
+      if (provider)
+        return yield* protect(provider, "status", provider.status(scope).pipe(Effect.flatMap(decodeStatus), Effect.map((rows) => Array.from(rows))), []);
+      return [];
+    }),
+    diff: Effect.fn("Vcs.diff")(function* (mode, options) {
+      const provider = selected();
+      if (!provider)
+        return [];
+      const rows = yield* review(provider, "diff", provider.diff({
+        ...scope,
+        mode,
+        ...options?.base !== undefined ? { base: options.base } : {},
+        context: options?.context ?? PATCH_CONTEXT_LINES2,
+        maxOutputBytes: MAX_TOTAL_PATCH_BYTES2
+      }).pipe(Effect.flatMap(decodeDiff)));
+      let total = 0;
+      return rows.map((row) => {
+        const bytes = Buffer.byteLength(row.patch);
+        if (total + bytes > MAX_TOTAL_PATCH_BYTES2)
+          return { ...row, patch: emptyPatch2(row.file) };
+        total += bytes;
+        return row;
+      });
+    })
+  });
+}));
+var node73 = makeLocationNode({
+  service: Service69,
+  layer,
+  deps: [FSUtil.node, node78, node84]
+});
+
+export { Base2, BranchList2, FileStatus2, Info28, Mode2, DiffError2, Service69, node73, exports_vcs };

package/dist/chunks/aisdk-native-d1g6sxjm.js

@@ -0,0 +1,148 @@
+import {
+  ephemeral2,
+  Service79,
+  node84
+} from "./aisdk-native-11nvngjf.js";
+import {
+  Service58,
+  node62
+} from "./aisdk-native-1xqm2dzv.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/wellknown.ts
+var exports_wellknown = {};
+__export(exports_wellknown, {
+  Auth: () => Auth2,
+  Config: () => Config2,
+  Event: () => Event13,
+  Manifest: () => Manifest2,
+  RemoteConfig: () => RemoteConfig2,
+  Service: () => Service57,
+  WellKnown: () => exports_wellknown,
+  inspect: () => inspect2,
+  node: () => node61,
+  resolve: () => resolve2
+});
+import { Integration } from "@opencode/schema/integration";
+import { Context, Effect, Layer, Ref, Schema, Semaphore } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { isDeepStrictEqual } from "node:util";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { httpClient } from "@opencode/util/effect/app-node-platform";
+var Auth2 = Schema.Struct({
+  command: Schema.Array(Schema.String),
+  env: Schema.String
+}).annotate({ identifier: "WellKnown.Auth" });
+var RemoteConfig2 = Schema.Struct({
+  url: Schema.String,
+  headers: Schema.optional(Schema.Record(Schema.String, Schema.String))
+}).annotate({ identifier: "WellKnown.RemoteConfig" });
+var Config2 = Schema.Record(Schema.String, Schema.Json).annotate({ identifier: "WellKnown.Config" });
+var Manifest2 = Schema.Struct({
+  auth: Schema.optional(Auth2),
+  config: Schema.optional(Schema.NullOr(Config2)),
+  remote_config: Schema.optional(RemoteConfig2)
+}).annotate({ identifier: "WellKnown.Manifest" });
+
+class Service57 extends Context.Service()("@opencode/WellKnown") {
+}
+var Event13 = {
+  Updated: ephemeral2({ type: "wellknown.updated", schema: {} })
+};
+var inspect2 = Effect.fn("WellKnown.inspect")(function* (origin) {
+  const url = `${origin.replace(/\/+$/, "")}/.well-known/opencode`;
+  const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+  return yield* http.execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson)).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Manifest2)), Effect.mapError((cause) => new Error(`Failed to load wellknown manifest from ${url}`, { cause })));
+});
+var resolve2 = Effect.fn("WellKnown.resolve")(function* (input) {
+  const manifest = yield* inspect2(input.origin);
+  return yield* resolveEntry({ origin: input.origin, integrationID: Integration.ID.make(input.origin.replace(/\/+$/, "")), manifest }, input.variables ?? {});
+});
+var resolveEntry = Effect.fnUntraced(function* (entry, variables) {
+  const configs = entry.manifest.config ? [entry.manifest.config] : [];
+  if (!entry.manifest.remote_config)
+    return configs;
+  const substitute = (value) => value.replace(/\{env:([^}]+)\}/g, (_, name) => variables[name] ?? process.env[name] ?? "");
+  const url = substitute(entry.manifest.remote_config.url);
+  const headers = Object.fromEntries(Object.entries(entry.manifest.remote_config.headers ?? {}).map(([key, value]) => [key, substitute(value)]));
+  const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+  const remote = yield* http.execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson, HttpClientRequest.setHeaders(headers))).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Config2)), Effect.mapError((cause) => new Error(`Failed to load wellknown remote config from ${url}`, { cause })));
+  if (Schema.is(Config2)(remote.config))
+    return [...configs, remote.config];
+  return [...configs, remote];
+});
+var sourcesKey = "wellknown:sources";
+var Sources = Schema.Array(Schema.String);
+var layer = Layer.effect(Service57, Effect.gen(function* () {
+  const http = yield* HttpClient.HttpClient;
+  const kv = yield* Service58;
+  const bus = yield* Service79;
+  const cache = yield* Ref.make(new Map);
+  const lock = Semaphore.makeUnsafe(1);
+  const loadEntry = Effect.fn("WellKnown.loadEntry")(function* (origin) {
+    const manifest = yield* inspect2(origin).pipe(Effect.provideService(HttpClient.HttpClient, http));
+    return { origin, integrationID: Integration.ID.make(origin), manifest };
+  });
+  const load = Effect.fn("WellKnown.load")(function* () {
+    const value = yield* kv.get(sourcesKey);
+    const origins = Schema.is(Sources)(value) ? value : [];
+    const current = yield* Ref.get(cache);
+    const entries = yield* Effect.forEach(origins, (origin) => {
+      const cached = current.get(origin);
+      if (cached)
+        return Effect.succeed(cached);
+      return loadEntry(origin);
+    });
+    yield* Ref.set(cache, new Map(entries.map((entry) => [entry.origin, entry])));
+    return entries;
+  });
+  const refresh = Effect.fn("WellKnown.refresh")(function* () {
+    const value = yield* kv.get(sourcesKey);
+    const origins = Schema.is(Sources)(value) ? value : [];
+    if (!origins.length)
+      return false;
+    const entries = yield* Effect.forEach(origins, loadEntry);
+    const next = new Map(entries.map((entry) => [entry.origin, entry]));
+    const changed = !isDeepStrictEqual(Ref.getUnsafe(cache), next);
+    if (!changed)
+      return false;
+    yield* Ref.set(cache, next);
+    yield* bus.publish(Event13.Updated, {});
+    return true;
+  }, (effect) => lock.withPermit(effect));
+  return Service57.of({
+    entries: load,
+    snapshot: () => Array.from(Ref.getUnsafe(cache).values()),
+    refresh,
+    add: Effect.fn("WellKnown.add")(function* (value) {
+      const origin = value.replace(/\/+$/, "");
+      const entry = yield* loadEntry(origin);
+      if (!entry.manifest.auth)
+        return yield* Effect.fail(new Error(`No authentication method found at ${origin}`));
+      const sources = yield* kv.get(sourcesKey);
+      const origins = Schema.is(Sources)(sources) ? sources : [];
+      yield* kv.set(sourcesKey, Array.from(new Set([...origins, origin])));
+      yield* Ref.update(cache, (current) => new Map(current).set(origin, entry));
+      yield* bus.publish(Event13.Updated, {});
+      return entry;
+    }, (effect, _value) => lock.withPermit(effect)),
+    remove: Effect.fn("WellKnown.remove")(function* (value) {
+      const origin = value.replace(/\/+$/, "");
+      const sources = yield* kv.get(sourcesKey);
+      const origins = Schema.is(Sources)(sources) ? sources : [];
+      yield* kv.set(sourcesKey, origins.filter((item) => item !== origin));
+      yield* Ref.update(cache, (current) => {
+        const next = new Map(current);
+        next.delete(origin);
+        return next;
+      });
+      yield* bus.publish(Event13.Updated, {});
+    }, (effect, _value) => lock.withPermit(effect)),
+    resolve: Effect.fn("WellKnown.resolveEntry")((entry, variables) => resolveEntry(entry, variables).pipe(Effect.provideService(HttpClient.HttpClient, http)))
+  });
+}));
+var node61 = makeGlobalNode({ service: Service57, layer, deps: [httpClient, node62, node84] });
+
+export { Auth2, RemoteConfig2, Config2, Manifest2, Service57, Event13, inspect2, resolve2, node61, exports_wellknown };

package/dist/chunks/aisdk-native-d9fn303g.js

@@ -0,0 +1,29 @@
+// src/database/migration/20260612174303_project_dir_strategy.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260612174303_project_dir_strategy",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`project_directory\` ADD \`strategy\` text;`);
+      yield* tx.run(`PRAGMA foreign_keys=OFF;`);
+      yield* tx.run(`
+        CREATE TABLE \`__new_project_directory\` (
+          \`project_id\` text NOT NULL,
+          \`directory\` text NOT NULL,
+          \`type\` text,
+          \`strategy\` text,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`project_directory_pk\` PRIMARY KEY(\`project_id\`, \`directory\`),
+          CONSTRAINT \`fk_project_directory_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`INSERT INTO \`__new_project_directory\`(\`project_id\`, \`directory\`, \`type\`, \`time_created\`) SELECT \`project_id\`, \`directory\`, \`type\`, \`time_created\` FROM \`project_directory\`;`);
+      yield* tx.run(`DROP TABLE \`project_directory\`;`);
+      yield* tx.run(`ALTER TABLE \`__new_project_directory\` RENAME TO \`project_directory\`;`);
+      yield* tx.run(`PRAGMA foreign_keys=ON;`);
+    });
+  }
+};
+var _20260612174303_project_dir_strategy_default = migration;
+
+export { _20260612174303_project_dir_strategy_default };

package/dist/chunks/aisdk-native-d9jj8t3e.js

@@ -0,0 +1,14 @@
+// src/database/migration/20260501142318_next_venus.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260501142318_next_venus",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`agent\` text;`);
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`model\` text;`);
+    });
+  }
+};
+var _20260501142318_next_venus_default = migration;
+
+export { _20260501142318_next_venus_default };

package/dist/chunks/aisdk-native-dajrwvna.js

@@ -0,0 +1,6 @@
+// src/persistent-pty/pty-binding.ts
+import { binaryPath } from "@opencode-ai/pty";
+var binding = binaryPath;
+var pty_binding_default = binding;
+
+export { pty_binding_default };

package/dist/chunks/aisdk-native-dap0rakb.js

@@ -0,0 +1,14 @@
+// src/github-copilot/responses/tool/web-search-preview.ts
+import { z } from "zod/v4";
+var webSearchPreviewArgsSchema2 = z.object({
+  searchContextSize: z.enum(["low", "medium", "high"]).optional(),
+  userLocation: z.object({
+    type: z.literal("approximate"),
+    country: z.string().optional(),
+    city: z.string().optional(),
+    region: z.string().optional(),
+    timezone: z.string().optional()
+  }).optional()
+});
+
+export { webSearchPreviewArgsSchema2 };

package/dist/chunks/aisdk-native-deehc0cj.js

@@ -0,0 +1,162 @@
+import {
+  mergeOverlay2,
+  mergeHeaders2
+} from "./aisdk-native-33n3bzdy.js";
+import {
+  latest2,
+  Service35
+} from "./aisdk-native-y9tfvs3x.js";
+import {
+  observe2
+} from "./aisdk-native-qsdy395h.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/config/plugin/provider.ts
+var exports_provider = {};
+__export(exports_provider, {
+  ConfigProviderPlugin: () => exports_provider,
+  Plugin: () => Plugin18
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Money } from "@opencode/schema/money";
+import { Effect } from "effect";
+var Plugin18 = define({
+  id: "opencode.config.provider",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service35;
+    const loaded = yield* observe2(config, ctx.event, ctx.integration.reload().pipe(Effect.andThen(ctx.catalog.reload())));
+    yield* ctx.integration.transform((integrations) => {
+      for (const [id, provider] of configuredProviders(loaded.entries)) {
+        const integrationID = id;
+        if (!integrations.get(integrationID)) {
+          integrations.method.update({
+            integrationID,
+            method: { type: "key", label: "Manually enter API Key" }
+          });
+        }
+        integrations.update(integrationID, (integration) => {
+          integration.name = provider.name ?? integration.name;
+        });
+        if (provider.env !== undefined) {
+          integrations.method.update({
+            integrationID,
+            method: { type: "env", names: [...provider.env] }
+          });
+        }
+      }
+    });
+    yield* ctx.catalog.transform((catalog) => {
+      const configuredDefault = latest2(loaded.entries, "model");
+      if (configuredDefault !== undefined)
+        catalog.model.default.set(configuredDefault.providerID, configuredDefault.model);
+      for (const [id, item] of configuredProviders(loaded.entries)) {
+        const providerID = id;
+        const current = catalog.provider.get(providerID);
+        const source = catalog.provider.get(item.canonical ?? current?.provider.canonical ?? providerID);
+        const changed = item.canonical !== undefined && item.canonical !== current?.provider.canonical;
+        catalog.provider.update(providerID, (provider) => {
+          if (changed && source && source.provider !== provider)
+            Object.assign(provider, structuredClone(source.provider), {
+              id: provider.id,
+              integrationID: provider.integrationID
+            });
+          provider.activation = "enabled";
+          if (item.canonical !== undefined)
+            provider.canonical = item.canonical;
+          if (item.name !== undefined)
+            provider.name = item.name;
+          if (item.package !== undefined)
+            provider.package = item.package;
+          if (item.compaction !== undefined)
+            provider.compaction = { ...item.compaction };
+          if (item.websocket !== undefined)
+            provider.websocket = item.websocket;
+          if (item.settings !== undefined)
+            provider.settings = mergeOverlay2(provider.settings, item.settings);
+          if (item.headers !== undefined)
+            provider.headers = mergeHeaders2(provider.headers, item.headers);
+          if (item.body !== undefined)
+            provider.body = mergeOverlay2(provider.body, item.body);
+        });
+        for (const [id, config] of Object.entries(item.models ?? {})) {
+          const base = source?.models.get(config.modelID ?? id) ?? source?.models.get(id);
+          const inherit = changed || !catalog.model.get(providerID, id);
+          catalog.model.update(providerID, id, (model) => {
+            if (inherit && base) {
+              Object.assign(model, structuredClone(base));
+              if (item.package !== undefined)
+                model.package = undefined;
+              if (item.settings?.baseURL !== undefined && model.settings)
+                delete model.settings.baseURL;
+            }
+            if (config.family !== undefined)
+              model.family = config.family;
+            if (config.name !== undefined)
+              model.name = config.name;
+            if (config.modelID !== undefined)
+              model.modelID = config.modelID;
+            if (config.compatibility !== undefined)
+              model.compatibility = { ...model.compatibility, ...config.compatibility };
+            if (config.package !== undefined)
+              model.package = config.package;
+            if (config.compaction !== undefined)
+              model.compaction = { ...config.compaction };
+            if (config.websocket !== undefined)
+              model.websocket = config.websocket;
+            if (config.settings !== undefined)
+              model.settings = mergeOverlay2(model.settings, config.settings);
+            if (config.headers !== undefined)
+              model.headers = mergeHeaders2(model.headers, config.headers);
+            if (config.body !== undefined)
+              model.body = mergeOverlay2(model.body, config.body);
+            if (config.capabilities !== undefined) {
+              model.capabilities = {
+                tools: config.capabilities.tools,
+                input: [...config.capabilities.input],
+                output: [...config.capabilities.output]
+              };
+            }
+            if (config.variants !== undefined) {
+              model.variants ??= [];
+              for (const variant of config.variants) {
+                let existing = model.variants.find((item) => item.id === variant.id);
+                if (!existing) {
+                  existing = { id: variant.id };
+                  model.variants.push(existing);
+                }
+                if (variant.settings !== undefined)
+                  existing.settings = mergeOverlay2(existing.settings, variant.settings);
+                if (variant.headers !== undefined)
+                  existing.headers = mergeHeaders2(existing.headers, variant.headers);
+                if (variant.body !== undefined)
+                  existing.body = mergeOverlay2(existing.body, variant.body);
+              }
+            }
+            if (config.cost !== undefined) {
+              model.cost = (Array.isArray(config.cost) ? config.cost : [config.cost]).map((cost) => ({
+                tier: cost.tier && { ...cost.tier },
+                input: cost.input,
+                output: cost.output,
+                cache: {
+                  read: cost.cache?.read ?? Money.USDPerMillionTokens.zero,
+                  write: cost.cache?.write ?? Money.USDPerMillionTokens.zero
+                }
+              }));
+            }
+            if (config.disabled !== undefined)
+              model.enabled = !config.disabled;
+            if (config.limit !== undefined)
+              model.limit = { ...model.limit, ...config.limit };
+          });
+        }
+      }
+    });
+  })
+});
+function configuredProviders(entries) {
+  return entries.filter((entry) => entry.type === "document").flatMap((file) => Object.entries(file.info.providers ?? {}));
+}
+
+export { Plugin18, exports_provider };

package/dist/chunks/aisdk-native-df08tz66.js

@@ -0,0 +1,13 @@
+// src/database/migration/20260811161259_execution_claim_attempts.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260811161259_execution_claim_attempts",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`session_v2\` ADD \`resume_attempts\` integer DEFAULT 0 NOT NULL;`);
+    });
+  }
+};
+var _20260811161259_execution_claim_attempts_default = migration;
+
+export { _20260811161259_execution_claim_attempts_default };