@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-94s48bjb.js

@@ -0,0 +1,185 @@
+import {
+  codeInterpreterArgsSchema2
+} from "./aisdk-native-eh3zwz77.js";
+import {
+  fileSearchArgsSchema2
+} from "./aisdk-native-e73j6tqm.js";
+import {
+  webSearchArgsSchema2
+} from "./aisdk-native-3wcehsnq.js";
+import {
+  webSearchPreviewArgsSchema2
+} from "./aisdk-native-dap0rakb.js";
+import {
+  imageGenerationArgsSchema2
+} from "./aisdk-native-4y7fprxs.js";
+
+// src/github-copilot/responses/openai-responses-prepare-tools.ts
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+function getResponsesHostedTool2(tool) {
+  switch (tool.id) {
+    case "openai.file_search":
+      return { name: tool.name, type: "file_search", responseType: "file_search" };
+    case "openai.web_search_preview":
+      return { name: tool.name, type: "web_search_preview", responseType: "web_search" };
+    case "openai.web_search":
+      return { name: tool.name, type: "web_search", responseType: "web_search" };
+    case "openai.code_interpreter":
+      return { name: tool.name, type: "code_interpreter", responseType: "code_interpreter" };
+    case "openai.image_generation":
+      return { name: tool.name, type: "image_generation", responseType: "image_generation" };
+  }
+  return;
+}
+function prepareResponsesTools2({
+  tools,
+  toolChoice,
+  strictJsonSchema
+}) {
+  tools = tools?.length ? tools : undefined;
+  const toolWarnings = [];
+  if (tools == null) {
+    return { tools: undefined, toolChoice: undefined, hostedTools: [], toolWarnings };
+  }
+  const hostedTools = tools.flatMap((tool) => {
+    if (tool.type !== "provider")
+      return [];
+    const hostedTool = getResponsesHostedTool2(tool);
+    return hostedTool ? [hostedTool] : [];
+  });
+  const selectedToolName = toolChoice?.type === "tool" ? toolChoice.toolName : undefined;
+  const selectedTools = selectedToolName === undefined ? [] : tools.filter((tool) => tool.name === selectedToolName);
+  if (selectedTools.length > 1) {
+    throw new UnsupportedFunctionalityError({
+      functionality: `ambiguous tool choice '${selectedToolName}': multiple tool definitions share this name`
+    });
+  }
+  const selectedHostedTool = selectedTools[0]?.type === "provider" ? getResponsesHostedTool2(selectedTools[0]) : undefined;
+  const ambiguousHostedResponse = toolChoice?.type === "none" || toolChoice?.type === "tool" ? undefined : hostedTools.find((tool) => new Set(hostedTools.filter((candidate) => candidate.responseType === tool.responseType).map((item) => item.name)).size > 1);
+  if (ambiguousHostedResponse) {
+    const names = new Set(hostedTools.filter((tool) => tool.responseType === ambiguousHostedResponse.responseType).map((tool) => tool.name));
+    throw new UnsupportedFunctionalityError({
+      functionality: `ambiguous ${ambiguousHostedResponse.responseType} response for hosted tools: ${[...names].join(", ")}`
+    });
+  }
+  if (selectedHostedTool) {
+    const names = new Set(hostedTools.filter((tool) => tool.type === selectedHostedTool.type).map((tool) => tool.name));
+    if (names.size > 1) {
+      throw new UnsupportedFunctionalityError({
+        functionality: `ambiguous ${selectedHostedTool.type} tool choice for hosted tools: ${[...names].join(", ")}`
+      });
+    }
+  }
+  const openaiTools = [];
+  for (const tool of tools) {
+    switch (tool.type) {
+      case "function":
+        openaiTools.push({
+          type: "function",
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema,
+          strict: tool.strict ?? strictJsonSchema
+        });
+        break;
+      case "provider": {
+        switch (tool.id) {
+          case "openai.file_search": {
+            const args = fileSearchArgsSchema2.parse(tool.args);
+            openaiTools.push({
+              type: "file_search",
+              vector_store_ids: args.vectorStoreIds,
+              max_num_results: args.maxNumResults,
+              ranking_options: args.ranking ? {
+                ranker: args.ranking.ranker,
+                score_threshold: args.ranking.scoreThreshold
+              } : undefined,
+              filters: args.filters
+            });
+            break;
+          }
+          case "openai.web_search_preview": {
+            const args = webSearchPreviewArgsSchema2.parse(tool.args);
+            openaiTools.push({
+              type: "web_search_preview",
+              search_context_size: args.searchContextSize,
+              user_location: args.userLocation
+            });
+            break;
+          }
+          case "openai.web_search": {
+            const args = webSearchArgsSchema2.parse(tool.args);
+            openaiTools.push({
+              type: "web_search",
+              filters: args.filters != null ? { allowed_domains: args.filters.allowedDomains } : undefined,
+              search_context_size: args.searchContextSize,
+              user_location: args.userLocation
+            });
+            break;
+          }
+          case "openai.code_interpreter": {
+            const args = codeInterpreterArgsSchema2.parse(tool.args);
+            openaiTools.push({
+              type: "code_interpreter",
+              container: args.container == null ? { type: "auto", file_ids: undefined } : typeof args.container === "string" ? args.container : { type: "auto", file_ids: args.container.fileIds }
+            });
+            break;
+          }
+          case "openai.image_generation": {
+            const args = imageGenerationArgsSchema2.parse(tool.args);
+            openaiTools.push({
+              type: "image_generation",
+              background: args.background,
+              input_fidelity: args.inputFidelity,
+              input_image_mask: args.inputImageMask ? {
+                file_id: args.inputImageMask.fileId,
+                image_url: args.inputImageMask.imageUrl
+              } : undefined,
+              model: args.model,
+              moderation: args.moderation,
+              partial_images: args.partialImages,
+              quality: args.quality,
+              output_compression: args.outputCompression,
+              output_format: args.outputFormat,
+              size: args.size
+            });
+            break;
+          }
+        }
+        break;
+      }
+      default:
+        toolWarnings.push({ type: "unsupported", feature: "tool type" });
+        break;
+    }
+  }
+  if (toolChoice == null) {
+    return { tools: openaiTools, toolChoice: undefined, hostedTools, selectedHostedTool, toolWarnings };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+    case "none":
+    case "required":
+      return { tools: openaiTools, toolChoice: type, hostedTools, selectedHostedTool, toolWarnings };
+    case "tool": {
+      return {
+        tools: openaiTools,
+        toolChoice: selectedHostedTool ? { type: selectedHostedTool.type } : { type: "function", name: toolChoice.toolName },
+        hostedTools,
+        selectedHostedTool,
+        toolWarnings
+      };
+    }
+    default: {
+      const _exhaustiveCheck = type;
+      throw new UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`
+      });
+    }
+  }
+}
+
+export { getResponsesHostedTool2, prepareResponsesTools2 };

package/dist/chunks/aisdk-native-9a4afbnw.js

@@ -0,0 +1,17 @@
+// src/database/migration/20260622170816_reset_v2_session_state.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260622170816_reset_v2_session_state",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DELETE FROM \`session_context_epoch\`;`);
+      yield* tx.run(`DELETE FROM \`session_input\`;`);
+      yield* tx.run(`DELETE FROM \`session_message\`;`);
+      yield* tx.run(`DELETE FROM \`event\`;`);
+      yield* tx.run(`DELETE FROM \`event_sequence\`;`);
+    });
+  }
+};
+var _20260622170816_reset_v2_session_state_default = migration;
+
+export { _20260622170816_reset_v2_session_state_default };

package/dist/chunks/aisdk-native-9jdakqgh.js

@@ -0,0 +1,148 @@
+import {
+  cleanup3
+} from "./aisdk-native-gd4qta3r.js";
+import {
+  ascending2
+} from "./aisdk-native-tvtrv512.js";
+import {
+  create3
+} from "./aisdk-native-kg06axw8.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/tool-output.ts
+var exports_tool_output2 = {};
+__export(exports_tool_output2, {
+  DIRECTORY: () => DIRECTORY3,
+  MAX_BYTES: () => MAX_BYTES2,
+  MAX_LINES: () => MAX_LINES2,
+  RETENTION: () => RETENTION3,
+  Service: () => Service55,
+  ToolOutput: () => exports_tool_output2,
+  node: () => node59
+});
+import path from "path";
+import { Context, Duration, Effect, Layer, Schedule } from "effect";
+import { makeGlobalNode, makeLocationNode } from "@opencode/util/effect/app-node";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+var MAX_LINES2 = 2000;
+var MAX_BYTES2 = 50 * 1024;
+var RETENTION3 = Duration.days(7);
+var DIRECTORY3 = "tool-output";
+
+class Service55 extends Context.Service()("@opencode/ToolOutput") {
+}
+var cleanup = Effect.fn("ToolOutput.cleanup")(function* (fs, directory) {
+  const entries = yield* fs.readDirectory(directory).pipe(Effect.map((entries) => entries.filter((entry) => /^tool_[0-9a-f]{12}/.test(entry))), Effect.orElseSucceed(() => []));
+  yield* cleanup3(fs, entries.map((entry) => path.join(directory, entry)), RETENTION3);
+});
+var layer = Layer.effect(Service55, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  const directory = path.join(global.data, DIRECTORY3);
+  const state = create3({
+    name: "tool-output",
+    initial: () => ({ maxLines: MAX_LINES2, maxBytes: MAX_BYTES2 }),
+    editor: (editor) => ({
+      configure: (limits) => {
+        if (limits.maxLines !== undefined)
+          editor.maxLines = limits.maxLines;
+        if (limits.maxBytes !== undefined)
+          editor.maxBytes = limits.maxBytes;
+      }
+    })
+  });
+  const truncate = Effect.fnUntraced(function* (result) {
+    if (result.metadata?.truncated !== undefined)
+      return result;
+    const content = result.content;
+    const text = content.flatMap((item) => item.type === "text" ? [item.text] : []).join(`
+`);
+    const limits = state.get();
+    const lines = text.split(`
+`);
+    if (text.endsWith(`
+`))
+      lines.pop();
+    const totalBytes = Buffer.byteLength(text, "utf-8");
+    if (lines.length <= limits.maxLines && totalBytes <= limits.maxBytes)
+      return { ...result, metadata: { ...result.metadata, truncated: false } };
+    const kept = [];
+    let bytes = 0;
+    let hitBytes = false;
+    for (const line of lines.slice(0, limits.maxLines)) {
+      const size = Buffer.byteLength(line, "utf-8") + (kept.length > 0 ? 1 : 0);
+      if (bytes + size > limits.maxBytes) {
+        hitBytes = true;
+        break;
+      }
+      kept.push(line);
+      bytes += size;
+    }
+    if (!hitBytes && kept.length === lines.length && totalBytes > bytes)
+      hitBytes = true;
+    const removed = hitBytes ? totalBytes - bytes : lines.length - kept.length;
+    const unit = hitBytes ? removed === 1 ? "byte" : "bytes" : removed === 1 ? "line" : "lines";
+    const file = path.join(directory, ascending2("tool"));
+    yield* fs.ensureDir(directory).pipe(Effect.orDie);
+    yield* fs.writeFileString(file, text).pipe(Effect.orDie);
+    const marker = `... ${removed} ${unit} truncated; full content saved to ${file} ...`;
+    const bounded = [];
+    let remaining = kept.join(`
+`).length;
+    let seenText = false;
+    let marked = false;
+    for (const item of content) {
+      if (item.type === "file") {
+        bounded.push(item);
+        continue;
+      }
+      if (seenText && remaining > 0)
+        remaining--;
+      seenText = true;
+      if (remaining >= item.text.length) {
+        bounded.push(item);
+        remaining -= item.text.length;
+        continue;
+      }
+      if (remaining > 0)
+        bounded.push({ ...item, text: item.text.slice(0, remaining) });
+      if (!marked)
+        bounded.push({ type: "text", text: marker });
+      remaining = 0;
+      marked = true;
+    }
+    if (!marked)
+      bounded.push({ type: "text", text: marker });
+    return {
+      ...result,
+      content: bounded,
+      metadata: { ...result.metadata, truncated: true, outputPath: file }
+    };
+  });
+  return Service55.of({
+    transform: state.transform,
+    reload: state.reload,
+    truncate,
+    cleanup: () => cleanup(fs, directory)
+  });
+}));
+var cleanupLayer = Layer.effectDiscard(Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  yield* cleanup(fs, path.join(global.data, DIRECTORY3)).pipe(Effect.repeat(Schedule.spaced(Duration.hours(1))), Effect.forkScoped);
+}));
+var cleanupNode = makeGlobalNode({
+  name: "tool-output-cleanup",
+  layer: cleanupLayer,
+  deps: [FSUtil.node, Global.node]
+});
+var node59 = makeLocationNode({
+  service: Service55,
+  layer,
+  deps: [FSUtil.node, Global.node, cleanupNode]
+});
+
+export { MAX_LINES2, MAX_BYTES2, RETENTION3, DIRECTORY3, Service55, node59, exports_tool_output2 };

package/dist/chunks/aisdk-native-9r7q4bhe.js

@@ -0,0 +1,119 @@
+import {
+  Service80
+} from "./aisdk-native-vfccn5yp.js";
+import {
+  Service79
+} from "./aisdk-native-11nvngjf.js";
+import {
+  Service42
+} from "./aisdk-native-81rrwt6s.js";
+import {
+  RelativePath2
+} from "./aisdk-native-922hggd3.js";
+import {
+  ID5,
+  Service53
+} from "./aisdk-native-y6jb2tes.js";
+import {
+  SessionEvent2
+} from "./aisdk-native-ec1grn59.js";
+import {
+  SessionMessage2
+} from "./aisdk-native-gftt206x.js";
+import {
+  MessageNotFoundError2
+} from "./aisdk-native-3x8gcmrs.js";
+import {
+  SessionMessageTable2
+} from "./aisdk-native-a1bz86dw.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/session/revert.ts
+var exports_revert = {};
+__export(exports_revert, {
+  MessageNotFoundError: () => MessageNotFoundError2,
+  SessionRevert: () => exports_revert,
+  clear: () => clear2,
+  commit: () => commit2,
+  stage: () => stage2
+});
+import { and, asc, eq, gt } from "drizzle-orm";
+import { Effect, Schema } from "effect";
+var stage2 = Effect.fn("SessionRevert.stage")(function* (input) {
+  const instances = yield* Service42;
+  const database = yield* Service80;
+  const bus = yield* Service79;
+  return yield* Effect.gen(function* () {
+    const snapshot = yield* Service53;
+    const original = input.session.revert?.snapshot ? ID5.make(input.session.revert.snapshot) : yield* snapshot.capture();
+    const next = yield* plan(database.db, { sessionID: input.session.id, messageID: input.messageID });
+    const restore = new Map;
+    if (original) {
+      for (const file of input.session.revert?.files ?? [])
+        restore.set(RelativePath2.make(file.file), original);
+    }
+    if (input.files !== false)
+      for (const [file, tree] of next)
+        restore.set(file, tree);
+    if (restore.size)
+      yield* snapshot.restore({ files: restore });
+    const paths = input.files === false ? [] : Array.from(next.keys());
+    const files = original ? yield* snapshot.diff({ from: original, to: (yield* snapshot.capture()) ?? original, paths }) : [];
+    const revert = {
+      messageID: input.messageID,
+      snapshot: original,
+      files
+    };
+    yield* bus.publish(SessionEvent2.RevertEvent.Staged, {
+      sessionID: input.session.id,
+      revert
+    });
+    return revert;
+  }).pipe(instances.provide(input.session));
+});
+var clear2 = Effect.fn("SessionRevert.clear")(function* (session) {
+  const instances = yield* Service42;
+  const bus = yield* Service79;
+  yield* Effect.gen(function* () {
+    const snapshot = yield* Service53;
+    if (!session.revert)
+      return;
+    const original = session.revert.snapshot ? ID5.make(session.revert.snapshot) : undefined;
+    if (original)
+      yield* snapshot.restore({
+        files: new Map((session.revert.files ?? []).map((file) => [RelativePath2.make(file.file), original]))
+      });
+    yield* bus.publish(SessionEvent2.RevertEvent.Cleared, {
+      sessionID: session.id
+    });
+  }).pipe(instances.provide(session));
+});
+var commit2 = Effect.fn("SessionRevert.commit")(function* (bus, session) {
+  if (!session.revert)
+    return;
+  yield* bus.publish(SessionEvent2.RevertEvent.Committed, {
+    sessionID: session.id,
+    to: session.revert.messageID
+  });
+});
+var plan = Effect.fn("SessionRevert.plan")(function* (db, input) {
+  const boundary = yield* db.select({ seq: SessionMessageTable2.seq }).from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, input.sessionID), eq(SessionMessageTable2.id, input.messageID))).get().pipe(Effect.orDie);
+  if (!boundary)
+    return yield* new MessageNotFoundError2(input);
+  const rows = yield* db.select().from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, input.sessionID), eq(SessionMessageTable2.type, "assistant"), gt(SessionMessageTable2.seq, boundary.seq))).orderBy(asc(SessionMessageTable2.seq)).all().pipe(Effect.orDie);
+  const decode = Schema.decodeUnknownEffect(SessionMessage2.Info);
+  const files = new Map;
+  for (const row of rows) {
+    const message = yield* decode({ ...row.data, id: row.id, type: row.type }).pipe(Effect.orDie);
+    if (message.type !== "assistant" || !message.snapshot?.start)
+      continue;
+    for (const file of message.snapshot.files ?? [])
+      if (!files.has(file))
+        files.set(file, ID5.make(message.snapshot.start));
+  }
+  return files;
+});
+
+export { stage2, clear2, commit2, exports_revert };

package/dist/chunks/aisdk-native-9rqn6x4v.js

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+export { __export };

package/dist/chunks/aisdk-native-9sjxd60t.js

@@ -0,0 +1,37 @@
+import {
+  latest2,
+  Service35
+} from "./aisdk-native-y9tfvs3x.js";
+import {
+  Service78
+} from "./aisdk-native-qx0n0hnh.js";
+import {
+  observe2
+} from "./aisdk-native-qsdy395h.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/config/plugin/shell.ts
+var exports_shell = {};
+__export(exports_shell, {
+  ConfigShellPlugin: () => exports_shell,
+  Plugin: () => Plugin3
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect } from "effect";
+var Plugin3 = define({
+  id: "opencode.config.shell",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* Service35;
+    const shell = yield* Service78;
+    const loaded = yield* observe2(config, ctx.event, shell.reload());
+    yield* shell.transform((editor) => {
+      const configured = latest2(loaded.entries, "shell");
+      if (configured)
+        editor.configure(configured);
+    });
+  })
+});
+
+export { Plugin3, exports_shell };