@opencode-ai/core 0.0.0-beta-19086 → 0.0.0-beta-19124

package/dist/chunks/{schema-bbwsb44a.js → event-logger-dsf4qpn2.js}

@@ -1,26 +1,27 @@
 import {
-  RipgrepBinary
-} from "./schema-rahat93a.js";
+  NonNegativeInt2,
+  PositiveInt2,
+  RelativePath2
+} from "./event-logger-p8qxwesx.js";
 import {
-  exports_environment1 as exports_environment
-} from "./schema-qa1y9c59.js";
+  Service65,
+  node69
+} from "./event-logger-22drdanb.js";
 import {
-  NonNegativeInt,
-  PositiveInt,
-  RelativePath
-} from "./schema-j07kk359.js";
+  RipgrepBinary2
+} from "./event-logger-5jvc5tg2.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/ripgrep.ts
 var exports_ripgrep = {};
 __export(exports_ripgrep, {
-  Error: () => Error,
-  InvalidPatternError: () => InvalidPatternError,
+  Error: () => Error2,
+  InvalidPatternError: () => InvalidPatternError2,
   Ripgrep: () => exports_ripgrep,
-  Service: () => Service,
-  node: () => node
+  Service: () => Service18,
+  node: () => node21
 });
 import { Context, Effect, Fiber, Layer, Schema, Stream } from "effect";
 import { ChildProcess } from "effect/unstable/process";
@@ -34,37 +35,37 @@ var RawMatch = Schema.Struct({
   data: Schema.Struct({
     path: Schema.Struct({ text: Schema.String }),
     lines: Schema.Struct({ text: Schema.String }),
-    line_number: PositiveInt,
-    absolute_offset: NonNegativeInt,
+    line_number: PositiveInt2,
+    absolute_offset: NonNegativeInt2,
     submatches: Schema.Array(Schema.Struct({
       match: Schema.Struct({ text: Schema.String }),
-      start: NonNegativeInt,
-      end: NonNegativeInt
+      start: NonNegativeInt2,
+      end: NonNegativeInt2
     }))
   })
 });
 var decodeJsonRecord = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
 
-class Error extends Schema.TaggedError()("Ripgrep.Error", {
+class Error2 extends Schema.TaggedError()("Ripgrep.Error", {
   message: Schema.String,
   cause: Schema.optional(Schema.Defect())
 }) {
 }
 
-class InvalidPatternError extends Schema.TaggedError()("Ripgrep.InvalidPatternError", {
+class InvalidPatternError2 extends Schema.TaggedError()("Ripgrep.InvalidPatternError", {
   pattern: Schema.String,
   message: Schema.String
 }) {
 }
 
-class Service extends Context.Service()("@opencode/Ripgrep") {
+class Service18 extends Context.Service()("@opencode/Ripgrep") {
 }
-var failure = (message, cause) => new Error({ message, cause });
+var failure = (message, cause) => new Error2({ message, cause });
 var normalizePath = (value) => value.replace(/^(?:\.[\\/])+/u, "").replace(/^[\\/]+/u, "").replaceAll("\\", "/");
 var isInvalidPattern = (stderr) => stderr.includes("regex parse error") || stderr.includes("error parsing regex");
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const environment = yield* exports_environment.Service;
-  const binary = yield* RipgrepBinary.Service;
+var layer = Layer.effect(Service18, Effect.gen(function* () {
+  const environment = yield* Service65;
+  const binary = yield* RipgrepBinary2.Service;
   const run = (input) => {
     const program = Effect.scoped(Effect.gen(function* () {
       const handle = yield* environment.spawner.spawn(ChildProcess.make(yield* binary.filepath, input.args, { cwd: input.cwd, extendEnv: true, stdin: "ignore" }));
@@ -81,7 +82,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       const code = yield* handle.exitCode;
       const stderr = yield* Fiber.join(stderrFiber);
       if (input.pattern && code === 2 && isInvalidPattern(stderr)) {
-        return yield* new InvalidPatternError({ pattern: input.pattern, message: stderr.trim() });
+        return yield* new InvalidPatternError2({ pattern: input.pattern, message: stderr.trim() });
       }
       if (code !== 0 && code !== 1 && code !== 2) {
         return yield* failure(stderr.trim() || `ripgrep failed with code ${code}`);
@@ -89,9 +90,9 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       return code === 1 ? [] : rows;
     }));
     const abortable = input.signal ? program.pipe(Effect.raceFirst(waitForAbort(input.signal))) : program;
-    return abortable.pipe(Effect.mapError((cause) => cause instanceof Error || cause instanceof InvalidPatternError ? cause : failure("ripgrep execution failed", cause)));
+    return abortable.pipe(Effect.mapError((cause) => cause instanceof Error2 || cause instanceof InvalidPatternError2 ? cause : failure("ripgrep execution failed", cause)));
   };
-  return Service.of({
+  return Service18.of({
     glob: (input) => run({
       cwd: input.cwd,
       limit: input.limit,
@@ -107,7 +108,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       ],
       parse: (line) => Effect.succeed(normalizePath(line))
     }).pipe(Effect.map((result) => result.map((relative) => Entry.make({
-      path: RelativePath.make(relative),
+      path: RelativePath2.make(relative),
       type: "file"
     }))), Effect.catchTag("Ripgrep.InvalidPatternError", (cause) => Effect.fail(failure(cause.message, cause)))),
     find: (input) => run({
@@ -127,7 +128,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       parse: (line) => {
         const relative = normalizePath(line);
         return Effect.succeed(Entry.make({
-          path: RelativePath.make(relative),
+          path: RelativePath2.make(relative),
           type: "file"
         }));
       },
@@ -159,7 +160,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       }))
     }).pipe(Effect.map((result) => result.map((match) => Match.make({
       entry: Entry.make({
-        path: RelativePath.make(match.path.text),
+        path: RelativePath2.make(match.path.text),
         type: "file"
       }),
       line: match.line_number,
@@ -173,6 +174,6 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     }))))
   });
 }));
-var node = makeLocationNode({ service: Service, layer, deps: [exports_environment.node, RipgrepBinary.node] });
+var node21 = makeLocationNode({ service: Service18, layer, deps: [node69, RipgrepBinary2.node] });
 
-export { Error, InvalidPatternError, Service, node, exports_ripgrep };
+export { Error2, InvalidPatternError2, Service18, node21, exports_ripgrep };

package/dist/chunks/{schema-ng85ggsa.js → event-logger-dzfg11yk.js}

@@ -1,26 +1,32 @@
 import {
-  exports_mcp as exports_mcp2
-} from "./schema-e7nnc03a.js";
+  Key4,
+  removed2,
+  empty3,
+  make20,
+  diffByKey2
+} from "./event-logger-1z80kc63.js";
 import {
-  exports_mcp
-} from "./schema-kwh3ary7.js";
+  evaluate2
+} from "./event-logger-yzjhj2th.js";
 import {
-  exports_permission
-} from "./schema-1nf5m1zv.js";
+  Service40,
+  node43
+} from "./event-logger-2mqy9ydc.js";
 import {
-  exports_instructions
-} from "./schema-c54e84vp.js";
+  namespace2,
+  name13
+} from "./event-logger-9r3tzwf8.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/mcp/instructions.ts
 var exports_instructions2 = {};
 __export(exports_instructions2, {
   McpInstructions: () => exports_instructions2,
-  Service: () => Service,
-  layer: () => layer,
-  node: () => node
+  Service: () => Service31,
+  layer: () => layer13,
+  node: () => node34
 });
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Context, Effect, Layer, Schema } from "effect";
@@ -32,7 +38,7 @@ var Summary = Schema.Struct({
 var entries = (servers) => servers.flatMap((server) => {
   const result = [`  <server name="${server.server}">`];
   if (server.codemode !== false)
-    result.push(`    Use tools from this server through \`execute\` under \`tools[${JSON.stringify(exports_mcp2.namespace(server.server))}]\`.`);
+    result.push(`    Use tools from this server through \`execute\` under \`tools[${JSON.stringify(namespace2(server.server))}]\`.`);
   result.push(...server.instructions.split(`
 `).map((line) => `    ${line}`), "  </server>");
   return result;
@@ -40,7 +46,7 @@ var entries = (servers) => servers.flatMap((server) => {
 var render = (servers) => ["<mcp_instructions>", ...entries(servers), "</mcp_instructions>"].join(`
 `);
 var update = (previous, current) => {
-  const diff = exports_instructions.diffByKey(previous, current, (server) => server.server, (before, after) => before.instructions !== after.instructions || before.codemode !== after.codemode);
+  const diff = diffByKey2(previous, current, (server) => server.server, (before, after) => before.instructions !== after.instructions || before.codemode !== after.codemode);
   if (diff.changed.length > 0 || diff.added.length === 0 && diff.removed.length === 0)
     return [
       "The available MCP server instructions have changed. This list supersedes the previous one.",
@@ -56,17 +62,17 @@ var update = (previous, current) => {
 `);
 };
 
-class Service extends Context.Service()("@opencode/McpInstructions") {
+class Service31 extends Context.Service()("@opencode/McpInstructions") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const mcp = yield* exports_mcp.Service;
-  return Service.of({
+var layer13 = Layer.effect(Service31, Effect.gen(function* () {
+  const mcp = yield* Service40;
+  return Service31.of({
     load: Effect.fn("McpInstructions.load")(function* (selection) {
       const agent = selection.info;
       if (!agent)
-        return exports_instructions.empty;
-      const source = (value) => exports_instructions.make({
-        key: exports_instructions.Key.make("core/mcp-guidance"),
+        return empty3;
+      const source = (value) => make20({
+        key: Key4.make("core/mcp-guidance"),
         codec: Schema.toCodecJson(Schema.Array(Summary)),
         read: Effect.succeed(value),
         render: {
@@ -78,22 +84,22 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       const [instructions, tools] = yield* Effect.all([mcp.instructions(), mcp.tools()], {
         concurrency: "unbounded"
       });
-      const canExecute = exports_permission.evaluate("execute", "*", agent.permissions).effect !== "deny";
+      const canExecute = evaluate2("execute", "*", agent.permissions).effect !== "deny";
       const visible = instructions.flatMap((item) => {
         const owned = tools.filter((tool) => tool.server === item.server);
         const codemode = owned[0]?.codemode !== false;
         if (codemode && !canExecute)
           return [];
-        if (!owned.some((tool) => exports_permission.evaluate(exports_mcp2.name(tool.server, tool.name), "*", agent.permissions).effect !== "deny"))
+        if (!owned.some((tool) => evaluate2(name13(tool.server, tool.name), "*", agent.permissions).effect !== "deny"))
           return [];
         return [
           codemode ? { server: item.server, instructions: item.instructions } : { server: item.server, instructions: item.instructions, codemode: false }
         ];
       }).toSorted((a, b) => a.server.localeCompare(b.server));
-      return source(visible.length === 0 ? exports_instructions.removed : visible);
+      return source(visible.length === 0 ? removed2 : visible);
     })
   });
 }));
-var node = makeLocationNode({ service: Service, layer, deps: [exports_mcp.node] });
+var node34 = makeLocationNode({ service: Service31, layer: layer13, deps: [node43] });
 
-export { Service, layer, node, exports_instructions2 as exports_instructions };
+export { Service31, layer13, node34, exports_instructions2 };

package/dist/chunks/{schema-aep5wxg9.js → event-logger-e4x9q39t.js}

@@ -1,34 +1,34 @@
 import {
-  DiffError
-} from "./schema-d26zqcqt.js";
+  Service75
+} from "./event-logger-00s3pqt3.js";
 import {
-  MAX_PATCH_BYTES,
-  MAX_TOTAL_PATCH_BYTES,
-  PATCH_CONTEXT_LINES,
-  chunksByFile,
-  emptyPatch
-} from "./schema-3chx3ng6.js";
+  PATCH_CONTEXT_LINES2,
+  MAX_PATCH_BYTES2,
+  MAX_TOTAL_PATCH_BYTES2,
+  emptyPatch2,
+  chunksByFile2
+} from "./event-logger-tazgh4e4.js";
 import {
-  exports_location
-} from "./schema-9kt3hna5.js";
+  DiffError2
+} from "./event-logger-vwbmxwbe.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/plugin/vcs/git.ts
 var exports_git = {};
 __export(exports_git, {
-  Plugin: () => Plugin,
+  Plugin: () => Plugin7,
   VcsGitPlugin: () => exports_git
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Effect } from "effect";
 import { ChildProcess } from "effect/unstable/process";
 import { AppProcess } from "@opencode-ai/util/process";
-var Plugin = define({
+var Plugin7 = define({
   id: "opencode.vcs.git",
   effect: Effect.fn("VcsGitPlugin")(function* (ctx) {
-    const location = yield* exports_location.Service;
+    const location = yield* Service75;
     if (location.vcs?.type !== "git")
       return;
     const processes = yield* AppProcess.Service;
@@ -88,7 +88,7 @@ function make(proc, input) {
       const base = options?.base ?? (yield* git.defaultBranch(ctx.directory))?.ref;
       const ref = base ? yield* git.mergeBase(ctx.directory, base) : undefined;
       if (!ref) {
-        return yield* new DiffError({
+        return yield* new DiffError2({
           message: base ? `No merge base available for ${base}` : "No review base available"
         });
       }
@@ -221,7 +221,7 @@ function makeGit(proc) {
       return null;
     const current = yield* branch(cwd);
     if (!current)
-      return yield* new DiffError({ message: "Choose a review base" });
+      return yield* new DiffError2({ message: "Choose a review base" });
     const history = (yield* lines(["reflog", "show", "--max-count=256", "--format=%H%x00%gs", `refs/heads/${current}`], {
       cwd
     })).flatMap((line) => {
@@ -232,25 +232,25 @@ function makeGit(proc) {
     const creation = renamed ? undefined : history.find((entry) => entry.message.startsWith("branch: Created from "));
     const origin = creation?.message.slice("branch: Created from ".length);
     if (creation && origin) {
-      const candidate2 = yield* namedRef(cwd, origin);
-      if (candidate2 && candidate2.name !== current && (yield* ancestor(cwd, creation.commit, "HEAD")) && (yield* ancestor(cwd, creation.commit, candidate2.ref))) {
-        return { ...candidate2, source: "reflog" };
+      const candidate = yield* namedRef(cwd, origin);
+      if (candidate && candidate.name !== current && (yield* ancestor(cwd, creation.commit, "HEAD")) && (yield* ancestor(cwd, creation.commit, candidate.ref))) {
+        return { ...candidate, source: "reflog" };
       }
     }
     const root = yield* defaultBranch(cwd);
     if (!root || current !== root.name)
-      return yield* new DiffError({ message: "Choose a review base" });
+      return yield* new DiffError2({ message: "Choose a review base" });
     const candidate = yield* namedRef(cwd, root.ref);
     if (!candidate)
-      return yield* new DiffError({ message: "The default review base is unavailable" });
+      return yield* new DiffError2({ message: "The default review base is unavailable" });
     return { name: root.name, ref: candidate.ref, source: "default" };
   });
   const hasHead = Effect.fn("VcsGit.hasHead")(function* (cwd) {
     const result = yield* run(["rev-parse", "--verify", "HEAD"], { cwd });
     return result.exitCode === 0;
   });
-  const mergeBase = Effect.fn("VcsGit.mergeBase")(function* (cwd, base2) {
-    const ref = yield* resolve(cwd, base2);
+  const mergeBase = Effect.fn("VcsGit.mergeBase")(function* (cwd, base) {
+    const ref = yield* resolve(cwd, base);
     if (!ref)
       return;
     const result = yield* run(["merge-base", ref, "HEAD"], { cwd });
@@ -270,7 +270,7 @@ function makeGit(proc) {
   const diff = Effect.fn("VcsGit.diffNames")(function* (cwd, ref, target) {
     const result = yield* run(["diff", "--no-ext-diff", "--no-renames", "--name-status", "-z", ref, ...target ? [target] : [], "--", "."], { cwd });
     if (result.exitCode !== 0)
-      return yield* new DiffError({ message: "Unable to list Git changes" });
+      return yield* new DiffError2({ message: "Unable to list Git changes" });
     const list = nuls(result.text());
     return list.flatMap((code, idx) => {
       if (idx % 2 !== 0)
@@ -394,40 +394,40 @@ var batchPatches = Effect.fnUntraced(function* (ctx, ref, list, options) {
     return emptyBatch();
   const result = yield* ctx.git.patchAll(ctx.directory, ref, {
     target: options?.target,
-    context: options?.context ?? PATCH_CONTEXT_LINES,
-    maxOutputBytes: MAX_TOTAL_PATCH_BYTES
+    context: options?.context ?? PATCH_CONTEXT_LINES2,
+    maxOutputBytes: MAX_TOTAL_PATCH_BYTES2
   });
   return {
-    patches: chunksByFile(result, (index) => list[index]?.file),
+    patches: chunksByFile2(result, (index) => list[index]?.file),
     capped: result.truncated
   };
 });
 var nativePatch = Effect.fnUntraced(function* (ctx, ref, item, options) {
   const result = item.code === "??" || !ref ? yield* ctx.git.patchUntracked(ctx.worktree, item.file, {
-    context: options?.context ?? PATCH_CONTEXT_LINES,
-    maxOutputBytes: MAX_PATCH_BYTES
+    context: options?.context ?? PATCH_CONTEXT_LINES2,
+    maxOutputBytes: MAX_PATCH_BYTES2
   }) : yield* ctx.git.patch(ctx.worktree, ref, item.file, {
     target: options?.target,
-    context: options?.context ?? PATCH_CONTEXT_LINES,
-    maxOutputBytes: MAX_PATCH_BYTES
+    context: options?.context ?? PATCH_CONTEXT_LINES2,
+    maxOutputBytes: MAX_PATCH_BYTES2
   });
   if (!result.truncated && result.text)
     return result.text;
-  return emptyPatch(item.file);
+  return emptyPatch2(item.file);
 });
 var totalPatch = (file, patch, total) => {
-  if (total + Buffer.byteLength(patch) <= MAX_TOTAL_PATCH_BYTES)
+  if (total + Buffer.byteLength(patch) <= MAX_TOTAL_PATCH_BYTES2)
     return { patch, capped: false };
-  return { patch: emptyPatch(file), capped: true };
+  return { patch: emptyPatch2(file), capped: true };
 };
 var patchForItem = Effect.fnUntraced(function* (ctx, ref, item, batch, capped, options) {
   if (capped)
-    return emptyPatch(item.file);
+    return emptyPatch2(item.file);
   const batched = batch.patches.get(item.file);
   if (batched !== undefined)
     return batched;
   if (item.code !== "??" && batch.capped)
-    return emptyPatch(item.file);
+    return emptyPatch2(item.file);
   return yield* nativePatch(ctx, ref, item, options);
 });
 var files = Effect.fnUntraced(function* (ctx, ref, list, map, batch, options) {
@@ -441,7 +441,7 @@ var files = Effect.fnUntraced(function* (ctx, ref, list, map, batch, options) {
     capped = capped || result.capped;
     if (!capped) {
       total += Buffer.byteLength(result.patch);
-      capped = total >= MAX_TOTAL_PATCH_BYTES;
+      capped = total >= MAX_TOTAL_PATCH_BYTES2;
     }
     next.push({
       file: item.file,
@@ -467,4 +467,4 @@ var track = Effect.fnUntraced(function* (ctx, ref, options) {
   return yield* diffAgainstRef(ctx, ref, options);
 });
 
-export { Plugin, exports_git };
+export { Plugin7, exports_git };

package/dist/chunks/{schema-wj4sxzqa.js → event-logger-e73j6tqm.js}

@@ -10,7 +10,7 @@ var compoundFilterSchema = z.object({
   type: z.enum(["and", "or"]),
   filters: z.array(z.union([comparisonFilterSchema, z.lazy(() => compoundFilterSchema)]))
 });
-var fileSearchArgsSchema = z.object({
+var fileSearchArgsSchema2 = z.object({
   vectorStoreIds: z.array(z.string()),
   maxNumResults: z.number().optional(),
   ranking: z.object({
@@ -19,7 +19,7 @@ var fileSearchArgsSchema = z.object({
   }).optional(),
   filters: z.union([comparisonFilterSchema, compoundFilterSchema]).optional()
 });
-var fileSearchOutputSchema = z.object({
+var fileSearchOutputSchema2 = z.object({
   queries: z.array(z.string()),
   results: z.array(z.object({
     attributes: z.record(z.string(), z.unknown()),
@@ -29,10 +29,10 @@ var fileSearchOutputSchema = z.object({
     text: z.string()
   })).nullable()
 });
-var fileSearch = createProviderToolFactoryWithOutputSchema({
+var fileSearch2 = createProviderToolFactoryWithOutputSchema({
   id: "openai.file_search",
   inputSchema: z.object({}),
-  outputSchema: fileSearchOutputSchema
+  outputSchema: fileSearchOutputSchema2
 });
 
-export { fileSearchArgsSchema, fileSearchOutputSchema, fileSearch };
+export { fileSearchArgsSchema2, fileSearchOutputSchema2, fileSearch2 };

package/dist/chunks/{schema-6b7ybj1y.js → event-logger-ecjyhxv0.js}

@@ -1,50 +1,50 @@
 import {
-  exports_id
-} from "./schema-x4az4y7r.js";
+  cleanup3
+} from "./event-logger-gd4qta3r.js";
 import {
-  exports_file_retention
-} from "./schema-p1m5qwvv.js";
+  ascending2
+} from "./event-logger-k4bwy1x5.js";
 import {
-  exports_state
-} from "./schema-j6s3yjyb.js";
+  create3
+} from "./event-logger-kg06axw8.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/tool-output.ts
-var exports_tool_output = {};
-__export(exports_tool_output, {
-  DIRECTORY: () => DIRECTORY,
-  MAX_BYTES: () => MAX_BYTES,
-  MAX_LINES: () => MAX_LINES,
-  RETENTION: () => RETENTION,
-  Service: () => Service,
-  ToolOutput: () => exports_tool_output,
-  node: () => node
+var exports_tool_output2 = {};
+__export(exports_tool_output2, {
+  DIRECTORY: () => DIRECTORY3,
+  MAX_BYTES: () => MAX_BYTES2,
+  MAX_LINES: () => MAX_LINES2,
+  RETENTION: () => RETENTION3,
+  Service: () => Service54,
+  ToolOutput: () => exports_tool_output2,
+  node: () => node57
 });
 import path from "path";
 import { Context, Duration, Effect, Layer, Schedule } from "effect";
 import { makeGlobalNode, makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { FSUtil } from "@opencode-ai/util/fs-util";
 import { Global } from "@opencode-ai/util/global";
-var MAX_LINES = 2000;
-var MAX_BYTES = 50 * 1024;
-var RETENTION = Duration.days(7);
-var DIRECTORY = "tool-output";
+var MAX_LINES2 = 2000;
+var MAX_BYTES2 = 50 * 1024;
+var RETENTION3 = Duration.days(7);
+var DIRECTORY3 = "tool-output";
 
-class Service extends Context.Service()("@opencode/ToolOutput") {
+class Service54 extends Context.Service()("@opencode/ToolOutput") {
 }
 var cleanup = Effect.fn("ToolOutput.cleanup")(function* (fs, directory) {
-  const entries = yield* fs.readDirectory(directory).pipe(Effect.map((entries2) => entries2.filter((entry) => /^tool_[0-9a-f]{12}/.test(entry))), Effect.orElseSucceed(() => []));
-  yield* exports_file_retention.cleanup(fs, entries.map((entry) => path.join(directory, entry)), RETENTION);
+  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(Service, Effect.gen(function* () {
+var layer = Layer.effect(Service54, Effect.gen(function* () {
   const fs = yield* FSUtil.Service;
   const global = yield* Global.Service;
-  const directory = path.join(global.data, DIRECTORY);
-  const state = exports_state.create({
+  const directory = path.join(global.data, DIRECTORY3);
+  const state = create3({
     name: "tool-output",
-    initial: () => ({ maxLines: MAX_LINES, maxBytes: MAX_BYTES }),
+    initial: () => ({ maxLines: MAX_LINES2, maxBytes: MAX_BYTES2 }),
     editor: (editor) => ({
       configure: (limits) => {
         if (limits.maxLines !== undefined)
@@ -85,7 +85,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       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, exports_id.ascending("tool"));
+    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} ...`;
@@ -122,7 +122,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       metadata: { ...result.metadata, truncated: true, outputPath: file }
     };
   });
-  return Service.of({
+  return Service54.of({
     transform: state.transform,
     reload: state.reload,
     truncate,
@@ -132,17 +132,17 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
 var cleanupLayer = Layer.effectDiscard(Effect.gen(function* () {
   const fs = yield* FSUtil.Service;
   const global = yield* Global.Service;
-  yield* cleanup(fs, path.join(global.data, DIRECTORY)).pipe(Effect.repeat(Schedule.spaced(Duration.hours(1))), Effect.forkScoped);
+  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 node = makeLocationNode({
-  service: Service,
+var node57 = makeLocationNode({
+  service: Service54,
   layer,
   deps: [FSUtil.node, Global.node, cleanupNode]
 });
 
-export { MAX_LINES, MAX_BYTES, RETENTION, DIRECTORY, Service, node, exports_tool_output };
+export { MAX_LINES2, MAX_BYTES2, RETENTION3, DIRECTORY3, Service54, node57, exports_tool_output2 };

package/dist/chunks/{schema-5a5ch9ts.js → event-logger-eh3zwz77.js}

@@ -1,17 +1,17 @@
 // src/github-copilot/responses/tool/code-interpreter.ts
 import { createProviderToolFactoryWithOutputSchema } from "@ai-sdk/provider-utils";
 import { z } from "zod/v4";
-var codeInterpreterInputSchema = z.object({
+var codeInterpreterInputSchema2 = z.object({
   code: z.string().nullish(),
   containerId: z.string()
 });
-var codeInterpreterOutputSchema = z.object({
+var codeInterpreterOutputSchema2 = z.object({
   outputs: z.array(z.discriminatedUnion("type", [
     z.object({ type: z.literal("logs"), logs: z.string() }),
     z.object({ type: z.literal("image"), url: z.string() })
   ])).nullish()
 });
-var codeInterpreterArgsSchema = z.object({
+var codeInterpreterArgsSchema2 = z.object({
   container: z.union([
     z.string(),
     z.object({
@@ -19,13 +19,13 @@ var codeInterpreterArgsSchema = z.object({
     })
   ]).optional()
 });
-var codeInterpreterToolFactory = createProviderToolFactoryWithOutputSchema({
+var codeInterpreterToolFactory2 = createProviderToolFactoryWithOutputSchema({
   id: "openai.code_interpreter",
-  inputSchema: codeInterpreterInputSchema,
-  outputSchema: codeInterpreterOutputSchema
+  inputSchema: codeInterpreterInputSchema2,
+  outputSchema: codeInterpreterOutputSchema2
 });
-var codeInterpreter = (args = {}) => {
-  return codeInterpreterToolFactory(args);
+var codeInterpreter2 = (args = {}) => {
+  return codeInterpreterToolFactory2(args);
 };
 
-export { codeInterpreterInputSchema, codeInterpreterOutputSchema, codeInterpreterArgsSchema, codeInterpreterToolFactory, codeInterpreter };
+export { codeInterpreterInputSchema2, codeInterpreterOutputSchema2, codeInterpreterArgsSchema2, codeInterpreterToolFactory2, codeInterpreter2 };