@opencode/core 0.0.0-reserved → 2.0.0

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

@@ -0,0 +1,69 @@
+import {
+  PositiveInt2
+} from "./aisdk-native-922hggd3.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/v1/config/mcp.ts
+var exports_mcp5 = {};
+__export(exports_mcp5, {
+  ConfigMCPV1: () => exports_mcp5,
+  Info: () => Info8,
+  Local: () => Local2,
+  OAuth: () => OAuth2,
+  Remote: () => Remote2
+});
+import { Schema } from "effect";
+var Local2 = Schema.Struct({
+  type: Schema.Literal("local").annotate({ description: "Type of MCP server connection" }),
+  command: Schema.mutable(Schema.Array(Schema.String)).annotate({
+    description: "Command and arguments to run the MCP server"
+  }),
+  cwd: Schema.optional(Schema.String).annotate({
+    description: "Working directory for the MCP server process. Relative paths resolve from the workspace directory."
+  }),
+  environment: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({
+    description: "Environment variables to set when running the MCP server"
+  }),
+  enabled: Schema.optional(Schema.Boolean).annotate({
+    description: "Enable or disable the MCP server on startup"
+  }),
+  timeout: Schema.optional(PositiveInt2).annotate({
+    description: "Timeout in ms for MCP server requests. Defaults to 5000 (5 seconds) if not specified."
+  })
+}).annotate({ identifier: "McpLocalConfig" });
+var OAuth2 = Schema.Struct({
+  clientId: Schema.optional(Schema.String).annotate({
+    description: "OAuth client ID. If not provided, dynamic client registration (RFC 7591) will be attempted."
+  }),
+  clientSecret: Schema.optional(Schema.String).annotate({
+    description: "OAuth client secret (if required by the authorization server)"
+  }),
+  scope: Schema.optional(Schema.String).annotate({ description: "OAuth scopes to request during authorization" }),
+  callbackPort: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 65535 }))).annotate({
+    description: "Port for the local OAuth callback server (default: 19876). Shorthand for redirectUri when only the port needs changing. Ignored if redirectUri is set."
+  }),
+  redirectUri: Schema.optional(Schema.String).annotate({
+    description: "OAuth redirect URI (default: http://127.0.0.1:19876/mcp/oauth/callback)."
+  })
+}).annotate({ identifier: "McpOAuthConfig" });
+var Remote2 = Schema.Struct({
+  type: Schema.Literal("remote").annotate({ description: "Type of MCP server connection" }),
+  url: Schema.String.annotate({ description: "URL of the remote MCP server" }),
+  enabled: Schema.optional(Schema.Boolean).annotate({
+    description: "Enable or disable the MCP server on startup"
+  }),
+  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({
+    description: "Headers to send with the request"
+  }),
+  oauth: Schema.optional(Schema.Union([OAuth2, Schema.Literal(false)])).annotate({
+    description: "OAuth authentication configuration for the MCP server. Set to false to disable OAuth auto-detection."
+  }),
+  timeout: Schema.optional(PositiveInt2).annotate({
+    description: "Timeout in ms for MCP server requests. Defaults to 5000 (5 seconds) if not specified."
+  })
+}).annotate({ identifier: "McpRemoteConfig" });
+var Info8 = Schema.Union([Local2, Remote2]).annotate({ discriminator: "type" });
+
+export { Local2, OAuth2, Remote2, Info8, exports_mcp5 };

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

@@ -0,0 +1,114 @@
+import {
+  directoryColumn2,
+  pathColumn2
+} from "./aisdk-native-6msgmcgs.js";
+import {
+  Timestamps2
+} from "./aisdk-native-qfa1cgps.js";
+import {
+  ProjectTable2
+} from "./aisdk-native-8p4f9s12.js";
+
+// src/session/sql.ts
+import { sqliteTable, text, integer, index, primaryKey, real, uniqueIndex } from "drizzle-orm/sqlite-core";
+import { sql } from "drizzle-orm";
+var SessionTable2 = sqliteTable("session_v2", {
+  id: text().$type().primaryKey(),
+  project_id: text().$type().notNull().references(() => ProjectTable2.id, { onDelete: "cascade" }),
+  workspace_id: text().$type(),
+  parent_id: text().$type(),
+  fork_session_id: text().$type(),
+  fork_boundary: text({ mode: "json" }).$type(),
+  slug: text().notNull(),
+  directory: directoryColumn2().notNull(),
+  path: pathColumn2(),
+  title: text(),
+  version: text().notNull(),
+  share_url: text(),
+  summary_additions: integer(),
+  summary_deletions: integer(),
+  summary_files: integer(),
+  summary_diffs: text({ mode: "json" }).$type(),
+  metadata: text({ mode: "json" }).$type(),
+  cost: real().notNull().default(0),
+  tokens_input: integer().notNull().default(0),
+  tokens_output: integer().notNull().default(0),
+  tokens_reasoning: integer().notNull().default(0),
+  tokens_cache_read: integer().notNull().default(0),
+  tokens_cache_write: integer().notNull().default(0),
+  revert: text({ mode: "json" }).$type(),
+  permission: text({ mode: "json" }).$type(),
+  agent: text(),
+  model: text({ mode: "json" }).$type(),
+  ...Timestamps2,
+  time_idle: integer(),
+  time_viewed: integer(),
+  idle_outcome: text().$type(),
+  time_compacting: integer(),
+  time_archived: integer(),
+  time_suspended: integer(),
+  resume_attempts: integer().notNull().default(0)
+}, (table) => [
+  index("session_v2_project_idx").on(table.project_id),
+  index("session_v2_workspace_idx").on(table.workspace_id),
+  index("session_v2_parent_idx").on(table.parent_id),
+  index("session_v2_time_suspended_idx").on(table.time_suspended).where(sql`${table.time_suspended} is not null`)
+]);
+var SessionMessageTable2 = sqliteTable("session_message", {
+  id: text().$type().primaryKey(),
+  session_id: text().$type().notNull().references(() => SessionTable2.id, { onDelete: "cascade" }),
+  type: text().$type().notNull(),
+  seq: integer().notNull(),
+  ...Timestamps2,
+  data: text({ mode: "json" }).notNull().$type()
+}, (table) => [
+  uniqueIndex("session_message_session_seq_idx").on(table.session_id, table.seq),
+  index("session_message_session_type_seq_idx").on(table.session_id, table.type, table.seq),
+  index("session_message_session_time_created_id_idx").on(table.session_id, table.time_created, table.id),
+  index("session_message_time_created_idx").on(table.time_created)
+]);
+var SessionPendingTable2 = sqliteTable("session_pending", {
+  id: text().$type().primaryKey(),
+  session_id: text().$type().notNull().references(() => SessionTable2.id, { onDelete: "cascade" }),
+  type: text().$type().notNull(),
+  data: text({ mode: "json" }).$type().notNull(),
+  delivery: text().$type(),
+  admitted_seq: integer().notNull(),
+  time_created: integer().notNull().$default(() => Date.now())
+}, (table) => [
+  index("session_pending_session_delivery_seq_idx").on(table.session_id, table.delivery, table.admitted_seq),
+  uniqueIndex("session_pending_session_compaction_idx").on(table.session_id).where(sql`${table.type} = 'compaction'`),
+  uniqueIndex("session_pending_session_admitted_seq_idx").on(table.session_id, table.admitted_seq)
+]);
+var SessionInboxTable2 = sqliteTable("session_inbox", {
+  id: text().$type().primaryKey(),
+  session_id: text().$type().notNull().references(() => SessionTable2.id, { onDelete: "cascade" }),
+  type: text().$type().notNull(),
+  payload: text({ mode: "json" }).$type().notNull(),
+  delivery: text().$type().notNull(),
+  enqueued_seq: integer().notNull(),
+  time_created: integer().notNull().$default(() => Date.now())
+}, (table) => [
+  index("session_inbox_session_delivery_seq_idx").on(table.session_id, table.delivery, table.enqueued_seq),
+  uniqueIndex("session_inbox_session_enqueued_seq_idx").on(table.session_id, table.enqueued_seq)
+]);
+var InstructionEntryTable2 = sqliteTable("instruction_entry", {
+  session_id: text().$type().notNull().references(() => SessionTable2.id, { onDelete: "cascade" }),
+  key: text().notNull(),
+  value: text({ mode: "json" }).$type(),
+  removed: integer({ mode: "boolean" }).notNull().default(false),
+  ...Timestamps2
+}, (table) => [primaryKey({ columns: [table.session_id, table.key] })]);
+var InstructionBlobTable2 = sqliteTable("instruction_blob", {
+  hash: text().$type().primaryKey(),
+  value: text({ mode: "json" }).$type()
+});
+var InstructionStateTable2 = sqliteTable("instruction_state", {
+  session_id: text().$type().primaryKey().references(() => SessionTable2.id, { onDelete: "cascade" }),
+  epoch_start: integer().notNull(),
+  through_seq: integer().notNull(),
+  initial_values: text({ mode: "json" }).notNull().$type(),
+  current_values: text({ mode: "json" }).notNull().$type()
+});
+
+export { SessionTable2, SessionMessageTable2, SessionPendingTable2, SessionInboxTable2, InstructionEntryTable2, InstructionBlobTable2, InstructionStateTable2 };

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

@@ -0,0 +1,366 @@
+import {
+  webSocketConstructor2
+} from "./aisdk-native-5t3nmthw.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/session/model-transport.ts
+var exports_model_transport = {};
+__export(exports_model_transport, {
+  Service: () => Service26,
+  SessionModelTransport: () => exports_model_transport,
+  layer: () => layer10,
+  makeLayer: () => makeLayer2,
+  node: () => node31
+});
+import {
+  WebSocketTransport
+} from "@opencode/ai/route";
+import { AIError, AIErrorReason, TransportError } from "@opencode/ai";
+import { Hash } from "@opencode/util/hash";
+import { Cause, Clock, Context, Effect, Fiber, Layer, Metric, Queue, Scope, Semaphore, Stream } from "effect";
+import { Socket } from "effect/unstable/socket";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+var ROTATE_AFTER_MS = 55 * 60 * 1000;
+var INBOUND_CAPACITY = 128;
+var CONNECT_TIMEOUT = "10 seconds";
+var IDLE_TIMEOUT = "5 minutes";
+var events = Metric.counter("opencode_session_websocket_events_total", {
+  description: "Session WebSocket lifecycle events",
+  incremental: true
+});
+var metric = (event, attributes = {}) => Metric.update(events.pipe(Metric.withAttributes({ event, ...attributes })), 1);
+
+class Service26 extends Context.Service()("@opencode/SessionModelTransport") {
+}
+var transportError = (message, input) => new AIError({
+  reason: new TransportError({ message, transport: "websocket", ...input })
+});
+var annotate = (error, input) => {
+  if (error.reason._tag !== "Transport")
+    return error;
+  return new AIError({
+    reason: new TransportError({
+      ...error.reason,
+      message: error.message,
+      cause: error.reason.cause,
+      ...input
+    })
+  });
+};
+var affinity = (exchange) => `${exchange.connect.url}:${Hash.sha256(JSON.stringify(Object.entries(exchange.connect.headers).sort(([a], [b]) => a.localeCompare(b))))}`;
+var observationFrame = (observation) => {
+  if (observation.type === "frame" || observation.type === "completed" || observation.type === "incomplete")
+    return Effect.succeed(observation.frame);
+  return Effect.fail(observation.error);
+};
+var observationTerminal = (observation) => observation.type !== "frame";
+var makeLayer2 = (connector) => Layer.effect(Service26, Effect.gen(function* () {
+  const scope = yield* Scope.Scope;
+  const states = new Map;
+  const state = (sessionID) => {
+    const current = states.get(sessionID);
+    if (current)
+      return current;
+    const created = { lock: Semaphore.makeUnsafe(1), closed: false, httpFallback: false };
+    states.set(sessionID, created);
+    return created;
+  };
+  const closeChannel = Effect.fn("SessionModelTransport.closeChannel")(function* (owner, channel) {
+    if (owner.channel === channel)
+      owner.channel = undefined;
+    if (channel.closing)
+      return;
+    channel.closing = true;
+    if (channel.reader)
+      yield* Fiber.interrupt(channel.reader);
+    yield* channel.connection.close;
+    if (channel.active)
+      Queue.failCauseUnsafe(channel.active.queue, Cause.fail(transportError("Session WebSocket closed", {
+        operation: "read",
+        code: "close",
+        phase: "close",
+        delivery: channel.active.delivery === "provider-observed" || channel.active.delivery === "terminal" ? "accepted" : "ambiguous"
+      })));
+    yield* metric("close");
+  });
+  const poison = Effect.fn("SessionModelTransport.poison")(function* (owner, channel, error) {
+    if (owner.channel === channel)
+      owner.channel = undefined;
+    if (channel.closing)
+      return;
+    channel.closing = true;
+    yield* Effect.logDebug("session websocket poisoned", {
+      sessionTransport: "websocket",
+      code: error.reason._tag === "Transport" ? error.reason.code : error.reason._tag,
+      active: channel.active !== undefined
+    });
+    if (channel.active)
+      Queue.failCauseUnsafe(channel.active.queue, Cause.fail(error));
+    yield* metric(error.reason._tag === "Transport" && error.reason.code === "queue-overflow" ? "queue_overflow" : "protocol_failure");
+    yield* channel.connection.close;
+  });
+  const open = Effect.fn("SessionModelTransport.open")(function* (owner, exchange, key) {
+    return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+      const connection = yield* restore(connector.open(exchange.connect).pipe(Effect.timeoutOrElse({
+        duration: CONNECT_TIMEOUT,
+        orElse: () => transportError("Timed out opening the Session WebSocket", {
+          url: exchange.connect.url,
+          operation: "request",
+          code: "connect-timeout",
+          phase: "connect",
+          delivery: "not-sent"
+        })
+      }), Effect.withSpan("SessionModelTransport.connect")));
+      if (owner.closed) {
+        yield* connection.close;
+        return yield* transportError("Session WebSocket owner closed while connecting", {
+          operation: "request",
+          code: "owner-closed",
+          phase: "connect",
+          delivery: "not-sent"
+        });
+      }
+      const channel = {
+        affinity: key,
+        connection,
+        openedAt: yield* Clock.currentTimeMillis,
+        closing: false
+      };
+      owner.channel = channel;
+      channel.reader = yield* connection.messages.pipe(Stream.runForEach((message) => Effect.gen(function* () {
+        const active = channel.active;
+        if (!active)
+          return yield* transportError("WebSocket data arrived without an active exchange", {
+            url: exchange.connect.url,
+            operation: "read",
+            code: "idle-data",
+            phase: "receive"
+          });
+        active.delivery = "provider-observed";
+        if (typeof message !== "string")
+          return yield* transportError("Unsupported binary WebSocket frame", {
+            url: exchange.connect.url,
+            operation: "read",
+            code: "message",
+            phase: "receive"
+          });
+        if (Queue.offerUnsafe(active.queue, message))
+          return;
+        return yield* transportError("Session WebSocket inbound queue overflow", {
+          url: exchange.connect.url,
+          operation: "read",
+          code: "queue-overflow",
+          phase: "receive",
+          delivery: "accepted"
+        });
+      })), Effect.catch((error) => channel.closing ? Effect.void : poison(owner, channel, annotate(error, {
+        phase: error.reason._tag === "Transport" && error.reason.phase === "close" ? "close" : "receive",
+        delivery: channel.active?.delivery === "provider-observed" || channel.active?.delivery === "terminal" || error.reason._tag === "Transport" && error.reason.code === "queue-overflow" ? "accepted" : error.reason._tag === "Transport" && error.reason.code === "1009" ? "rejected" : "ambiguous"
+      }))), Effect.forkIn(scope, { startImmediately: true }));
+      yield* Effect.logDebug("session websocket connected", {
+        sessionTransport: "websocket",
+        phase: "connect"
+      });
+      yield* metric("connect");
+      return channel;
+    }));
+  });
+  const fallback = (exchange) => ({
+    frames: exchange.fallback(),
+    complete: Effect.void
+  });
+  const start = Effect.fn("SessionModelTransport.start")(function* (owner, exchange) {
+    if (owner.closed)
+      return yield* transportError("Session WebSocket owner is closed", {
+        operation: "request",
+        code: "owner-closed",
+        phase: "queue",
+        delivery: "not-sent"
+      });
+    if (owner.httpFallback)
+      return fallback(exchange);
+    const key = affinity(exchange);
+    const now = yield* Clock.currentTimeMillis;
+    const current = owner.channel;
+    const rotateAfterMs = exchange.connect.rotateAfterMs ?? ROTATE_AFTER_MS;
+    const rotation = current ? current.affinity !== key ? "affinity" : now - current.openedAt >= rotateAfterMs ? "age" : undefined : undefined;
+    if (current && rotation) {
+      yield* Effect.logDebug("session websocket rotating", {
+        sessionTransport: "websocket",
+        phase: "connect",
+        reason: rotation
+      });
+      yield* metric("rotation", { reason: rotation });
+      yield* metric("reconnect");
+      yield* closeChannel(owner, current);
+    }
+    if (owner.channel)
+      yield* Effect.logDebug("session websocket reused", {
+        sessionTransport: "websocket",
+        phase: "connect"
+      });
+    if (owner.channel)
+      yield* metric("reuse");
+    const channel = owner.channel ? owner.channel : yield* open(owner, exchange, key).pipe(Effect.catch((error) => {
+      if (error.reason._tag === "Transport" && error.reason.code === "owner-closed")
+        return Effect.fail(error);
+      owner.httpFallback = true;
+      return Effect.logWarning("session websocket connect failed; using http", {
+        sessionTransport: "websocket",
+        phase: "connect",
+        delivery: "not-sent",
+        code: error.reason._tag === "Transport" ? error.reason.code : error.reason._tag
+      }).pipe(Effect.andThen(metric("connect_failure")), Effect.andThen(metric("fallback")), Effect.as(undefined));
+    }));
+    if (!channel)
+      return fallback(exchange);
+    if (channel.pending) {
+      channel.pending = undefined;
+      channel.checkpoint = undefined;
+    }
+    const create = yield* exchange.driver.create(channel.checkpoint).pipe(Effect.tapError(() => closeChannel(owner, channel)), Effect.onInterrupt(() => closeChannel(owner, channel)));
+    if (create.mode === "full")
+      channel.checkpoint = undefined;
+    yield* Effect.logDebug("session websocket sending", {
+      sessionTransport: "websocket",
+      phase: "send",
+      mode: create.mode
+    });
+    const active = {
+      queue: yield* Queue.bounded(INBOUND_CAPACITY),
+      delivery: "send-attempted"
+    };
+    channel.active = active;
+    const sent = yield* channel.connection.sendText(create.message).pipe(Effect.withSpan("SessionModelTransport.send"), Effect.onInterrupt(() => closeChannel(owner, channel)), Effect.result);
+    if (sent._tag === "Failure") {
+      const failure = new AIError({
+        reason: AIErrorReason.make({
+          ...sent.failure.reason,
+          message: sent.failure.message,
+          cause: sent.failure.reason.cause,
+          http: sent.failure.reason.http ?? channel.connection.http
+        })
+      });
+      const notSent = failure.reason._tag === "Transport" && failure.reason.delivery === "not-sent";
+      yield* closeChannel(owner, channel);
+      if (notSent) {
+        yield* metric("fallback");
+        return fallback(exchange);
+      }
+      yield* metric("ambiguous_delivery");
+      return yield* annotate(failure, { phase: "send", delivery: "ambiguous" });
+    }
+    yield* metric("send");
+    let terminal;
+    const token = {};
+    const frames = Stream.fromQueue(active.queue).pipe(Stream.timeoutOrElse({
+      duration: IDLE_TIMEOUT,
+      orElse: () => Stream.fail(transportError("Timed out waiting for WebSocket data", {
+        url: exchange.connect.url,
+        operation: "read",
+        code: "idle-timeout",
+        phase: "receive",
+        delivery: active.delivery === "provider-observed" ? "accepted" : "ambiguous"
+      }))
+    }), Stream.mapEffect((frame) => exchange.driver.observe(create, frame)), Stream.tap((observation) => Effect.sync(() => {
+      if (!observationTerminal(observation))
+        return;
+      terminal = observation;
+      active.delivery = "terminal";
+      const staged = observation.type === "completed" ? observation.checkpoint : undefined;
+      if (staged)
+        channel.pending = { token, checkpoint: staged };
+      if (observation.type !== "completed" || !staged)
+        channel.checkpoint = undefined;
+    })), Stream.takeUntil(observationTerminal), Stream.mapEffect(observationFrame), Stream.ensuring(Effect.gen(function* () {
+      if (channel.active === active)
+        channel.active = undefined;
+      const pending = yield* Queue.size(active.queue);
+      yield* Queue.shutdown(active.queue);
+      if (terminal && pending === 0) {
+        yield* metric("terminal", { type: terminal.type });
+        if (terminal.type === "rejected")
+          yield* metric("rejection", { recovery: terminal.recovery });
+        if (terminal.type !== "completed" && terminal.type !== "incomplete")
+          yield* closeChannel(owner, channel);
+        return;
+      }
+      yield* metric("cancellation");
+      channel.checkpoint = undefined;
+      channel.pending = undefined;
+      const error = terminal ? transportError("WebSocket data arrived after the terminal event", {
+        url: exchange.connect.url,
+        operation: "read",
+        code: "idle-data",
+        phase: "receive",
+        delivery: "accepted"
+      }) : transportError("Session WebSocket exchange did not reach a terminal event", {
+        url: exchange.connect.url,
+        operation: "read",
+        code: "incomplete",
+        phase: "receive",
+        delivery: active.delivery === "provider-observed" ? "accepted" : "ambiguous"
+      });
+      yield* poison(owner, channel, error);
+    })), Stream.catch((error) => {
+      if (error.reason._tag !== "Transport" || error.reason.code !== "1009" || error.reason.delivery !== "rejected")
+        return Stream.fail(error);
+      owner.httpFallback = true;
+      return Stream.unwrap(Effect.logWarning("session websocket request too large; using http", {
+        sessionTransport: "websocket",
+        phase: "close",
+        delivery: "rejected",
+        code: error.reason.code
+      }).pipe(Effect.andThen(metric("fallback", { reason: "message_too_large" })), Effect.as(exchange.fallback())));
+    }));
+    const complete = Effect.sync(() => {
+      if (owner.channel !== channel || channel.pending?.token !== token)
+        return;
+      channel.checkpoint = channel.pending.checkpoint;
+      channel.pending = undefined;
+    });
+    return { frames, complete, http: channel.connection.http };
+  });
+  const bind = (sessionID) => ({
+    execute: (exchange) => {
+      const owner = state(sessionID);
+      let execution;
+      return Effect.succeed({
+        get http() {
+          return execution?.http;
+        },
+        frames: Stream.unwrap(Effect.acquireRelease(owner.lock.take(1), () => owner.lock.release(1), { interruptible: true }).pipe(Effect.andThen(start(owner, exchange)), Effect.tap((started) => Effect.sync(() => {
+          execution = started;
+        })), Effect.map((started) => started.frames))),
+        complete: Effect.suspend(() => execution?.complete ?? Effect.void)
+      });
+    }
+  });
+  const close = Effect.fn("SessionModelTransport.close")(function* (sessionID) {
+    const owner = states.get(sessionID);
+    if (!owner)
+      return;
+    states.delete(sessionID);
+    owner.closed = true;
+    if (owner.channel)
+      yield* closeChannel(owner, owner.channel);
+  });
+  const closeAll = Effect.suspend(() => {
+    const owners = Array.from(states.values());
+    states.clear();
+    return Effect.forEach(owners, (owner) => {
+      owner.closed = true;
+      return owner.channel ? closeChannel(owner, owner.channel) : Effect.void;
+    }, { discard: true });
+  });
+  yield* Effect.addFinalizer(() => closeAll);
+  return Service26.of({ bind, close, closeAll });
+}));
+var layer10 = Layer.unwrap(Effect.map(Socket.WebSocketConstructor, (constructor) => makeLayer2({
+  open: (input) => WebSocketTransport.open(input).pipe(Effect.provideService(Socket.WebSocketConstructor, constructor))
+})));
+var node31 = makeGlobalNode({ service: Service26, layer: layer10, deps: [webSocketConstructor2] });
+
+export { Service26, makeLayer2, layer10, node31, exports_model_transport };

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

@@ -0,0 +1,105 @@
+// src/database/migration/20260805200742_import_legacy_credentials.ts
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { sql } from "drizzle-orm";
+import { Effect, Option, Schema } from "effect";
+import { Credential } from "@opencode/schema/credential";
+import { Integration } from "@opencode/schema/integration";
+import { NonNegativeInt } from "@opencode/schema/schema";
+import { Global } from "@opencode/util/global";
+var LegacyOAuth = Schema.Struct({
+  type: Schema.Literal("oauth"),
+  refresh: Schema.String,
+  access: Schema.String,
+  expires: NonNegativeInt,
+  accountId: Schema.optional(Schema.String),
+  enterpriseUrl: Schema.optional(Schema.String)
+});
+var LegacyKey = Schema.Struct({
+  type: Schema.Literal("api"),
+  key: Schema.String,
+  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String))
+});
+var LegacyWellKnown = Schema.Struct({
+  type: Schema.Literal("wellknown"),
+  key: Schema.String,
+  token: Schema.String
+});
+var LegacyValue = Schema.Union([LegacyOAuth, LegacyKey, LegacyWellKnown]);
+var decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown));
+var decodeValue = Schema.decodeUnknownOption(LegacyValue);
+var wellKnownSourcesKey = "wellknown:sources";
+var migration = {
+  id: "20260805200742_import_legacy_credentials",
+  up(tx) {
+    return Effect.gen(function* () {
+      const global = yield* Global.Service;
+      return yield* importLegacyCredentials2(tx, path.join(global.data, "auth.json"));
+    });
+  }
+};
+var _20260805200742_import_legacy_credentials_default = migration;
+function importLegacyCredentials2(tx, filepath) {
+  return Effect.gen(function* () {
+    const content = yield* Effect.promise(() => readFile(filepath, "utf8").catch(() => {
+      return;
+    }));
+    if (content === undefined)
+      return;
+    const input = Option.getOrUndefined(decodeJson(content));
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+      return yield* Effect.fail(new Error("Legacy credential file must contain an object"));
+    }
+    const origins = [];
+    for (const [id, raw] of Object.entries(input)) {
+      const value = Option.getOrUndefined(decodeValue(raw));
+      if (!value)
+        continue;
+      const integrationID = id.replace(/\/+$/, "");
+      if (!integrationID)
+        continue;
+      if (value.type === "wellknown")
+        origins.push(integrationID);
+      if (yield* tx.get(sql`SELECT id FROM credential WHERE integration_id = ${integrationID}`))
+        continue;
+      const credential = value.type === "api" ? Credential.Key.make({ type: "key", key: value.key, metadata: value.metadata }) : value.type === "wellknown" ? Credential.Key.make({ type: "key", key: value.token }) : Credential.OAuth.make({
+        type: "oauth",
+        methodID: Integration.MethodID.make(methodID(integrationID)),
+        refresh: value.refresh,
+        access: value.access,
+        expires: value.expires,
+        metadata: value.accountId || value.enterpriseUrl ? {
+          ...value.accountId ? { accountID: value.accountId } : {},
+          ...value.enterpriseUrl ? { enterpriseUrl: value.enterpriseUrl } : {}
+        } : undefined
+      });
+      const label = credential.type === "oauth" ? "OAuth" : "API key";
+      const now = Date.now();
+      yield* tx.run(sql`
+        INSERT INTO credential (id, integration_id, label, value, time_created, time_updated)
+        VALUES (${Credential.ID.create()}, ${integrationID}, ${label}, ${JSON.stringify(credential)}, ${now}, ${now})
+      `);
+    }
+    if (!origins.length)
+      return;
+    const stored = yield* tx.get(sql`SELECT value FROM kv WHERE key = ${wellKnownSourcesKey}`);
+    const decoded = stored ? Option.getOrUndefined(decodeJson(stored.value)) : undefined;
+    const current = Array.isArray(decoded) ? decoded.filter((item) => typeof item === "string") : [];
+    const value = JSON.stringify(Array.from(new Set([...current, ...origins])));
+    const now = Date.now();
+    yield* tx.run(sql`
+      INSERT INTO kv (key, value, time_created, time_updated)
+      VALUES (${wellKnownSourcesKey}, ${value}, ${now}, ${now})
+      ON CONFLICT (key) DO UPDATE SET value = excluded.value, time_updated = excluded.time_updated
+    `);
+  });
+}
+function methodID(integrationID) {
+  if (integrationID === "openai")
+    return "chatgpt-browser";
+  if (["github-copilot", "opencode", "xai"].includes(integrationID))
+    return "device";
+  return "oauth";
+}
+
+export { importLegacyCredentials2, _20260805200742_import_legacy_credentials_default };