@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-0zz82cjq.js

@@ -0,0 +1,17 @@
+// src/plugin/provider/factory.ts
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect } from "effect";
+function createProviderPlugin(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 { createProviderPlugin };

package/dist/chunks/location-mutation-10xtr3be.js

@@ -0,0 +1,34 @@
+import {
+  exports_provider
+} from "./location-mutation-d6vvk673.js";
+import {
+  __require
+} from "./location-mutation-rvfvac9x.js";
+
+// src/plugin/provider/cerebras.ts
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+var CerebrasPlugin = define({
+  id: "opencode.provider.cerebras",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (!exports_provider.isAISDK(item.provider.package))
+          continue;
+        if (exports_provider.packageName(item.provider.package) !== "@ai-sdk/cerebras")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = { ...provider.headers, "X-Cerebras-3rd-Party-Integration": "opencode" };
+        });
+      }
+    });
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.package !== "@ai-sdk/cerebras")
+        return;
+      const mod = yield* Effect.promise(() => import("@ai-sdk/cerebras"));
+      evt.sdk = mod.createCerebras(evt.options);
+    }));
+  })
+});
+
+export { CerebrasPlugin };

package/dist/chunks/location-mutation-18pv8fg3.js

@@ -0,0 +1,98 @@
+import {
+  PositiveInt
+} from "./location-mutation-j07kk359.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/v1/config/provider.ts
+var exports_provider = {};
+__export(exports_provider, {
+  ModelStatus: () => ModelStatus,
+  Model: () => Model,
+  Info: () => Info,
+  ConfigProviderV1: () => exports_provider
+});
+import { Schema } from "effect";
+var ModelStatus = Schema.Literals(["alpha", "beta", "deprecated", "active"]);
+var Model = Schema.Struct({
+  id: Schema.optional(Schema.String),
+  name: Schema.optional(Schema.String),
+  family: Schema.optional(Schema.String),
+  release_date: Schema.optional(Schema.String),
+  attachment: Schema.optional(Schema.Boolean),
+  reasoning: Schema.optional(Schema.Boolean),
+  temperature: Schema.optional(Schema.Boolean),
+  tool_call: Schema.optional(Schema.Boolean),
+  interleaved: Schema.optional(Schema.Union([
+    Schema.Boolean,
+    Schema.String,
+    Schema.Struct({
+      field: Schema.String
+    })
+  ])),
+  cost: Schema.optional(Schema.Struct({
+    input: Schema.Finite,
+    output: Schema.Finite,
+    cache_read: Schema.optional(Schema.Finite),
+    cache_write: Schema.optional(Schema.Finite),
+    context_over_200k: Schema.optional(Schema.Struct({
+      input: Schema.Finite,
+      output: Schema.Finite,
+      cache_read: Schema.optional(Schema.Finite),
+      cache_write: Schema.optional(Schema.Finite)
+    }))
+  })),
+  limit: Schema.optional(Schema.Struct({
+    context: Schema.Finite,
+    input: Schema.optional(Schema.Finite),
+    output: Schema.Finite
+  })),
+  modalities: Schema.optional(Schema.Struct({
+    input: Schema.optional(Schema.mutable(Schema.Array(Schema.Literals(["text", "audio", "image", "video", "pdf"])))),
+    output: Schema.optional(Schema.mutable(Schema.Array(Schema.Literals(["text", "audio", "image", "video", "pdf"]))))
+  })),
+  experimental: Schema.optional(Schema.Boolean),
+  status: Schema.optional(ModelStatus),
+  provider: Schema.optional(Schema.Struct({ npm: Schema.optional(Schema.String), api: Schema.optional(Schema.String) })),
+  options: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
+  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+  variants: Schema.optional(Schema.Record(Schema.String, Schema.StructWithRest(Schema.Struct({
+    disabled: Schema.optional(Schema.Boolean).annotate({ description: "Disable this variant for the model" })
+  }), [Schema.Record(Schema.String, Schema.Any)])).annotate({ description: "Variant-specific configuration" }))
+});
+var Info = Schema.Struct({
+  api: Schema.optional(Schema.String),
+  name: Schema.optional(Schema.String),
+  env: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
+  id: Schema.optional(Schema.String),
+  npm: Schema.optional(Schema.String),
+  whitelist: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
+  blacklist: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
+  options: Schema.optional(Schema.StructWithRest(Schema.Struct({
+    apiKey: Schema.optional(Schema.String),
+    baseURL: Schema.optional(Schema.String),
+    enterpriseUrl: Schema.optional(Schema.String).annotate({
+      description: "GitHub Enterprise URL for copilot authentication"
+    }),
+    setCacheKey: Schema.optional(Schema.Boolean).annotate({
+      description: "Enable promptCacheKey for this provider (default false)"
+    }),
+    timeout: Schema.optional(Schema.Union([PositiveInt, Schema.Literal(false)]).annotate({
+      description: "Timeout in milliseconds for full requests to this provider. Set to false to disable timeout."
+    })).annotate({
+      description: "Timeout in milliseconds for full requests to this provider. Set to false to disable timeout."
+    }),
+    headerTimeout: Schema.optional(Schema.Union([PositiveInt, Schema.Literal(false)]).annotate({
+      description: "Timeout in milliseconds to wait for response headers. Provider integrations may set defaults. Set to false to disable timeout."
+    })).annotate({
+      description: "Timeout in milliseconds to wait for response headers. Provider integrations may set defaults. Set to false to disable timeout."
+    }),
+    chunkTimeout: Schema.optional(PositiveInt).annotate({
+      description: "Timeout in milliseconds between streamed SSE chunks for this provider. If no chunk arrives within this window, the request is aborted."
+    })
+  }), [Schema.Record(Schema.String, Schema.Any)])),
+  models: Schema.optional(Schema.Record(Schema.String, Model))
+}).annotate({ identifier: "ProviderConfig" });
+
+export { ModelStatus, Model, Info, exports_provider };

package/dist/chunks/location-mutation-1c00jchy.js

@@ -0,0 +1,64 @@
+import {
+  collectBoundedResponseBody
+} from "./location-mutation-jve7t217.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/plugin/websearch/mcp.ts
+var exports_mcp = {};
+__export(exports_mcp, {
+  parseResponse: () => parseResponse,
+  call: () => call,
+  WebSearchMcp: () => exports_mcp,
+  MAX_RESPONSE_BYTES: () => MAX_RESPONSE_BYTES
+});
+import { Duration, Effect, Schema } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/unstable/http";
+var MAX_RESPONSE_BYTES = 256 * 1024;
+var parseResponse = (body, result) => {
+  const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Struct({ result })));
+  const parse = (payload) => {
+    const trimmed = payload.trim();
+    if (!trimmed.startsWith("{"))
+      return Effect.succeed(undefined);
+    return decode(trimmed).pipe(Effect.map((response) => response.result));
+  };
+  return Effect.gen(function* () {
+    const trimmed = body.trim();
+    const direct = trimmed ? yield* parse(trimmed) : undefined;
+    if (direct)
+      return direct;
+    for (const line of body.split(`
+`)) {
+      if (!line.startsWith("data: "))
+        continue;
+      const data = yield* parse(line.substring(6));
+      if (data)
+        return data;
+    }
+  });
+};
+var call = (http, url, tool, schema, value, headers = {}) => Effect.gen(function* () {
+  const request = yield* HttpClientRequest.post(url).pipe(HttpClientRequest.accept("application/json, text/event-stream"), HttpClientRequest.setHeaders(headers), HttpClientRequest.schemaBodyJson(Schema.Struct({
+    jsonrpc: Schema.Literal("2.0"),
+    id: Schema.Literal(1),
+    method: Schema.Literal("tools/call"),
+    params: Schema.Struct({ name: Schema.String, arguments: schema.input })
+  }))({
+    jsonrpc: "2.0",
+    id: 1,
+    method: "tools/call",
+    params: { name: tool, arguments: value }
+  }));
+  return yield* Effect.gen(function* () {
+    const response = yield* HttpClient.filterStatusOk(http).execute(request);
+    const body = yield* collectBoundedResponseBody(response, MAX_RESPONSE_BYTES, () => new Error(`${tool} response exceeded ${MAX_RESPONSE_BYTES} bytes`));
+    return yield* parseResponse(body.toString("utf8"), schema.output);
+  }).pipe(Effect.timeoutOrElse({
+    duration: Duration.seconds(25),
+    orElse: () => Effect.fail(new Error(`${tool} request timed out`))
+  }));
+});
+
+export { MAX_RESPONSE_BYTES, parseResponse, call, exports_mcp };

package/dist/chunks/location-mutation-1f30npvx.js

@@ -0,0 +1,72 @@
+import {
+  exports_schema
+} from "./location-mutation-y8rs54ne.js";
+import {
+  exports_agent
+} from "./location-mutation-0ms0v4tv.js";
+import {
+  exports_model
+} from "./location-mutation-xfd1xnk3.js";
+import {
+  exports_provider
+} from "./location-mutation-d6vvk673.js";
+import {
+  exports_workspace
+} from "./location-mutation-1mtx69dw.js";
+import {
+  exports_location
+} from "./location-mutation-57ntp81p.js";
+import {
+  exports_project
+} from "./location-mutation-sbx2darh.js";
+import {
+  AbsolutePath,
+  RelativePath
+} from "./location-mutation-j07kk359.js";
+
+// src/session/info.ts
+import { DateTime, Schema } from "effect";
+import { PersistedRevert } from "@opencode-ai/schema/session-revert";
+import { Money } from "@opencode-ai/schema/money";
+var decodeRevert = Schema.decodeUnknownSync(PersistedRevert);
+function fromRow(row) {
+  return exports_schema.Info.make({
+    id: exports_schema.ID.make(row.id),
+    projectID: exports_project.ID.make(row.project_id),
+    title: row.title ?? undefined,
+    parentID: row.parent_id ? exports_schema.ID.make(row.parent_id) : undefined,
+    fork: row.fork_session_id && row.fork_boundary ? {
+      sessionID: exports_schema.ID.make(row.fork_session_id),
+      boundary: row.fork_boundary
+    } : undefined,
+    agent: row.agent ? exports_agent.ID.make(row.agent) : undefined,
+    model: row.model ? {
+      id: exports_model.ID.make(row.model.id),
+      providerID: exports_provider.ID.make(row.model.providerID),
+      variant: exports_model.VariantID.make(row.model.variant ?? "default")
+    } : undefined,
+    cost: Money.USD.make(row.cost),
+    tokens: {
+      input: row.tokens_input,
+      output: row.tokens_output,
+      reasoning: row.tokens_reasoning,
+      cache: {
+        read: row.tokens_cache_read,
+        write: row.tokens_cache_write
+      }
+    },
+    location: exports_location.Ref.make({
+      directory: AbsolutePath.make(row.directory),
+      workspaceID: row.workspace_id ? exports_workspace.ID.make(row.workspace_id) : undefined
+    }),
+    subpath: row.path ? RelativePath.make(row.path) : undefined,
+    revert: row.revert ? decodeRevert(row.revert) : undefined,
+    time: {
+      created: DateTime.makeUnsafe(row.time_created),
+      updated: DateTime.makeUnsafe(row.time_updated),
+      archived: row.time_archived ? DateTime.makeUnsafe(row.time_archived) : undefined
+    }
+  });
+}
+
+export { fromRow };

package/dist/chunks/location-mutation-1fb7bmpf.js

@@ -0,0 +1,15 @@
+// src/database/migration/20260511173437_session-metadata.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260511173437_session-metadata",
+  up(tx) {
+    return Effect.gen(function* () {
+      if ((yield* tx.all(`PRAGMA table_info(\`session\`)`)).some((column) => column.name === "metadata"))
+        return;
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`metadata\` text;`);
+    });
+  }
+};
+var _20260511173437_session_metadata_default = migration;
+
+export { _20260511173437_session_metadata_default };

package/dist/chunks/location-mutation-1kedsd2h.js

@@ -0,0 +1,286 @@
+import {
+  ID
+} from "./location-mutation-tvmhrvfj.js";
+import {
+  exports_select
+} from "./location-mutation-04kwjb53.js";
+import {
+  exports_config
+} from "./location-mutation-qvf5nvg0.js";
+import {
+  lazy
+} from "./location-mutation-8w9tzfz1.js";
+import {
+  exports_location
+} from "./location-mutation-57ntp81p.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+import {
+  __export,
+  __require
+} from "./location-mutation-rvfvac9x.js";
+
+// src/pty.ts
+var exports_pty = {};
+__export(exports_pty, {
+  node: () => node,
+  layer: () => layer,
+  configured: () => configured,
+  UpdateInput: () => UpdateInput,
+  Service: () => Service,
+  Pty: () => exports_pty,
+  NotFoundError: () => NotFoundError,
+  Info: () => Info,
+  ExitedError: () => ExitedError,
+  Event: () => Event,
+  CreateInput: () => CreateInput
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Pty } from "@opencode-ai/schema/pty";
+import { Global } from "@opencode-ai/util/global";
+import { Event } from "@opencode-ai/schema/pty";
+var BUFFER_LIMIT = 1024 * 1024 * 2;
+var EXITED_LIMIT = 25;
+var pty = lazy(() => import("#pty"));
+var Info = Pty.Info;
+var CreateInput = Pty.CreateInput;
+var UpdateInput = Pty.UpdateInput;
+
+class NotFoundError extends Schema.TaggedErrorClass()("Pty.NotFoundError", {
+  ptyID: ID
+}) {
+}
+
+class ExitedError extends Schema.TaggedErrorClass()("Pty.ExitedError", {
+  ptyID: ID
+}) {
+}
+
+class Service extends Context.Service()("@opencode/Pty") {
+}
+var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const location = yield* exports_location.Service;
+  const config = yield* exports_config.Service;
+  const global = yield* Global.Service;
+  const context = yield* Effect.context();
+  const runFork = Effect.runForkWith(context);
+  const sessions = new Map;
+  const exitOrder = [];
+  function notifyEnd(session, event) {
+    for (const subscriber of session.subscribers.values()) {
+      if (!subscriber.active) {
+        subscriber.end = event;
+        continue;
+      }
+      try {
+        subscriber.onEnd(event);
+      } catch {}
+    }
+    session.subscribers.clear();
+  }
+  function teardown(session) {
+    for (const listener of session.listeners)
+      listener.dispose();
+    session.listeners.length = 0;
+    if (session.info.status === "running") {
+      try {
+        session.process.kill();
+      } catch {}
+    }
+    notifyEnd(session, {});
+  }
+  yield* Effect.addFinalizer(() => Effect.sync(() => {
+    for (const session of sessions.values())
+      teardown(session);
+    sessions.clear();
+    exitOrder.length = 0;
+  }));
+  const requireSession = Effect.fn("Pty.requireSession")(function* (id) {
+    const session = sessions.get(id);
+    if (!session)
+      return yield* new NotFoundError({ ptyID: id });
+    return session;
+  });
+  const removeSession = Effect.fnUntraced(function* (id) {
+    const session = sessions.get(id);
+    if (!session)
+      return;
+    sessions.delete(id);
+    const index = exitOrder.indexOf(id);
+    if (index !== -1)
+      exitOrder.splice(index, 1);
+    yield* Effect.logInfo("removing session", { id });
+    teardown(session);
+    yield* bus.publish(Pty.Event.Deleted, { id: session.info.id });
+  });
+  const remove = Effect.fn("Pty.remove")(function* (id) {
+    yield* requireSession(id);
+    yield* removeSession(id);
+  });
+  const list = Effect.fn("Pty.list")(function* () {
+    return Array.from(sessions.values()).map((session) => session.info);
+  });
+  const get = Effect.fn("Pty.get")(function* (id) {
+    return (yield* requireSession(id)).info;
+  });
+  const create = Effect.fn("Pty.create")(function* (input) {
+    const id = ID.ascending();
+    const command = input.command || exports_select.preferred(exports_config.latest(yield* config.entries(), "shell"), options, global.bin);
+    const args = exports_select.login(command) ? [...input.args ?? [], "-l"] : [...input.args ?? []];
+    const cwd = input.cwd || location.directory;
+    const env = {
+      ...process.env,
+      ...input.env,
+      TERM: "xterm-256color",
+      OPENCODE_TERMINAL: "1"
+    };
+    if (process.platform === "win32") {
+      env.LC_ALL = "C.UTF-8";
+      env.LC_CTYPE = "C.UTF-8";
+      env.LANG = "C.UTF-8";
+    }
+    yield* Effect.logInfo("creating session", { id, cmd: command, args, cwd });
+    const { spawn } = yield* Effect.promise(() => pty());
+    const proc = yield* Effect.sync(() => spawn(command, args, { name: "xterm-256color", cwd, env }));
+    const info = {
+      id,
+      title: input.title || `Terminal ${id.slice(-4)}`,
+      command,
+      args,
+      cwd,
+      status: "running",
+      pid: proc.pid
+    };
+    const session = {
+      info,
+      process: proc,
+      buffer: "",
+      bufferCursor: 0,
+      cursor: 0,
+      subscribers: new Map,
+      listeners: []
+    };
+    sessions.set(id, session);
+    session.listeners.push(proc.onData((chunk) => {
+      session.cursor += chunk.length;
+      for (const [token, subscriber] of session.subscribers.entries()) {
+        if (!subscriber.active) {
+          subscriber.pending.push(chunk);
+          continue;
+        }
+        try {
+          subscriber.onData(chunk);
+        } catch {
+          session.subscribers.delete(token);
+        }
+      }
+      session.buffer += chunk;
+      if (session.buffer.length <= BUFFER_LIMIT)
+        return;
+      const excess = session.buffer.length - BUFFER_LIMIT;
+      session.buffer = session.buffer.slice(excess);
+      session.bufferCursor += excess;
+    }), proc.onExit(({ exitCode }) => {
+      if (session.info.status === "exited")
+        return;
+      session.info.status = "exited";
+      session.info.exitCode = exitCode;
+      notifyEnd(session, { exitCode });
+      exitOrder.push(id);
+      runFork(Effect.gen(function* () {
+        yield* Effect.logInfo("session exited", { id, exitCode });
+        yield* bus.publish(Pty.Event.Exited, { id, exitCode });
+        while (exitOrder.length > EXITED_LIMIT) {
+          const oldest = exitOrder[0];
+          if (!oldest)
+            break;
+          yield* removeSession(oldest);
+        }
+      }));
+    }));
+    yield* bus.publish(Pty.Event.Created, { info });
+    return info;
+  });
+  const update = Effect.fn("Pty.update")(function* (id, input) {
+    const session = yield* requireSession(id);
+    if (input.title)
+      session.info.title = input.title;
+    if (input.size && session.info.status === "running")
+      session.process.resize(input.size.cols, input.size.rows);
+    yield* bus.publish(Pty.Event.Updated, { info: session.info });
+    return session.info;
+  });
+  const write = Effect.fn("Pty.write")(function* (id, data) {
+    const session = yield* requireSession(id);
+    if (session.info.status === "running")
+      session.process.write(data);
+  });
+  const attach = Effect.fn("Pty.attach")(function* (id, input) {
+    const session = yield* requireSession(id);
+    if (session.info.status !== "running")
+      return yield* new ExitedError({ ptyID: id });
+    yield* Effect.logInfo("client attached to session", { id, directory: location.directory });
+    const token = {};
+    const subscriber = {
+      onData: input.onData,
+      onEnd: input.onEnd,
+      active: false,
+      detached: false,
+      pending: []
+    };
+    session.subscribers.set(token, subscriber);
+    const start = session.bufferCursor;
+    const end = session.cursor;
+    const from = input.cursor === -1 ? end : typeof input.cursor === "number" && Number.isSafeInteger(input.cursor) ? Math.max(0, input.cursor) : 0;
+    const replay = (() => {
+      if (!session.buffer || from >= end)
+        return "";
+      const offset = Math.max(0, from - start);
+      if (offset >= session.buffer.length)
+        return "";
+      return session.buffer.slice(offset);
+    })();
+    return {
+      replay,
+      cursor: end,
+      write: (data) => {
+        if (session.info.status === "running")
+          session.process.write(data);
+      },
+      activate: () => {
+        if (subscriber.active || subscriber.detached)
+          return;
+        subscriber.active = true;
+        try {
+          for (const chunk of subscriber.pending)
+            subscriber.onData(chunk);
+          subscriber.pending.length = 0;
+          if (subscriber.end)
+            subscriber.onEnd(subscriber.end);
+        } catch {
+          session.subscribers.delete(token);
+        }
+      },
+      detach: () => {
+        subscriber.detached = true;
+        subscriber.pending.length = 0;
+        subscriber.end = undefined;
+        session.subscribers.delete(token);
+      }
+    };
+  });
+  return Service.of({ list, get, create, update, remove, write, attach });
+}));
+function configured(options) {
+  return makeLocationNode({
+    service: Service,
+    layer: layer(options),
+    deps: [exports_bus.node, exports_location.node, exports_config.node, Global.node]
+  });
+}
+var node = configured();
+
+export { Info, CreateInput, UpdateInput, NotFoundError, ExitedError, Service, layer, configured, node, exports_pty, Event };