@opencode/core 0.0.0-reserved → 2.0.0

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

@@ -0,0 +1,213 @@
+import {
+  create3
+} from "./aisdk-native-kg06axw8.js";
+import {
+  which2
+} from "./aisdk-native-qaymkmh1.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/shell/select.ts
+var exports_select = {};
+__export(exports_select, {
+  Options: () => Options10,
+  Service: () => Service78,
+  ShellSelect: () => exports_select,
+  args: () => args2,
+  configured: () => configured11,
+  environment: () => environment2,
+  gitbash: () => gitbash2,
+  list: () => list4,
+  login: () => login2,
+  name: () => name15,
+  node: () => node83,
+  ps: () => ps2,
+  resolve: () => resolve3
+});
+import path from "path";
+import { readFile } from "fs/promises";
+import { statSync } from "fs";
+import { Context, Effect, Layer, Schema } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+var META = {
+  bash: { login: true },
+  dash: { login: true },
+  fish: { deny: true, login: true },
+  ksh: { login: true },
+  nu: { deny: true },
+  powershell: { ps: true },
+  pwsh: { ps: true },
+  sh: { login: true },
+  zsh: { login: true }
+};
+var Options10 = Schema.Struct({
+  gitbash: Schema.optional(Schema.String)
+});
+
+class Service78 extends Context.Service()("@opencode/ShellSelect") {
+}
+function stat(file) {
+  return statSync(file, { throwIfNoEntry: false }) ?? undefined;
+}
+function findExecutable(name, bin) {
+  return which2(name, undefined, bin);
+}
+function full(file, options, bin) {
+  if (process.platform !== "win32")
+    return file;
+  const shell = FSUtil.windowsPath(file);
+  if (path.win32.dirname(shell) !== ".") {
+    if (shell.startsWith("/") && name15(shell) === "bash")
+      return gitbash2(options, bin) || shell;
+    return shell;
+  }
+  if (name15(shell) === "bash")
+    return gitbash2(options, bin) || findExecutable(shell, bin) || shell;
+  return findExecutable(shell, bin) || shell;
+}
+function meta(file) {
+  return META[name15(file)];
+}
+function compatible(file) {
+  return meta(file)?.deny !== true;
+}
+function rooted(file) {
+  return path.isAbsolute(FSUtil.windowsPath(file));
+}
+function executable(file, options, bin) {
+  const shell = full(file, options, bin);
+  if (rooted(shell)) {
+    if (stat(shell)?.isFile())
+      return shell;
+    return;
+  }
+  return findExecutable(shell, bin) ?? undefined;
+}
+function win(options, bin) {
+  return Array.from(new Set([
+    findExecutable("pwsh", bin),
+    findExecutable("powershell", bin),
+    gitbash2(options, bin),
+    process.env.COMSPEC || "cmd.exe"
+  ].filter((item) => Boolean(item)).map((file) => full(file, options, bin))));
+}
+async function unix() {
+  const text = await readFile("/etc/shells", "utf8").catch(() => "");
+  if (text)
+    return Array.from(new Set(text.split(`
+`).filter((line) => line.trim() && !line.startsWith("#"))));
+  return ["/bin/bash", "/bin/zsh", "/bin/sh"];
+}
+function select(file, options, opts, bin) {
+  if (file && (!opts?.compatible || compatible(file))) {
+    const shell = executable(file, options, bin);
+    if (shell)
+      return shell;
+  }
+  if (process.platform === "win32")
+    return win(options, bin)[0];
+  return fallback(bin);
+}
+function gitbash2(options, bin) {
+  if (process.platform !== "win32")
+    return;
+  if (options?.gitbash)
+    return options.gitbash;
+  const git = findExecutable("git", bin);
+  if (!git)
+    return;
+  const file = path.join(git, "..", "..", "bin", "bash.exe");
+  if (stat(file)?.size)
+    return file;
+}
+function fallback(bin) {
+  if (process.platform === "darwin")
+    return "/bin/zsh";
+  const bash = findExecutable("bash", bin);
+  if (bash)
+    return bash;
+  return "/bin/sh";
+}
+function name15(file) {
+  if (process.platform === "win32")
+    return path.win32.parse(FSUtil.windowsPath(file)).name.toLowerCase();
+  return path.basename(file).toLowerCase();
+}
+function login2(file) {
+  return meta(file)?.login === true;
+}
+function ps2(file) {
+  return meta(file)?.ps === true;
+}
+function info(file, options, bin) {
+  const item = full(file, options, bin);
+  const n = name15(item);
+  return {
+    path: item,
+    name: executable(n, options, bin) ? n : item,
+    acceptable: compatible(item)
+  };
+}
+function args2(file, command) {
+  const n = name15(file);
+  if (n === "cmd")
+    return ["/c", command];
+  if (ps2(file))
+    return ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", command];
+  return ["-c", command];
+}
+function environment2(bin, filter) {
+  return select(process.env.SHELL, undefined, filter, bin) ?? fallback(bin);
+}
+var defaultConfigured;
+var defaultCompatible;
+function resolve3(input, configShell, options, bin) {
+  const filter = input.priority === "compat" ? { compatible: true } : undefined;
+  if (configShell)
+    return select(configShell, options, filter, bin);
+  if (options?.gitbash)
+    return select(process.env.SHELL, options, filter, bin);
+  const cached = input.priority === "compat" ? defaultCompatible : defaultConfigured;
+  if (cached && cached.bin === bin)
+    return cached.value;
+  const value = environment2(bin, filter);
+  if (input.priority === "compat")
+    defaultCompatible = { bin, value };
+  if (input.priority === "config")
+    defaultConfigured = { bin, value };
+  return value;
+}
+resolve3.reset = () => {
+  defaultConfigured = undefined;
+  defaultCompatible = undefined;
+};
+async function list4(options, bin) {
+  const shells = process.platform === "win32" ? win(options, bin) : await unix();
+  return shells.filter((shell) => executable(shell, options, bin)).map((shell) => info(shell, options, bin));
+}
+var layer = (options) => Layer.effect(Service78, Effect.gen(function* () {
+  const global = yield* Global.Service;
+  const state = create3({
+    name: "shell-select",
+    initial: () => ({}),
+    editor: (editor) => ({
+      configure: (shell) => {
+        editor.shell = shell;
+      }
+    })
+  });
+  return Service78.of({
+    transform: state.transform,
+    reload: state.reload,
+    resolve: (input) => Effect.sync(() => resolve3(input, state.get().shell, options, global.bin))
+  });
+}));
+function configured11(options) {
+  return makeLocationNode({ service: Service78, layer: layer(options), deps: [Global.node] });
+}
+var node83 = configured11();
+
+export { Options10, Service78, gitbash2, name15, login2, ps2, args2, environment2, resolve3, list4, configured11, node83, exports_select };

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

@@ -0,0 +1,193 @@
+import {
+  mergeOverlay2,
+  mergeHeaders2,
+  Info33
+} from "./aisdk-native-33n3bzdy.js";
+import {
+  Info26
+} from "./aisdk-native-jghsd1wz.js";
+import {
+  Service79,
+  node84
+} from "./aisdk-native-11nvngjf.js";
+import {
+  create3
+} from "./aisdk-native-kg06axw8.js";
+import {
+  ID11,
+  Service66,
+  node70
+} from "./aisdk-native-tpbhnsa4.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/catalog.ts
+var exports_catalog2 = {};
+__export(exports_catalog2, {
+  Catalog: () => exports_catalog2,
+  Event: () => Event16,
+  Service: () => Service65,
+  node: () => node69
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Array, Context, Effect, Layer, Order, pipe } from "effect";
+import { Catalog } from "@opencode/schema/catalog";
+import { Event as Event16 } from "@opencode/schema/catalog";
+
+class Service65 extends Context.Service()("@opencode/Catalog") {
+}
+var layer = Layer.effect(Service65, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const integrations = yield* Service66;
+  const available = (provider, integration) => {
+    if (provider.activation === "disabled")
+      return false;
+    if (provider.activation === "enabled")
+      return true;
+    if (integration?.connections.length)
+      return true;
+    return provider.integrationID === undefined && !integration;
+  };
+  const projectModel = (model, provider) => {
+    return {
+      ...model,
+      ...provider.canonical === undefined ? {} : { canonical: provider.canonical },
+      package: model.package ?? provider.package,
+      compaction: model.compaction ?? provider.compaction,
+      websocket: model.websocket ?? provider.websocket,
+      settings: mergeOverlay2(provider.settings, model.settings),
+      headers: mergeHeaders2(provider.headers, model.headers),
+      body: mergeOverlay2(provider.body, model.body)
+    };
+  };
+  const state = create3({
+    name: "catalog",
+    initial: () => ({ providers: new Map }),
+    editor: (editor) => {
+      const result = {
+        provider: {
+          list: () => Array.fromIterable(editor.providers.values()),
+          get: (providerID) => editor.providers.get(providerID),
+          update: (providerID, fn) => {
+            let current = editor.providers.get(providerID);
+            if (!current) {
+              current = {
+                provider: Info33.empty(providerID),
+                models: new Map
+              };
+              editor.providers.set(providerID, current);
+            }
+            fn(current.provider);
+            current.provider.id = providerID;
+          },
+          remove: (providerID) => {
+            editor.providers.delete(providerID);
+          }
+        },
+        model: {
+          get: (providerID, modelID) => editor.providers.get(providerID)?.models.get(modelID),
+          update: (providerID, modelID, fn) => {
+            let record = editor.providers.get(providerID);
+            if (!record) {
+              record = {
+                provider: Info33.empty(providerID),
+                models: new Map
+              };
+              editor.providers.set(providerID, record);
+            }
+            const model = record.models.get(modelID) ?? Info26.default(providerID, modelID);
+            if (!record.models.has(modelID))
+              record.models.set(modelID, model);
+            fn(model);
+            model.id = modelID;
+            model.providerID = providerID;
+          },
+          remove: (providerID, modelID) => {
+            editor.providers.get(providerID)?.models.delete(modelID);
+          },
+          default: {
+            get: () => editor.defaultModel,
+            set: (providerID, modelID) => {
+              editor.defaultModel = { providerID, modelID };
+            }
+          }
+        }
+      };
+      return result;
+    },
+    notify: () => bus.publish(Catalog.Event.Updated, {}).pipe(Effect.asVoid, Effect.withSpan("Catalog.notify"))
+  });
+  const result = {
+    transform: state.transform,
+    reload: state.reload,
+    provider: {
+      get: Effect.fn("Catalog.provider.get")(function* (providerID) {
+        return state.get().providers.get(providerID)?.provider;
+      }),
+      all: Effect.fn("Catalog.provider.all")(function* () {
+        return Array.fromIterable(state.get().providers.values()).map((record) => record.provider);
+      }),
+      available: Effect.fn("Catalog.provider.available")(function* () {
+        const active = new Map((yield* integrations.list()).map((integration) => [integration.id, integration]));
+        return (yield* result.provider.all()).filter((provider) => available(provider, active.get(provider.integrationID ?? ID11.make(provider.id))));
+      })
+    },
+    model: {
+      get: Effect.fn("Catalog.model.get")(function* (providerID, modelID) {
+        const record = state.get().providers.get(providerID);
+        if (!record)
+          return;
+        const model = record.models.get(modelID);
+        return model && projectModel(model, record.provider);
+      }),
+      all: Effect.fn("Catalog.model.all")(function* () {
+        return pipe(Array.fromIterable(state.get().providers.values()), Array.flatMap((record) => {
+          return Array.fromIterable(record.models.values()).map((model) => projectModel(model, record.provider));
+        }), Array.sortWith((item) => item.time.released, Order.flip(Order.Number)));
+      }),
+      available: Effect.fn("Catalog.model.available")(function* () {
+        const providers = new Set((yield* result.provider.available()).map((provider) => provider.id));
+        const models = [];
+        for (const record of state.get().providers.values()) {
+          if (!providers.has(record.provider.id))
+            continue;
+          for (const model of record.models.values()) {
+            if (!model.enabled)
+              continue;
+            models.push(projectModel(model, record.provider));
+          }
+        }
+        return pipe(models, Array.sortWith((item) => item.time.released, Order.flip(Order.Number)));
+      }),
+      default: Effect.fn("Catalog.model.default")(function* () {
+        const defaultModel = state.get().defaultModel;
+        if (defaultModel) {
+          const provider = yield* result.provider.get(defaultModel.providerID);
+          if (provider && (yield* result.provider.available()).some((item) => item.id === provider.id)) {
+            const model = yield* result.model.get(defaultModel.providerID, defaultModel.modelID);
+            if (model?.enabled)
+              return model;
+          }
+        }
+        return (yield* result.model.available())[0];
+      }),
+      small: Effect.fn("Catalog.model.small")(function* (providerID) {
+        const record = state.get().providers.get(providerID);
+        if (!record)
+          return;
+        const models = pipe(Array.fromIterable(record.models.values()), Array.filter((model) => model.providerID === providerID && model.enabled && model.status === "active" && model.capabilities.input.some((item) => item.startsWith("text")) && model.capabilities.output.some((item) => item.startsWith("text"))), Array.sortWith((model) => model.time.released, Order.flip(Order.Number)));
+        for (const family of SMALL_MODEL_FAMILY_PRIORITY) {
+          const selected = models.find((model) => model.family === family);
+          if (selected)
+            return projectModel(selected, record.provider);
+        }
+      })
+    }
+  };
+  return Service65.of(result);
+}));
+var SMALL_MODEL_FAMILY_PRIORITY = ["gpt-luna", "gemini-flash-lite", "gemini-flash", "claude-haiku"];
+var node69 = makeLocationNode({ service: Service65, layer, deps: [node84, node70] });
+
+export { Service65, node69, exports_catalog2, Event16 };

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

@@ -0,0 +1,263 @@
+import {
+  definition2,
+  normalizedName2
+} from "./aisdk-native-3w5fmr99.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/codemode/tool.ts
+var exports_tool2 = {};
+__export(exports_tool2, {
+  CodeModeTool: () => exports_tool2,
+  catalog: () => catalog2,
+  create: () => create2
+});
+import { CodeMode, Namespace, Tool, toolError } from "@opencode/codemode";
+import { Effect, Ref, Schema, Semaphore } from "effect";
+var ExecuteFile = Schema.Struct({
+  data: Schema.String,
+  mime: Schema.String,
+  name: Schema.optionalKey(Schema.String)
+});
+var ExecuteCall = Schema.Struct({
+  tool: Schema.String,
+  status: Schema.Literals(["running", "completed", "error"]),
+  input: Schema.optionalKey(Schema.Record(Schema.String, Schema.Json))
+});
+var ExecuteOutput = Schema.Struct({
+  output: Schema.String,
+  toolCalls: Schema.Array(ExecuteCall),
+  error: Schema.optionalKey(Schema.Literal(true)),
+  files: Schema.Array(ExecuteFile)
+});
+var description = [
+  "Run JavaScript in a confined Code Mode runtime to orchestrate tool calls and compose their results.",
+  "Imports, direct filesystem access, and timers are unavailable. Do not use `fetch`; all external access goes through `tools`.",
+  "Within `{ code }`, the only callable tools are those explicitly listed in the Code Mode catalog instructions or returned by the `search` function. Inside `{ code }`, ignore tools shown outside the Code Mode catalog. They are not available in the Code Mode runtime.",
+  'Call tools through `tools` using only exact paths and signatures from the catalog. Do not infer or normalize tool names; preserve bracket notation such as `tools.<namespace>["tool-name"](input)`.',
+  "Prefer an explicit `return`; if omitted, the final top-level expression becomes the result.",
+  "Await every call whose completion matters; pending calls are interrupted when execution ends. Run independent calls concurrently with `Promise.all`."
+].join(`
+`);
+var create2 = (inventory, executeTool) => {
+  return {
+    name: "execute",
+    description,
+    input: CodeMode.Input,
+    output: ExecuteOutput,
+    execute: ({ code }, context) => Effect.gen(function* () {
+      const callIndex = yield* Ref.make(0);
+      const files = yield* Ref.make([]);
+      const calls = yield* Ref.make([]);
+      const lock = Semaphore.makeUnsafe(1);
+      const updateCalls = (update) => lock.withPermit(Ref.updateAndGet(calls, update).pipe(Effect.flatMap((toolCalls) => context.progress({ toolCalls }))));
+      const result = yield* runtime(inventory, (name, tool, input) => Effect.gen(function* () {
+        const index = yield* Ref.getAndUpdate(callIndex, (index) => index + 1);
+        const executed = yield* executeTool(name, tool, input, context);
+        const content = typeof executed.content === "string" ? [{ type: "text", text: executed.content }] : executed.content ?? [];
+        const outputFileParts = outputFiles(content);
+        if (outputFileParts.length > 0)
+          yield* Ref.update(files, (items) => [...items, { index, files: outputFileParts }]);
+        if (executed.output !== undefined)
+          return executed.output;
+        const text = content.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
+`);
+        return text === "" ? null : text;
+      }), {
+        onToolCallStart: ({ index, name, input }) => {
+          const shown = displayInput(input);
+          return updateCalls((items) => {
+            const next = [...items];
+            next[index] = { tool: name, status: "running", ...shown ? { input: shown } : {} };
+            return next;
+          });
+        },
+        onToolCallEnd: ({ index, name, input, outcome }) => {
+          const shown = displayInput(input);
+          return updateCalls((items) => {
+            const next = [...items];
+            next[index] = {
+              ...items[index] ?? { tool: name, ...shown ? { input: shown } : {} },
+              status: outcome === "success" ? "completed" : "error"
+            };
+            return next;
+          });
+        }
+      }).execute(code);
+      const toolCalls = yield* Ref.get(calls);
+      const collected = (yield* Ref.get(files)).toSorted((left, right) => left.index - right.index).flatMap((item) => item.files);
+      const output = formatResult(result);
+      const value = {
+        output,
+        toolCalls,
+        files: collected,
+        ...result.ok ? {} : { error: true }
+      };
+      const content = [
+        { type: "text", text: value.output },
+        ...value.files.map((file) => ({
+          type: "file",
+          uri: `data:${file.mime};base64,${file.data}`,
+          mime: file.mime,
+          ...file.name === undefined ? {} : { name: file.name }
+        }))
+      ];
+      const metadata = {
+        toolCalls: value.toolCalls,
+        ...value.error ? { error: true } : {}
+      };
+      return {
+        output: value,
+        content,
+        metadata
+      };
+    })
+  };
+};
+var catalog2 = (inventory) => {
+  const pinned = new Set(Array.from(inventory.tools.values()).filter((registration) => registration.options?.pinned === true).map(qualifiedName));
+  const root = { children: new Map };
+  for (const namespace of inventory.namespaces?.values() ?? [])
+    getNode(root, namespace.name).namespace = namespace;
+  for (const tool of runtime(inventory, () => Effect.fail(toolError("Execute context is unavailable"))).catalog)
+    getNode(root, tool.path).tool = {
+      type: "tool",
+      name: tool.path.split(".").at(-1) ?? tool.path,
+      description: tool.description,
+      signature: tool.signature,
+      pinned: pinned.has(tool.path)
+    };
+  return {
+    tools: renderCatalog(root)
+  };
+};
+function renderCatalog(root) {
+  return Array.from(root.children).toSorted(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).flatMap(([name, node]) => {
+    const tools = renderCatalog(node);
+    const namespace = node.namespace === undefined && tools.length === 0 ? undefined : {
+      type: "namespace",
+      name,
+      ...node.namespace?.description === undefined ? {} : { description: node.namespace.description },
+      tools
+    };
+    if (node.tool === undefined)
+      return namespace === undefined ? [] : [namespace];
+    if (namespace === undefined)
+      return [node.tool];
+    return [node.tool, namespace];
+  });
+}
+function runtime(inventory, executeTool, hooks) {
+  const root = { children: new Map };
+  for (const namespace of inventory.namespaces?.values() ?? [])
+    getNode(root, namespace.name).namespace = namespace;
+  for (const [name, registration] of inventory.tools) {
+    const child = definition2(registration);
+    getNode(root, qualifiedName(registration)).tool = Tool.make({
+      description: child.description,
+      input: child.inputSchema,
+      output: child.outputSchema ?? Schema.NullOr(Schema.String),
+      execute: (input) => executeTool(name, registration, input)
+    });
+  }
+  const tools = renderTools(root);
+  return CodeMode.make({ tools, ...hooks });
+}
+function getNode(root, path) {
+  return path.split(".").reduce((parent, name) => {
+    const child = parent.children.get(name) ?? { children: new Map };
+    parent.children.set(name, child);
+    return child;
+  }, root);
+}
+function renderTools(root) {
+  const callables = new Map;
+  const tools = renderChildren(root, [], callables);
+  for (const [path, tool] of callables)
+    tools[path] = tool;
+  return tools;
+}
+function renderChildren(node, path, callables) {
+  return Object.fromEntries(Array.from(node.children).flatMap(([name, child]) => {
+    const next = [...path, name];
+    if (path.length === 0 && child.tool !== undefined && (child.namespace !== undefined || child.children.size > 0)) {
+      const tools = {};
+      flattenTools(child, next, tools);
+      return Object.entries(tools);
+    }
+    return [[name, renderEntry(child, next, callables)]];
+  }));
+}
+function renderEntry(node, path, callables) {
+  const tools = renderChildren(node, path, callables);
+  if (node.tool !== undefined && (node.namespace !== undefined || node.children.size > 0))
+    callables.set(path.join("."), node.tool);
+  if (node.namespace !== undefined)
+    return Namespace.make({
+      description: node.namespace.description,
+      tools
+    });
+  if (node.tool === undefined)
+    return tools;
+  if (node.children.size === 0)
+    return node.tool;
+  return tools;
+}
+function flattenTools(node, path, tools) {
+  if (node.tool !== undefined)
+    tools[path.join(".")] = node.tool;
+  for (const [name, child] of node.children)
+    flattenTools(child, [...path, name], tools);
+}
+function qualifiedName(registration) {
+  const normalized = normalizedName2(registration);
+  if (registration.options?.namespace === undefined)
+    return normalized;
+  return `${registration.options.namespace}.${normalized}`;
+}
+function displayInput(input) {
+  if (input === null || input === undefined)
+    return;
+  if (typeof input !== "object" || Array.isArray(input))
+    return { input };
+  if (Object.keys(input).length === 0)
+    return;
+  return input;
+}
+function formatResult(result) {
+  const output = result.ok ? formatValue(result.value) : [result.error.message, ...(result.error.suggestions ?? []).filter((hint) => !result.error.message.includes(hint))].join(`
+`).trim();
+  const warnings = result.ok && result.warnings && result.warnings.length > 0 ? `Warnings:
+${result.warnings.map((item) => `- [${item.kind}] ${item.message}`).join(`
+`)}` : undefined;
+  const logs = result.logs && result.logs.length > 0 ? `Logs:
+${result.logs.join(`
+`)}` : undefined;
+  return [output, warnings, logs].filter((part) => part !== undefined && part !== "").join(`
+
+`);
+}
+function formatValue(value) {
+  if (typeof value === "string")
+    return value;
+  return JSON.stringify(value, null, 2) ?? String(value);
+}
+function outputFiles(content) {
+  return content.flatMap((part) => {
+    if (part.type !== "file")
+      return [];
+    const prefix = `data:${part.mime};base64,`;
+    if (!part.uri.startsWith(prefix))
+      return [];
+    return [
+      {
+        data: part.uri.slice(prefix.length),
+        mime: part.mime,
+        ...part.name === undefined ? {} : { name: part.name }
+      }
+    ];
+  });
+}
+
+export { create2, catalog2, exports_tool2 };