@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-yfjv9t1g.js

@@ -0,0 +1,82 @@
+import {
+  AgentNotFoundError2,
+  StepFailedError2,
+  UserInterruptedError2
+} from "./worktree-k7d0894y.js";
+import {
+  BlockedError2
+} from "./worktree-k56d8zdx.js";
+import {
+  AuthorizationError2
+} from "./worktree-g0he3e83.js";
+import {
+  ModelNotSelectedError2,
+  ModelUnavailableError2,
+  VariantUnavailableError2,
+  UnsupportedPackageError2,
+  UnresolvedProviderVariablesError2,
+  UnsupportedCompactionError2
+} from "./worktree-t3vqhd9s.js";
+
+// src/session/to-session-error.ts
+import { AIError, ToolFailure } from "@opencode/ai";
+import { Tool } from "@opencode/schema/tool";
+function toSessionError2(cause) {
+  if (cause instanceof AIError) {
+    switch (cause.reason._tag) {
+      case "RateLimit":
+        return providerError("provider.rate-limit", cause.reason);
+      case "Authentication":
+        return providerError("provider.auth", cause.reason);
+      case "QuotaExceeded":
+        return providerError("provider.quota", cause.reason);
+      case "ContentPolicy":
+        return providerError("provider.content-filter", cause.reason);
+      case "Transport":
+        return providerError("provider.transport", cause.reason);
+      case "ProviderInternal":
+        return providerError("provider.internal", cause.reason);
+      case "InvalidProviderOutput":
+        return providerError("provider.invalid-output", cause.reason);
+      case "InvalidRequest":
+        return providerError("provider.invalid-request", cause.reason);
+      case "UnsupportedOperation":
+        return providerError("provider.unsupported-operation", cause.reason);
+      case "NoRoute":
+        return providerError("provider.no-route", cause.reason);
+      case "UnknownProvider":
+        return providerError("provider.unknown", cause.reason);
+      default: {
+        const exhaustive = cause.reason;
+        return exhaustive;
+      }
+    }
+  }
+  if (cause instanceof BlockedError2)
+    return { type: "permission.rejected", message: cause.message };
+  if (cause instanceof ToolFailure || cause instanceof Tool.Error) {
+    if (cause.error === undefined)
+      return { type: "tool.execution", message: cause.message };
+    const unwrapped = toSessionError2(cause.error);
+    return unwrapped.message === "" ? { ...unwrapped, type: "tool.execution", message: cause.message } : unwrapped;
+  }
+  if (cause instanceof StepFailedError2)
+    return cause.error;
+  if (cause instanceof UnsupportedCompactionError2)
+    return { type: "provider.unsupported-operation", message: cause.message };
+  if (cause instanceof AgentNotFoundError2)
+    return { type: "unknown", message: cause.message };
+  if (cause instanceof UserInterruptedError2)
+    return { type: "aborted", message: cause.message };
+  if (cause instanceof ModelNotSelectedError2 || cause instanceof ModelUnavailableError2 || cause instanceof VariantUnavailableError2 || cause instanceof UnsupportedPackageError2 || cause instanceof UnresolvedProviderVariablesError2)
+    return { type: "provider.no-route", message: cause.message };
+  if (cause instanceof AuthorizationError2)
+    return { type: "provider.auth", message: cause.message };
+  return { type: "unknown", message: cause instanceof Error ? cause.message : String(cause) };
+}
+function providerError(type, reason) {
+  const status = reason.http?.status;
+  return { type, message: reason.message, ...status === undefined ? {} : { status } };
+}
+
+export { toSessionError2 };

package/dist/chunks/worktree-ygaqb7jw.js

@@ -0,0 +1,25 @@
+// src/database/migration/20260611035744_credential.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260611035744_credential",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`credential\` (
+          \`id\` text PRIMARY KEY,
+          \`connector_id\` text NOT NULL,
+          \`method_id\` text NOT NULL,
+          \`label\` text NOT NULL,
+          \`value\` text NOT NULL,
+          \`active\` integer DEFAULT false NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL
+        );
+      `);
+      yield* tx.run(`CREATE UNIQUE INDEX \`credential_connector_active_idx\` ON \`credential\` (\`connector_id\`) WHERE "credential"."active" = 1;`);
+    });
+  }
+};
+var _20260611035744_credential_default = migration;
+
+export { _20260611035744_credential_default };

package/dist/chunks/worktree-ym463w8f.js

@@ -0,0 +1,17 @@
+// src/plugin/provider/factory.ts
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect } from "effect";
+function createProviderPlugin2(input) {
+  return define({
+    id: input.id,
+    effect: Effect.fn(function* (ctx) {
+      yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+        if (evt.package !== input.package)
+          return;
+        evt.sdk = yield* Effect.promise(() => input.load(evt.options));
+      }));
+    })
+  });
+}
+
+export { createProviderPlugin2 };

package/dist/chunks/worktree-yp2x3t23.js

@@ -0,0 +1,92 @@
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/session/run-coordinator.ts
+var exports_run_coordinator = {};
+__export(exports_run_coordinator, {
+  SessionRunCoordinator: () => exports_run_coordinator,
+  make: () => make16
+});
+import { Deferred, Effect, Fiber, FiberSet } from "effect";
+var make16 = (options) => Effect.gen(function* () {
+  const executions = new Map;
+  const fork = yield* FiberSet.makeRuntime();
+  const loop = (key, execution, force) => Effect.suspend(() => options.drain(key, force, execution.scope)).pipe(Effect.andThen(Effect.suspend(() => {
+    if (execution.stopping || execution.pendingWake === undefined)
+      return Effect.void;
+    execution.scope = execution.pendingWake;
+    execution.pendingWake = undefined;
+    return Effect.yieldNow.pipe(Effect.andThen(loop(key, execution, false)));
+  })));
+  const start = (key, force, scope) => {
+    const execution = {
+      done: Deferred.makeUnsafe(),
+      scope,
+      stopping: false
+    };
+    executions.set(key, execution);
+    execution.owner = fork(Effect.yieldNow.pipe(Effect.andThen(Effect.uninterruptible(options.started?.(key) ?? Effect.void)), Effect.andThen(loop(key, execution, force)), Effect.onExit((exit) => Effect.sync(() => {
+      execution.owner = undefined;
+    }).pipe(Effect.andThen(options.settled?.(key, exit, execution.interruptionReason) ?? Effect.void))), Effect.onExit((exit) => Effect.sync(() => settle(key, execution, exit))), Effect.exit, Effect.asVoid));
+    return execution;
+  };
+  const settle = (key, execution, exit) => {
+    if (execution.pendingWake)
+      start(key, false, execution.pendingWake);
+    else
+      executions.delete(key);
+    Deferred.doneUnsafe(execution.done, exit);
+  };
+  const isActive = (key) => Effect.sync(() => executions.has(key));
+  const run = (key) => Effect.suspend(() => {
+    const execution = executions.get(key);
+    if (execution !== undefined) {
+      if (execution.stopping)
+        return Deferred.await(execution.done).pipe(Effect.ignoreCause, Effect.andThen(run(key)));
+      return Deferred.await(execution.done);
+    }
+    return Deferred.await(start(key, true, "input").done);
+  });
+  const wake = (key, scope = "input") => Effect.sync(() => {
+    const execution = executions.get(key);
+    if (execution !== undefined) {
+      execution.pendingWake = execution.pendingWake === "input" ? "input" : scope;
+      return;
+    }
+    start(key, false, scope);
+  });
+  const interrupt = (key, reason) => Effect.sync(() => {
+    const execution = executions.get(key);
+    if (execution === undefined || execution.stopping)
+      return false;
+    if (execution.owner === undefined) {
+      execution.pendingWake = undefined;
+      return false;
+    }
+    execution.stopping = true;
+    execution.pendingWake = undefined;
+    execution.interruptionReason = reason;
+    fork(Fiber.interrupt(execution.owner));
+    return true;
+  });
+  const awaitIdle = (key) => Effect.suspend(() => {
+    const execution = executions.get(key);
+    if (execution === undefined)
+      return Effect.void;
+    return Deferred.await(execution.done).pipe(Effect.ignoreCause, Effect.andThen(awaitIdle(key)));
+  });
+  return {
+    active: Effect.sync(() => new Set(executions.keys())),
+    isActive,
+    run,
+    wake,
+    interrupt: (key, reason, options) => Effect.suspend(() => {
+      const execution = executions.get(key);
+      return interrupt(key, reason).pipe(Effect.tap(() => options?.awaitSettlement && execution ? Deferred.await(execution.done).pipe(Effect.ignoreCause) : Effect.void));
+    }),
+    awaitIdle
+  };
+});
+
+export { make16, exports_run_coordinator };

package/dist/chunks/worktree-yrhqyw5v.js

@@ -0,0 +1,15 @@
+import {
+  createProviderPlugin2
+} from "./worktree-ym463w8f.js";
+
+// src/plugin/provider/venice.ts
+var VenicePlugin2 = createProviderPlugin2({
+  id: "opencode.provider.venice",
+  package: "venice-ai-sdk-provider",
+  load: async (options) => {
+    const { createVenice } = await import("venice-ai-sdk-provider");
+    return createVenice(options);
+  }
+});
+
+export { VenicePlugin2 };

package/dist/chunks/worktree-yrznvahk.js

@@ -0,0 +1,60 @@
+import {
+  InvalidError2
+} from "./worktree-z63w68vq.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/config/variable.ts
+var exports_variable = {};
+__export(exports_variable, {
+  ConfigVariable: () => exports_variable,
+  substitute: () => substitute2
+});
+import os from "os";
+import path from "path";
+import { Effect } from "effect";
+import { FSUtil } from "@opencode/util/fs-util";
+var substitute2 = Effect.fn("ConfigVariable.substitute")(function* (input) {
+  const text = input.text.replace(/\{env:([^}]+)\}/g, (_, varName) => (input.env?.[varName] ?? process.env[varName]) || "");
+  if (!text.includes("{file:"))
+    return text;
+  return yield* substituteFiles(input, text);
+});
+var substituteFiles = Effect.fnUntraced(function* (input, text) {
+  const fs = yield* FSUtil.Service;
+  const configDir = input.type === "path" ? path.dirname(input.path) : input.dir;
+  const configSource = input.type === "path" ? input.path : input.source;
+  let out = "";
+  let cursor = 0;
+  for (const match of text.matchAll(/\{file:[^}]+\}/g)) {
+    const token = match[0];
+    const index = match.index;
+    out += text.slice(cursor, index);
+    const lineStart = text.lastIndexOf(`
+`, index - 1) + 1;
+    const prefix = text.slice(lineStart, index).trimStart();
+    if (prefix.startsWith("//")) {
+      out += token;
+      cursor = index + token.length;
+      continue;
+    }
+    const filePath = token.slice("{file:".length, -1);
+    const expandedPath = filePath.startsWith("~/") ? path.join(os.homedir(), filePath.slice(2)) : filePath;
+    const resolvedPath = path.isAbsolute(expandedPath) ? expandedPath : path.resolve(configDir, expandedPath);
+    const fileContent = yield* fs.readFileString(resolvedPath).pipe(Effect.catch((error) => {
+      if (input.missing === "empty")
+        return Effect.succeed("");
+      const message = `bad file reference: "${token}"`;
+      return Effect.fail(new InvalidError2({
+        path: configSource,
+        message: error._tag === "PlatformError" && error.reason._tag === "NotFound" ? `${message} ${resolvedPath} does not exist` : message
+      }, { cause: error }));
+    }));
+    out += JSON.stringify(fileContent.trim()).slice(1, -1);
+    cursor = index + token.length;
+  }
+  return out + text.slice(cursor);
+});
+
+export { substitute2, exports_variable };

package/dist/chunks/worktree-z0bkrqjs.js

@@ -0,0 +1,15 @@
+import {
+  createProviderPlugin2
+} from "./worktree-ym463w8f.js";
+
+// src/plugin/provider/cohere.ts
+var CoherePlugin2 = createProviderPlugin2({
+  id: "opencode.provider.cohere",
+  package: "@ai-sdk/cohere",
+  load: async (options) => {
+    const { createCohere } = await import("@ai-sdk/cohere");
+    return createCohere(options);
+  }
+});
+
+export { CoherePlugin2 };

package/dist/chunks/worktree-z0kan0ff.js

@@ -0,0 +1,118 @@
+import {
+  useragent2
+} from "./worktree-xrd4famk.js";
+import {
+  ID12
+} from "./worktree-9qn3qky1.js";
+import {
+  iife2
+} from "./worktree-1kg9ymc8.js";
+import {
+  configuredSettings2
+} from "./worktree-asseqh46.js";
+
+// src/plugin/provider/cloudflare-ai-gateway.ts
+import os from "os";
+import { Effect, Option, Schema } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+import { Form } from "@opencode/schema/form";
+var providerID = ID12.make("cloudflare-ai-gateway");
+var CloudflareAIGatewayPlugin2 = define({
+  id: "opencode.provider.cloudflare.ai.gateway",
+  effect: Effect.fn(function* (ctx) {
+    const configured = yield* configuredSettings2(providerID);
+    const form = iife2(() => {
+      if (typeof configured?.baseURL === "string")
+        return;
+      const accountId = process.env.CLOUDFLARE_ACCOUNT_ID || stringOption(configured ?? {}, "accountId");
+      const gatewayId = process.env.CLOUDFLARE_GATEWAY_ID || stringOption(configured ?? {}, "gatewayId") || stringOption(configured ?? {}, "gateway");
+      if (accountId && gatewayId)
+        return;
+      const accountIdForm = Form.StringField.make({
+        type: "string",
+        key: "accountId",
+        title: "Enter your Cloudflare Account ID",
+        placeholder: "e.g. 1234567890abcdef1234567890abcdef",
+        required: true
+      });
+      const gatewayIdForm = Form.StringField.make({
+        type: "string",
+        key: "gatewayId",
+        title: "Enter your Cloudflare AI Gateway ID",
+        placeholder: "e.g. my-gateway",
+        required: true
+      });
+      if (accountId)
+        return Form.Fields.make([gatewayIdForm]);
+      if (gatewayId)
+        return Form.Fields.make([accountIdForm]);
+      return Form.Fields.make([accountIdForm, gatewayIdForm]);
+    });
+    yield* ctx.integration.transform((editor) => {
+      editor.method.update({
+        integrationID: providerID,
+        method: {
+          type: "key",
+          label: "Gateway API token",
+          form
+        }
+      });
+    });
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.package !== "ai-gateway-provider")
+        return;
+      if (evt.options.baseURL)
+        return;
+      const config = gatewayConfig(evt.options);
+      if (!config)
+        return;
+      const metadata = gatewayMetadata(evt.options);
+      const { createAiGateway } = yield* Effect.promise(() => import("ai-gateway-provider"));
+      const { createUnified } = yield* Effect.promise(() => import("ai-gateway-provider/providers/unified"));
+      const gateway = createAiGateway({
+        accountId: config.accountId,
+        gateway: config.gatewayId,
+        apiKey: config.apiKey,
+        options: gatewayOptions(evt.options, metadata, ctx.app)
+      });
+      const unified = createUnified({ apiKey: config.apiKey });
+      evt.sdk = {
+        languageModel(modelID) {
+          return gateway(unified(modelID));
+        }
+      };
+    }));
+  })
+});
+var decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown));
+function gatewayConfig(options) {
+  const accountId = process.env.CLOUDFLARE_ACCOUNT_ID ?? stringOption(options, "accountId");
+  const gatewayId = process.env.CLOUDFLARE_GATEWAY_ID ?? stringOption(options, "gatewayId") ?? stringOption(options, "gateway");
+  const apiKey = process.env.CLOUDFLARE_API_TOKEN ?? process.env.CF_AIG_TOKEN ?? stringOption(options, "apiKey");
+  if (!accountId || !gatewayId || !apiKey)
+    return;
+  return { accountId, gatewayId, apiKey };
+}
+function gatewayMetadata(options) {
+  if (options.metadata !== undefined)
+    return options.metadata;
+  const raw = options.headers?.["cf-aig-metadata"];
+  return raw ? Option.getOrUndefined(decodeJson(raw)) : undefined;
+}
+function gatewayOptions(options, metadata, app) {
+  return {
+    metadata,
+    cacheTtl: options.cacheTtl,
+    cacheKey: options.cacheKey,
+    skipCache: options.skipCache,
+    collectLog: options.collectLog,
+    headers: {
+      "User-Agent": `${useragent2(app)} cloudflare-ai-gateway (${os.platform()} ${os.release()}; ${os.arch()})`
+    }
+  };
+}
+function stringOption(options, key) {
+  return typeof options[key] === "string" ? options[key] : undefined;
+}
+
+export { CloudflareAIGatewayPlugin2 };

package/dist/chunks/worktree-z63w68vq.js

@@ -0,0 +1,46 @@
+import {
+  NamedError2
+} from "./worktree-2axfhc9x.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/v1/config/error.ts
+var exports_error = {};
+__export(exports_error, {
+  ConfigErrorV1: () => exports_error,
+  DirectoryTypoError: () => DirectoryTypoError2,
+  FrontmatterError: () => FrontmatterError2,
+  InvalidError: () => InvalidError2,
+  JsonError: () => JsonError2,
+  RemoteAuthError: () => RemoteAuthError2
+});
+import { Schema } from "effect";
+var Issue = Schema.StructWithRest(Schema.Struct({
+  message: Schema.String,
+  path: Schema.Array(Schema.String)
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+var JsonError2 = NamedError2.create("ConfigJsonError", {
+  path: Schema.String,
+  message: Schema.optional(Schema.String)
+});
+var InvalidError2 = NamedError2.create("ConfigInvalidError", {
+  path: Schema.String,
+  issues: Schema.optional(Schema.Array(Issue)),
+  message: Schema.optional(Schema.String)
+});
+var FrontmatterError2 = NamedError2.create("ConfigFrontmatterError", {
+  path: Schema.String,
+  message: Schema.String
+});
+var DirectoryTypoError2 = NamedError2.create("ConfigDirectoryTypoError", {
+  path: Schema.String,
+  dir: Schema.String,
+  suggestion: Schema.String
+});
+var RemoteAuthError2 = NamedError2.create("ConfigRemoteAuthError", {
+  url: Schema.String,
+  remote: Schema.String
+});
+
+export { JsonError2, InvalidError2, FrontmatterError2, DirectoryTypoError2, RemoteAuthError2, exports_error };

package/dist/chunks/worktree-z82wee6n.js

@@ -0,0 +1,43 @@
+import {
+  Service75,
+  node80
+} from "./worktree-a8mtf1n7.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/location.ts
+var exports_location = {};
+__export(exports_location, {
+  Info: () => Info31,
+  Location: () => exports_location,
+  Ref: () => Ref4,
+  Service: () => Service74,
+  boundNode: () => boundNode2,
+  node: () => node79,
+  response: () => response2
+});
+import { Context, Effect, Layer } from "effect";
+import { Info as Info31, Ref as Ref4, response as response2 } from "@opencode/schema/location";
+import { LayerNode } from "@opencode/util/effect/layer-node";
+import { makeLocationNode, tags } from "@opencode/util/effect/app-node";
+class Service74 extends Context.Service()("@opencode/Location") {
+}
+var node79 = LayerNode.unbound(Service74, tags.values.location);
+var layer = (ref, options) => Layer.effect(Service74, Effect.gen(function* () {
+  const project = yield* Service75;
+  const resolved = yield* project.resolve(ref.directory, options);
+  return Service74.of({
+    directory: ref.directory,
+    workspaceID: ref.workspaceID,
+    project: { id: resolved.id, directory: resolved.directory, canonical: resolved.canonical },
+    vcs: resolved.vcs
+  });
+}));
+var boundNode2 = (ref, options) => makeLocationNode({
+  service: Service74,
+  layer: layer(ref, options),
+  deps: [node80]
+});
+
+export { Info31, Ref4, response2, Service74, node79, boundNode2, exports_location };

package/dist/chunks/worktree-z9919s4g.js

@@ -0,0 +1,16 @@
+// src/database/migration/20260423070820_add_icon_url_override.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260423070820_add_icon_url_override",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        ALTER TABLE \`project\` ADD \`icon_url_override\` text;
+        UPDATE \`project\` SET \`icon_url_override\` = \`icon_url\` WHERE \`icon_url\` IS NOT NULL;
+      `);
+    });
+  }
+};
+var _20260423070820_add_icon_url_override_default = migration;
+
+export { _20260423070820_add_icon_url_override_default };

package/dist/chunks/worktree-zeh9ct20.js

@@ -0,0 +1,29 @@
+import {
+  PositiveInt2
+} from "./worktree-922hggd3.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/v1/config/server.ts
+var exports_server = {};
+__export(exports_server, {
+  ConfigServerV1: () => exports_server,
+  Server: () => Server2
+});
+import { Schema } from "effect";
+var Server2 = Schema.Struct({
+  port: Schema.optional(PositiveInt2).annotate({
+    description: "Port to listen on"
+  }),
+  hostname: Schema.optional(Schema.String).annotate({ description: "Hostname to listen on" }),
+  mdns: Schema.optional(Schema.Boolean).annotate({ description: "Enable mDNS service discovery" }),
+  mdnsDomain: Schema.optional(Schema.String).annotate({
+    description: "Custom domain name for mDNS service (default: opencode.local)"
+  }),
+  cors: Schema.optional(Schema.mutable(Schema.Array(Schema.String))).annotate({
+    description: "Additional domains to allow for CORS"
+  })
+}).annotate({ identifier: "ServerConfig" });
+
+export { Server2, exports_server };