@opencode/core 0.0.0-reserved → 2.0.0

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

@@ -0,0 +1,328 @@
+import {
+  provider2,
+  model2
+} from "./aisdk-native-0paq2nw3.js";
+import {
+  aisdk2
+} from "./aisdk-native-33n3bzdy.js";
+import {
+  Capabilities2,
+  compatibility2
+} from "./aisdk-native-jghsd1wz.js";
+import {
+  __export
+} from "./aisdk-native-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/aisdk-native-pvvztgda.js

@@ -0,0 +1,95 @@
+import {
+  SessionMessage2
+} from "./aisdk-native-gftt206x.js";
+import {
+  SessionSchema2
+} from "./aisdk-native-y6f0p4jw.js";
+import {
+  MessageDecodeError2
+} from "./aisdk-native-3x8gcmrs.js";
+import {
+  InitializationBlocked2,
+  read3
+} from "./aisdk-native-rhjbct0v.js";
+import {
+  SessionMessageTable2
+} from "./aisdk-native-a1bz86dw.js";
+import {
+  initial2,
+  preview3
+} from "./aisdk-native-cq37gk0t.js";
+import {
+  compatible2,
+  isCheckpoint2,
+  validate2
+} from "./aisdk-native-msq0jde0.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/session/history.ts
+var exports_history = {};
+__export(exports_history, {
+  SessionHistory: () => exports_history,
+  decodeMessageRow: () => decodeMessageRow2,
+  entriesForRunner: () => entriesForRunner2,
+  firstUserMessage: () => firstUserMessage2,
+  latestCompaction: () => latestCompaction2,
+  load: () => load3,
+  preview: () => preview2
+});
+import { and, asc, desc, eq, gte, or, sql } from "drizzle-orm";
+import { Effect, Schema } from "effect";
+var decode = Schema.decodeUnknownEffect(SessionMessage2.Info);
+var replayable = (message, boundary) => !isCheckpoint2(message) || boundary === "latest" || boundary !== "local" && compatible2(message.providerContext.provenance, boundary);
+var latestCompaction2 = Effect.fnUntraced(function* (db, sessionID, boundary) {
+  return yield* db.select({ seq: SessionMessageTable2.seq }).from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, sessionID), eq(SessionMessageTable2.type, "compaction"), sql`json_extract(${SessionMessageTable2.data}, '$.status') = 'completed'`, boundary === "latest" ? undefined : or(sql`json_extract(${SessionMessageTable2.data}, '$.providerContext') is null`, boundary === "local" ? undefined : and(...Object.entries(boundary).map(([key, value]) => sql`json_extract(${SessionMessageTable2.data}, ${`$.providerContext.provenance.${key}`}) = ${value}`))))).orderBy(desc(SessionMessageTable2.seq)).limit(1).get().pipe(Effect.orDie);
+});
+var decodeMessageRow2 = (row) => decode({ ...row.data, id: row.id, type: row.type }).pipe(Effect.tap((message) => isCheckpoint2(message) ? validate2(message.providerContext) : Effect.void), Effect.mapError(() => new MessageDecodeError2({
+  sessionID: SessionSchema2.ID.make(row.session_id),
+  messageID: SessionMessage2.ID.make(row.id)
+})));
+var messageEntries = Effect.fnUntraced(function* (db, sessionID, boundary) {
+  const compaction = yield* latestCompaction2(db, sessionID, boundary);
+  const rows = yield* db.select().from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, sessionID), compaction ? gte(SessionMessageTable2.seq, compaction.seq) : undefined)).orderBy(asc(SessionMessageTable2.seq)).all().pipe(Effect.orDie);
+  const entries = yield* Effect.forEach(rows, (row) => decodeMessageRow2(row).pipe(Effect.map((message) => ({ seq: row.seq, message }))));
+  const native = entries.findLast((entry) => isCheckpoint2(entry.message));
+  return entries.filter((entry) => !(entry.message.type === "system" && native && entry.seq < native.seq) && replayable(entry.message, boundary));
+});
+var load3 = Effect.fn("SessionHistory.load")(function* (db, sessionID, boundary) {
+  return (yield* messageEntries(db, sessionID, boundary)).map((entry) => entry.message);
+});
+var entriesForRunner2 = Effect.fn("SessionHistory.entriesForRunner")(function* (db, sessionID, instructions, boundary) {
+  return yield* db.transaction(() => Effect.gen(function* () {
+    const messages = yield* messageEntries(db, sessionID, boundary);
+    return {
+      initial: yield* initial2(db, sessionID, instructions),
+      entries: messages
+    };
+  })).pipe(Effect.orDie);
+});
+var preview2 = Effect.fn("SessionHistory.preview")(function* (db, sessionID, instructions, boundary) {
+  const observed = yield* read3(instructions);
+  return yield* db.transaction(() => Effect.gen(function* () {
+    const messages = yield* messageEntries(db, sessionID, boundary);
+    const unsettled = messages.findIndex((entry) => entry.message.type === "assistant" && entry.message.time.completed === undefined);
+    const settled = unsettled === -1 ? messages : messages.slice(0, unsettled);
+    const assembled = yield* preview3(db, sessionID, instructions, observed);
+    return {
+      initial: assembled.initial,
+      messages: settled.map((entry) => entry.message),
+      instructionUpdate: assembled.update
+    };
+  })).pipe(Effect.catch((error) => error instanceof InitializationBlocked2 ? error : Effect.die(error)));
+});
+var firstUserMessage2 = Effect.fn("SessionHistory.firstUserMessage")(function* (db, sessionID) {
+  const row = yield* db.select().from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, sessionID), eq(SessionMessageTable2.type, "user"))).orderBy(asc(SessionMessageTable2.seq)).get().pipe(Effect.orDie);
+  if (!row)
+    return;
+  const message = yield* decodeMessageRow2(row).pipe(Effect.orElseSucceed(() => {
+    return;
+  }));
+  return message?.type === "user" ? message : undefined;
+});
+
+export { latestCompaction2, decodeMessageRow2, load3, entriesForRunner2, preview2, firstUserMessage2, exports_history };

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

@@ -0,0 +1,114 @@
+import {
+  Service71
+} from "./aisdk-native-ms882c9x.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/mcp/stdio.ts
+var exports_stdio = {};
+__export(exports_stdio, {
+  McpStdio: () => exports_stdio,
+  make: () => make2
+});
+import { ReadBuffer, serializeMessage } from "@modelcontextprotocol/sdk/shared/stdio.js";
+import { Cause, Duration, Effect, Queue, Scope, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+var CLOSE_GRACE = Duration.seconds(2);
+var FORCE_KILL_AFTER = Duration.seconds(2);
+var OUTGOING_CAPACITY = 64;
+var MAX_FRAME_BYTES = 16 * 1024 * 1024;
+var make2 = Effect.fnUntraced(function* (options) {
+  const environment = yield* Service71;
+  const scope = yield* Effect.scope;
+  const outgoing = yield* Queue.bounded(OUTGOING_CAPACITY);
+  const buffer = new ReadBuffer;
+  const state = { phase: "ready" };
+  let startup;
+  let closing;
+  let trailingBytes = 0;
+  const stop = Effect.fnUntraced(function* (handle) {
+    yield* Effect.timeoutOption(handle.exitCode, CLOSE_GRACE).pipe(Effect.ignore);
+    const terminated = yield* Effect.timeoutOption(handle.kill({ killSignal: "SIGTERM" }), FORCE_KILL_AFTER);
+    if (terminated._tag === "None")
+      yield* handle.kill({ killSignal: "SIGKILL" });
+  }, Effect.ignore());
+  const close = () => closing ??= Effect.runPromise(Effect.gen(function* () {
+    state.phase = "closed";
+    Queue.endUnsafe(outgoing);
+    if (startup)
+      yield* Effect.promise(() => startup.catch(() => {
+        return;
+      }));
+    const handle = state.handle;
+    if (!handle)
+      return;
+    state.handle = undefined;
+    yield* stop(handle);
+  }).pipe(Effect.ensuring(Queue.shutdown(outgoing)), Effect.ensuring(Effect.sync(() => buffer.clear()))));
+  const transport = {
+    start: () => {
+      if (state.phase !== "ready")
+        return Promise.reject(new Error("Stdio transport already started"));
+      state.phase = "starting";
+      startup = Effect.runPromise(Effect.gen(function* () {
+        const handle = yield* environment.spawner.spawn(ChildProcess.make(options.command, [...options.args], {
+          cwd: options.cwd,
+          env: options.environment,
+          extendEnv: true,
+          stdin: { stream: Stream.encodeText(Stream.fromQueue(outgoing)), endOnDone: true },
+          stdout: "pipe",
+          stderr: "pipe",
+          forceKillAfter: FORCE_KILL_AFTER
+        }));
+        state.handle = handle;
+        if (state.phase === "closed") {
+          state.handle = undefined;
+          return yield* stop(handle);
+        }
+        state.phase = "open";
+        yield* startOutput(handle);
+      }).pipe(Scope.provide(scope)));
+      return startup;
+    },
+    send: (message) => state.phase !== "open" ? Promise.reject(new Error("Not connected")) : Effect.runPromise(Queue.offer(outgoing, serializeMessage(message)).pipe(Effect.flatMap((offered) => offered ? Effect.void : Effect.fail(new Error("Not connected"))))),
+    close
+  };
+  const deliver = (chunk) => Effect.gen(function* () {
+    for (const byte of chunk) {
+      trailingBytes = byte === 10 ? 0 : trailingBytes + 1;
+      if (trailingBytes > MAX_FRAME_BYTES)
+        return yield* Effect.fail(new Error("MCP stdio frame exceeded 16 MiB"));
+    }
+    buffer.append(Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+    while (true) {
+      const message = yield* Effect.try({
+        try: () => buffer.readMessage(),
+        catch: (cause) => cause instanceof Error ? cause : new Error(String(cause))
+      }).pipe(Effect.catch((error) => Effect.sync(() => {
+        transport.onerror?.(error);
+        return;
+      })));
+      if (message === undefined)
+        continue;
+      if (message === null)
+        return;
+      transport.onmessage?.(message);
+    }
+  });
+  const startOutput = (handle) => Effect.gen(function* () {
+    yield* Effect.forkScoped(Stream.runForEach(handle.stdout, deliver).pipe(Effect.tapCause((cause) => Effect.sync(() => {
+      const error = Cause.squash(cause);
+      transport.onerror?.(error instanceof Error ? error : new Error(String(error)));
+    })), Effect.ignore, Effect.ensuring(Effect.gen(function* () {
+      const unexpected = state.phase !== "closed";
+      if (unexpected)
+        yield* Effect.promise(close);
+      transport.onclose?.();
+    }))));
+    yield* Effect.forkScoped(handle.stderr.pipe(Stream.decodeText(), Stream.runForEach((output) => output.trim() === "" ? Effect.void : Effect.logDebug("mcp server stderr", { server: options.server, output })), Effect.ignore));
+  });
+  return transport;
+});
+
+export { make2, exports_stdio };

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

@@ -0,0 +1,13 @@
+// src/database/migration/20260211171708_add_project_commands.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260211171708_add_project_commands",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`project\` ADD \`commands\` text;`);
+    });
+  }
+};
+var _20260211171708_add_project_commands_default = migration;
+
+export { _20260211171708_add_project_commands_default };