@opencode/core 0.0.0-reserved → 2.0.0

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

@@ -0,0 +1,271 @@
+import {
+  definition2,
+  execute3,
+  normalizeContent2,
+  normalizedName2,
+  effectiveName2
+} from "./aisdk-native-3w5fmr99.js";
+import {
+  create2,
+  catalog2
+} from "./aisdk-native-r9mregkx.js";
+import {
+  create3
+} from "./aisdk-native-kg06axw8.js";
+import {
+  Service51,
+  node54
+} from "./aisdk-native-jx8g4evx.js";
+import {
+  Service63,
+  node67
+} from "./aisdk-native-ra3qct3x.js";
+import {
+  match2
+} from "./aisdk-native-y1fvbwt7.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/tool.ts
+var exports_tool = {};
+__export(exports_tool, {
+  CallID: () => CallID2,
+  Content: () => Content3,
+  Error: () => Error2,
+  FileContent: () => FileContent3,
+  RegistrationError: () => RegistrationError2,
+  Service: () => Service34,
+  TextContent: () => TextContent2,
+  Tool: () => exports_tool,
+  node: () => node38
+});
+import { CallID as CallID2, Content as Content3, Error as Error2, FileContent as FileContent3, TextContent as TextContent2 } from "@opencode/schema/tool";
+import { ToolDefinition } from "@opencode/ai";
+import { Tool } from "@opencode/schema/tool";
+import { Context, Effect, Layer, Result, Schema, SchemaIssue } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+class RegistrationError2 extends Schema.TaggedError()("Tool.RegistrationError", {
+  name: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class Service34 extends Context.Service()("@opencode/Tool") {
+}
+var layer = Layer.effect(Service34, Effect.gen(function* () {
+  const hooks = yield* Service63;
+  const image = yield* Service51;
+  const normalizeImages = Effect.fnUntraced(function* (content) {
+    const normalized = yield* Effect.forEach(content, (item) => {
+      if (item.type !== "file" || !item.mime.startsWith("image/"))
+        return Effect.succeed(item);
+      const base64 = /^data:[^,]*;base64,(.*)$/s.exec(item.uri)?.[1];
+      if (base64 === undefined)
+        return Effect.succeed(item);
+      const resource = item.name ?? `${item.mime} tool output`;
+      return image.normalize(resource, { uri: resource, content: base64, encoding: "base64", mime: item.mime }).pipe(Effect.map((result) => ({
+        ...item,
+        uri: `data:${result.mime};base64,${result.content}`,
+        mime: result.mime
+      })), Effect.catchTag("Image.ResizerUnavailableError", () => Effect.succeed(item)), Effect.catchTag("Image.DecodeError", () => Effect.succeed("decode")), Effect.catchTag("Image.SizeError", () => Effect.succeed("size")));
+    });
+    const note = (reason, text) => {
+      const count = normalized.filter((item) => item === reason).length;
+      if (count === 0)
+        return [];
+      return [{ type: "text", text: `[${count} image${count === 1 ? "" : "s"} omitted: ${text}]` }];
+    };
+    return [
+      ...normalized.filter((item) => typeof item !== "string"),
+      ...note("decode", "could not be decoded."),
+      ...note("size", "could not be resized below the image size limit.")
+    ];
+  });
+  const beforeExecute = (name, input, context) => hooks.trigger("tool", "execute.before", {
+    tool: name,
+    sessionID: context.sessionID,
+    agent: context.agent,
+    messageID: context.messageID,
+    id: context.id,
+    input
+  });
+  const executeTool = Effect.fn("Tool.execute")(function* (tool, name, input, context) {
+    const execution = yield* execute3(tool, input, context).pipe(Effect.map((value) => ({ value })), Effect.catchTag("Tool.Error", (failure) => Effect.succeed({ failure })));
+    const base = {
+      tool: name,
+      sessionID: context.sessionID,
+      agent: context.agent,
+      messageID: context.messageID,
+      id: context.id,
+      input
+    };
+    if ("failure" in execution) {
+      const afterEvent = {
+        ...base,
+        status: "error",
+        error: execution.failure
+      };
+      yield* hooks.trigger("tool", "execute.after", afterEvent);
+      return yield* afterEvent.error;
+    }
+    const afterEvent = {
+      ...base,
+      status: "completed",
+      result: {
+        ...execution.value.output === undefined ? {} : { output: execution.value.output },
+        content: execution.value.content,
+        ...execution.value.metadata === undefined ? {} : { metadata: execution.value.metadata }
+      }
+    };
+    yield* hooks.trigger("tool", "execute.after", afterEvent);
+    const afterContent = yield* normalizeImages(normalizeContent2(afterEvent.result.content, afterEvent.result.output));
+    return {
+      ...afterEvent.result.output === undefined ? {} : { output: afterEvent.result.output },
+      content: afterContent,
+      ...afterEvent.result.metadata === undefined ? {} : { metadata: afterEvent.result.metadata }
+    };
+  });
+  const state = create3({
+    name: "tool",
+    initial: () => ({
+      tools: new Map,
+      namespaces: new Map,
+      errors: []
+    }),
+    editor: (editor) => ({
+      list: () => Array.from(editor.tools.values()),
+      get: (id) => editor.tools.get(id),
+      namespace: (namespace) => {
+        const error = namespaceError(namespace.name);
+        if (error) {
+          editor.errors.push({ kind: "namespace", name: namespace.name, namespace: namespace.name, error });
+          return;
+        }
+        editor.namespaces.set(namespace.name, { ...namespace });
+      },
+      add: (tool) => {
+        const error = registrationError(tool);
+        if (error) {
+          editor.errors.push({ kind: "tool", name: tool.name, namespace: tool.options?.namespace, error });
+          return;
+        }
+        const id = effectiveName2(tool);
+        editor.tools.set(id, { ...tool, id, options: tool.options && { ...tool.options } });
+      },
+      update: (id, update) => {
+        const current = editor.tools.get(id);
+        if (!current)
+          return;
+        const tool = { ...current, options: current.options && { ...current.options } };
+        update(tool);
+        tool.name = current.name;
+        tool.id = id;
+        if (tool.options?.namespace !== current.options?.namespace)
+          tool.options = { ...tool.options, namespace: current.options?.namespace };
+        const error = registrationError(tool);
+        if (error) {
+          editor.errors.push({ kind: "tool", name: tool.name, namespace: tool.options?.namespace, error });
+          return;
+        }
+        editor.tools.set(id, tool);
+      },
+      remove: (id) => {
+        editor.tools.delete(id);
+      }
+    }),
+    notify: (value) => Effect.forEach(value.errors, ({ kind, name, namespace, error }) => Effect.logError(`Skipping invalid ${kind} registration`, {
+      name,
+      namespace,
+      error: error.message
+    }), { discard: true })
+  });
+  return Service34.of({
+    transform: state.transform,
+    reload: state.reload,
+    snapshot: Effect.fn("Tool.snapshot")((permissions) => Effect.sync(() => {
+      const active = new Map;
+      const rules = permissions ?? [];
+      for (const [name, tool] of state.get().tools) {
+        if (whollyDisabled(tool.options?.permission ?? name, rules))
+          continue;
+        active.set(name, tool);
+      }
+      const direct = new Map(Array.from(active).filter(([, tool]) => tool.options?.codemode === false));
+      const codeModeTools = new Map(Array.from(active).filter(([, tool]) => tool.options?.codemode !== false));
+      const namespaces = state.get().namespaces;
+      const codeModeInventory = { tools: codeModeTools, namespaces };
+      const codeModeEnabled = !whollyDisabled("execute", rules);
+      const codeModeTool = codeModeEnabled ? create2(codeModeInventory, (name, tool, input, context) => beforeExecute(name, input, context).pipe(Effect.flatMap((event) => executeTool(tool, name, event.input, context)))) : undefined;
+      const codeModeCatalog = codeModeEnabled ? catalog2(codeModeInventory) : undefined;
+      return {
+        ...codeModeCatalog === undefined ? {} : { codeModeCatalog },
+        definitions: [
+          ...Array.from(direct).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([, tool]) => definition2(tool)),
+          ...codeModeTool ? [definition2(codeModeTool)] : []
+        ],
+        execute: Effect.fnUntraced(function* (input) {
+          const context = {
+            sessionID: input.sessionID,
+            agent: input.agent,
+            messageID: input.messageID,
+            id: Tool.CallID.make(input.call.id),
+            progress: input.progress ?? (() => Effect.void)
+          };
+          const event = yield* beforeExecute(input.call.name, input.call.input, context);
+          const requested = input.definitions?.get(event.tool);
+          if (!requested && input.definitions && (direct.has(event.tool) || codeModeTool?.name === event.tool))
+            return yield* new Tool.Error({ message: `Tool is not available for this request: ${event.tool}` });
+          const name = requested?.name ?? event.tool;
+          if (name === "execute" && codeModeTool)
+            return yield* executeTool(codeModeTool, name, event.input, context);
+          const tool = direct.get(name);
+          if (tool)
+            return yield* executeTool(tool, name, event.input, context);
+          return yield* new Tool.Error({ message: `Unknown tool: ${name}` });
+        })
+      };
+    }))
+  });
+}));
+var whollyDisabled = (action, rules) => {
+  const rule = rules.findLast((rule) => match2(action, rule.action));
+  return rule?.resource === "*" && rule.effect === "deny";
+};
+var formatSchemaIssue = SchemaIssue.makeFormatterDefault();
+function schemaMakeError(error) {
+  if (error instanceof Error && SchemaIssue.isIssue(error.cause))
+    return formatSchemaIssue(error.cause);
+  return error instanceof Error ? error.message : String(error);
+}
+function registrationError(tool) {
+  const namespace = tool.options?.namespace;
+  if (namespace !== undefined) {
+    const error = namespaceError(namespace);
+    if (error)
+      return error;
+  }
+  const name = normalizedName2(tool);
+  if (!/^[A-Za-z0-9_-]{1,64}$/.test(name))
+    return new RegistrationError2({ name, message: `Invalid tool name: ${name}` });
+  const id = effectiveName2(tool);
+  if (tool.options?.codemode === false && id === "execute")
+    return new RegistrationError2({ name: id, message: 'Tool name "execute" is reserved for CodeMode' });
+  const result = Result.try({
+    try: () => ToolDefinition.make(definition2(tool)),
+    catch: (error) => new RegistrationError2({ name: id, message: `Invalid tool definition ${id}: ${schemaMakeError(error)}` })
+  });
+  return Result.isFailure(result) ? result.failure : undefined;
+}
+function namespaceError(name) {
+  if (name.split(".").every((segment) => /^[A-Za-z0-9_-]{1,64}$/.test(segment)))
+    return;
+  return new RegistrationError2({ name, message: `Invalid tool namespace: ${JSON.stringify(name)}` });
+}
+var node38 = makeLocationNode({
+  service: Service34,
+  layer,
+  deps: [node67, node54]
+});
+
+export { RegistrationError2, Service34, node38, exports_tool, CallID2, Content3, Error2, FileContent3, TextContent2 };

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

@@ -0,0 +1,14 @@
+// src/github-copilot/chat/get-response-metadata.ts
+function getResponseMetadata2({
+  id,
+  model,
+  created
+}) {
+  return {
+    id: id ?? undefined,
+    modelId: model ?? undefined,
+    timestamp: created != null ? new Date(created * 1000) : undefined
+  };
+}
+
+export { getResponseMetadata2 };

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

@@ -0,0 +1,173 @@
+import {
+  ID13,
+  Family2
+} from "./aisdk-native-jghsd1wz.js";
+import {
+  Service35
+} from "./aisdk-native-y9tfvs3x.js";
+import {
+  foldSettings2
+} from "./aisdk-native-6g46d628.js";
+
+// src/plugin/provider/ollama.ts
+import { define } from "@opencode/plugin/effect/plugin";
+import { Duration, Effect, Schedule, Schema, Semaphore, Stream } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+var providerID = "ollama";
+var Details = Schema.Struct({
+  parent_model: Schema.String.pipe(Schema.optional),
+  format: Schema.String,
+  family: Schema.String,
+  families: Schema.Array(Schema.String).pipe(Schema.optional),
+  parameter_size: Schema.String,
+  quantization_level: Schema.String
+});
+var RemoteModel = Schema.Struct({
+  name: Schema.String,
+  model: Schema.String,
+  remote_model: Schema.String.pipe(Schema.optional),
+  remote_host: Schema.String.pipe(Schema.optional),
+  modified_at: Schema.String,
+  size: Schema.Int,
+  digest: Schema.String,
+  details: Details
+});
+var TagsResponse = Schema.Struct({ models: Schema.Array(RemoteModel) });
+var ShowRequest = Schema.Struct({ model: Schema.String });
+var ShowResponse = Schema.Struct({
+  parameters: Schema.String.pipe(Schema.optional),
+  license: Schema.String.pipe(Schema.optional),
+  modified_at: Schema.String.pipe(Schema.optional),
+  details: Details.pipe(Schema.optional),
+  template: Schema.String.pipe(Schema.optional),
+  capabilities: Schema.Array(Schema.String).pipe(Schema.optional),
+  model_info: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional)
+});
+var discovery = new Map;
+var discoveryLock = Semaphore.makeUnsafe(1);
+function make6(origin = "http://127.0.0.1:11434", interval = "30 seconds") {
+  return define({
+    id: "opencode.provider.ollama",
+    effect: Effect.fn(function* (ctx) {
+      const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+      const config = yield* Service35;
+      const source = { current: configured(yield* config.entries(), origin) };
+      const loaded = { models: [], hash: "[]" };
+      yield* ctx.integration.transform((integrations) => {
+        if (loaded.models.length === 0)
+          return;
+        integrations.remove(providerID);
+      });
+      yield* ctx.catalog.transform((catalog) => {
+        if (loaded.models.length === 0)
+          return;
+        for (const model of catalog.provider.get(providerID)?.models.values() ?? []) {
+          catalog.model.remove(providerID, model.id);
+        }
+        catalog.provider.update(providerID, (provider) => {
+          provider.name = "Ollama";
+          provider.activation = "enabled";
+          provider.package = "@opencode/ai/providers/openai-compatible";
+          provider.settings = {
+            baseURL: source.current.baseURL,
+            provider: providerID,
+            apiKey: source.current.apiKey ?? ""
+          };
+          provider.integrationID = undefined;
+        });
+        for (const item of loaded.models) {
+          catalog.model.update(providerID, item.model, (model) => {
+            model.modelID = ID13.make(item.model);
+            model.name = item.name || item.model;
+            model.family = item.show.details?.family ? Family2.make(item.show.details.family) : item.details.family ? Family2.make(item.details.family) : undefined;
+            model.capabilities = {
+              tools: item.show.capabilities?.includes("tools") ?? false,
+              input: ["text", ...item.show.capabilities?.includes("vision") ? ["image"] : []],
+              output: ["text"]
+            };
+            const context = Object.entries(item.show.model_info ?? {}).flatMap(([key, value]) => key.endsWith(".context_length") && typeof value === "number" && value > 0 ? [value] : [])[0];
+            if (context !== undefined)
+              model.limit.context = context;
+          });
+        }
+      });
+      const discover = Effect.fn("OllamaPlugin.discover")(function* () {
+        const current = source.current;
+        if (!current.tagsEndpoint || !current.showEndpoint)
+          return;
+        return yield* discoveryLock.withPermit(Effect.gen(function* () {
+          const cached = discovery.get(current.tagsEndpoint);
+          if (cached && cached.apiKey === current.apiKey && Date.now() - cached.checked < Duration.toMillis(interval))
+            return { source: current, models: cached.models };
+          const previous = cached && cached.apiKey === current.apiKey ? cached : { checked: 0, apiKey: current.apiKey, shows: new Map };
+          discovery.set(current.tagsEndpoint, { ...previous, checked: Date.now(), apiKey: current.apiKey });
+          const tagsRequest = current.apiKey ? HttpClientRequest.get(current.tagsEndpoint).pipe(HttpClientRequest.acceptJson, HttpClientRequest.bearerToken(current.apiKey)) : HttpClientRequest.get(current.tagsEndpoint).pipe(HttpClientRequest.acceptJson);
+          const response = yield* http.execute(tagsRequest).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(TagsResponse)), Effect.timeout("1 second"));
+          const summaries = response.models.filter((model) => model.model.length > 0).toSorted((a, b) => a.model.localeCompare(b.model));
+          const shows = new Map;
+          const models = yield* Effect.forEach(summaries, (model) => Effect.gen(function* () {
+            const saved = previous.shows.get(model.model);
+            const info = saved?.digest === model.digest ? saved.info : yield* HttpClientRequest.post(current.showEndpoint).pipe(HttpClientRequest.acceptJson, current.apiKey ? HttpClientRequest.bearerToken(current.apiKey) : (request) => request, HttpClientRequest.schemaBodyJson(ShowRequest)({ model: model.model }), Effect.flatMap(http.execute), Effect.flatMap(HttpClientResponse.schemaBodyJson(ShowResponse)), Effect.timeout("1 second"));
+            shows.set(model.model, { digest: model.digest, info });
+            return { ...model, show: info };
+          }).pipe(Effect.orElseSucceed(() => {
+            return;
+          })), { concurrency: 4 });
+          const filtered = models.filter((model) => model !== undefined && (model.show.capabilities?.includes("completion") ?? false));
+          discovery.set(current.tagsEndpoint, {
+            checked: Date.now(),
+            apiKey: current.apiKey,
+            models: filtered,
+            shows
+          });
+          return { source: current, models: filtered };
+        }));
+      });
+      const refresh = Effect.fn("OllamaPlugin.refresh")(function* () {
+        const result = yield* discover();
+        if (!result?.models || result.source !== source.current)
+          return;
+        const hash = JSON.stringify(result.models);
+        if (hash === loaded.hash)
+          return;
+        loaded.models = result.models;
+        loaded.hash = hash;
+        yield* ctx.integration.reload();
+        yield* ctx.catalog.reload();
+      });
+      yield* refresh().pipe(Effect.ignore, Effect.repeat(Schedule.spaced(interval)), Effect.forkScoped);
+      const reload = Effect.fn("OllamaPlugin.reload")(function* () {
+        const next = configured(yield* config.entries(), origin);
+        if (next.baseURL === source.current.baseURL && next.apiKey === source.current.apiKey && next.tagsEndpoint === source.current.tagsEndpoint)
+          return;
+        source.current = next;
+        loaded.models = [];
+        loaded.hash = "[]";
+        yield* ctx.integration.reload();
+        yield* ctx.catalog.reload();
+        yield* refresh().pipe(Effect.ignore);
+      });
+      yield* ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(reload), Effect.forkScoped({ startImmediately: true }));
+    })
+  });
+}
+var OllamaPlugin2 = make6();
+function configured(entries, origin) {
+  const settings = foldSettings2(entries, providerID, undefined);
+  const baseURL = (typeof settings?.baseURL === "string" ? settings.baseURL : `${origin.replace(/\/+$/, "")}/v1`).replace(/\/+$/, "");
+  const apiKey = typeof settings?.apiKey === "string" ? settings.apiKey : undefined;
+  if (!URL.canParse(baseURL))
+    return { baseURL, apiKey };
+  const url = new URL(baseURL);
+  if (url.protocol !== "http:" && url.protocol !== "https:")
+    return { baseURL, apiKey };
+  const prefix = url.pathname.endsWith("/v1") ? url.pathname.slice(0, -3) : url.pathname.replace(/\/+$/, "");
+  url.pathname = `${prefix}/api/tags`;
+  url.search = "";
+  url.hash = "";
+  const tagsEndpoint = url.toString();
+  url.pathname = `${prefix}/api/show`;
+  return { baseURL, apiKey, tagsEndpoint, showEndpoint: url.toString() };
+}
+
+export { make6, OllamaPlugin2 };

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

@@ -0,0 +1,17 @@
+// src/database/migration/20260303231226_add_workspace_fields.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260303231226_add_workspace_fields",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`type\` text NOT NULL;`);
+      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`name\` text;`);
+      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`directory\` text;`);
+      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`extra\` text;`);
+      yield* tx.run(`ALTER TABLE \`workspace\` DROP COLUMN \`config\`;`);
+    });
+  }
+};
+var _20260303231226_add_workspace_fields_default = migration;
+
+export { _20260303231226_add_workspace_fields_default };

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

@@ -0,0 +1,86 @@
+import {
+  Service44,
+  node47
+} from "./aisdk-native-xmvvg8ty.js";
+import {
+  Key3,
+  removed2,
+  make20,
+  diffByKey2
+} from "./aisdk-native-rhjbct0v.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/reference/instructions.ts
+var exports_instructions5 = {};
+__export(exports_instructions5, {
+  ReferenceInstructions: () => exports_instructions5,
+  Service: () => Service29,
+  node: () => node33
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+var Summary = Schema.Struct({
+  name: Schema.String,
+  path: Schema.String,
+  description: Schema.String.pipe(Schema.optional)
+});
+var entries = (references) => references.flatMap((reference) => [
+  "  <reference>",
+  `    <name>${reference.name}</name>`,
+  `    <path>${reference.path}</path>`,
+  ...reference.description === undefined ? [] : [`    <description>${reference.description}</description>`],
+  "  </reference>"
+]);
+var render = (references) => [
+  "Project references provide additional directories that can be accessed when relevant.",
+  "<available_references>",
+  ...entries(references),
+  "</available_references>"
+].join(`
+`);
+var update = (previous, current) => {
+  const diff = diffByKey2(previous, current, (reference) => reference.name, (before, after) => before.path !== after.path || before.description !== after.description);
+  if (diff.changed.length > 0 || diff.added.length === 0 && diff.removed.length === 0)
+    return [
+      "The available project references have changed. This list supersedes the previous reference list.",
+      render(current)
+    ].join(`
+`);
+  return [
+    ...diff.added.length === 0 ? [] : ["New project references are available in addition to those previously listed:", ...entries(diff.added)],
+    ...diff.removed.length === 0 ? [] : [
+      `The following project references are no longer available and must not be used: ${diff.removed.map((reference) => reference.name).join(", ")}.`
+    ]
+  ].join(`
+`);
+};
+
+class Service29 extends Context.Service()("@opencode/ReferenceInstructions") {
+}
+var layer = Layer.effect(Service29, Effect.gen(function* () {
+  const references = yield* Service44;
+  return Service29.of({
+    load: Effect.fn("ReferenceInstructions.load")(function* () {
+      const available = (yield* references.list()).filter((reference) => reference.description !== undefined).map((reference) => ({
+        name: reference.name,
+        path: reference.path,
+        description: reference.description
+      })).toSorted((a, b) => a.name.localeCompare(b.name));
+      return make20({
+        key: Key3.make("core/reference-guidance"),
+        codec: Schema.toCodecJson(Schema.Array(Summary)),
+        read: Effect.succeed(available.length === 0 ? removed2 : available),
+        render: {
+          initial: render,
+          changed: update,
+          removed: () => "Project reference guidance is no longer available. Do not use previously listed references."
+        }
+      });
+    })
+  });
+}));
+var node33 = makeLocationNode({ service: Service29, layer, deps: [node47] });
+
+export { Service29, node33, exports_instructions5 };