@opencode-ai/core 0.0.0-beta-18314 → 0.0.0-beta-18381

package/dist/chunks/snapshot-msys3ym3.js

@@ -0,0 +1,324 @@
+import {
+  MAX_STEPS_PROMPT
+} from "./snapshot-qaarhjrp.js";
+import {
+  exports_step
+} from "./snapshot-3kdy3jz5.js";
+import {
+  exports_retry
+} from "./snapshot-a09abg6q.js";
+import {
+  exports_title
+} from "./snapshot-dcerdtt9.js";
+import {
+  exports_prompt_cache_diagnostics
+} from "./snapshot-wd268jeg.js";
+import {
+  exports_context
+} from "./snapshot-cp2m8bkb.js";
+import {
+  exports_supervisor
+} from "./snapshot-45y5aksg.js";
+import {
+  exports_model_request
+} from "./snapshot-3dap0q13.js";
+import {
+  exports_compaction
+} from "./snapshot-7h4d1ktr.js";
+import {
+  exports_tool_output
+} from "./snapshot-f7q7a28y.js";
+import {
+  DrainResult,
+  Service
+} from "./snapshot-2m0hgr65.js";
+import {
+  exports_inbox
+} from "./snapshot-mkaeg0rc.js";
+import {
+  exports_model_transport
+} from "./snapshot-d4ax61k3.js";
+import {
+  llmClient
+} from "./snapshot-k42t1tha.js";
+import {
+  exports_store
+} from "./snapshot-c4sv2ydx.js";
+import {
+  exports_instruction_state
+} from "./snapshot-ztjk4rav.js";
+import {
+  StepFailedError
+} from "./snapshot-fb7nfzf2.js";
+import {
+  SessionEvent
+} from "./snapshot-a83yvq99.js";
+import {
+  exports_snapshot
+} from "./snapshot-2m73nq4z.js";
+import {
+  SessionMessage
+} from "./snapshot-8rpfd2h6.js";
+import {
+  exports_bus
+} from "./snapshot-prx0wmsc.js";
+import {
+  exports_database
+} from "./snapshot-kwb0smgr.js";
+import {
+  __export
+} from "./snapshot-rvfvac9x.js";
+
+// src/session/runner/llm.ts
+var exports_llm = {};
+__export(exports_llm, {
+  node: () => node,
+  SessionRunnerLLM: () => exports_llm
+});
+import { Message } from "@opencode-ai/ai";
+import { Cause, Config, Effect, Exit, FiberMap, Layer, Pull, Schedule } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+var CONTINUE_AFTER_INCOMPLETE_STREAM = "The previous response was interrupted. Continue from where you left off without repeating completed content.";
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const store = yield* exports_store.Service;
+  const context = yield* exports_context.Service;
+  const modelTransport = yield* exports_model_transport.Service;
+  const db = (yield* exports_database.Service).db;
+  const compaction = yield* exports_compaction.Service;
+  const plugins = yield* exports_supervisor.Service;
+  const title = yield* exports_title.Service;
+  const steps = yield* exports_step.make;
+  const diagnostics = yield* Config.boolean("OPENCODE_PROMPT_CACHE_DIAGNOSTICS").pipe(Config.withDefault(false), Effect.orDie);
+  const promptCacheSnapshots = diagnostics ? new Map : undefined;
+  const diagnosePromptCache = Effect.fn("SessionRunner.diagnosePromptCache")(function* (sessionID, request) {
+    if (!promptCacheSnapshots)
+      return;
+    const current = exports_prompt_cache_diagnostics.snapshot(request);
+    const comparison = exports_prompt_cache_diagnostics.compare(promptCacheSnapshots.get(sessionID), current);
+    promptCacheSnapshots.delete(sessionID);
+    promptCacheSnapshots.set(sessionID, current);
+    const oldest = promptCacheSnapshots.keys().next().value;
+    if (promptCacheSnapshots.size > 100 && oldest !== undefined)
+      promptCacheSnapshots.delete(oldest);
+    yield* Effect.logInfo("prompt cache prefix").pipe(Effect.annotateLogs({
+      sessionID,
+      toolCount: current.tools.length,
+      systemParts: current.system.length,
+      messageCount: current.messages.length,
+      ...comparison
+    }));
+  });
+  const titles = yield* FiberMap.make();
+  const drain = Effect.fn("SessionRunner.drain")(function* (input) {
+    const sessionID = input.sessionID;
+    let force = input.force;
+    let continuing = input.continuation !== undefined;
+    let step = input.continuation?.step ?? 1;
+    let entering = true;
+    const promotable = input.promotable ?? "input";
+    if (!force && !continuing) {
+      const pending = yield* exports_inbox.nextPromotable(db, sessionID, "input");
+      if (!pending || pending.delivery === "queue" && promotable === "steer" && pending.type !== "compaction" && pending.type !== "move")
+        return DrainResult.Complete();
+    }
+    yield* plugins.flush;
+    yield* settleStaleToolCalls(sessionID);
+    const advanceToStep = Effect.fn("SessionRunner.advanceToStep")(() => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+      while (true) {
+        const pending = yield* exports_inbox.serialized(sessionID, Effect.gen(function* () {
+          const next = yield* exports_inbox.nextPromotable(db, sessionID, entering || !continuing ? "input" : "steer");
+          if (next?.type === "compaction")
+            yield* bus.publishAll([
+              [SessionEvent.InboxDelivered, { sessionID, inboxID: next.id }],
+              [SessionEvent.Compaction.Started, { sessionID, reason: "manual", recent: "", inputID: next.id }]
+            ]);
+          if (next?.type === "move")
+            yield* restore(Effect.gen(function* () {
+              yield* modelTransport.close(sessionID);
+              yield* bus.publishAll([
+                [SessionEvent.InboxDelivered, { sessionID, inboxID: next.id }],
+                [SessionEvent.Moved, { sessionID, ...next.payload }]
+              ]);
+            }));
+          return next;
+        }));
+        if (!continuing && pending?.delivery !== "steer") {
+          entering = true;
+          step = 1;
+        }
+        if (pending?.type === "move")
+          return DrainResult.Moved({ continuation: !entering && continuing ? { step } : undefined });
+        if (pending?.type === "compaction") {
+          const session = yield* store.get(sessionID);
+          if (!session)
+            return yield* Effect.die(new Error(`Session not found: ${sessionID}`));
+          const compacted = yield* restore(Effect.gen(function* () {
+            return yield* compaction.compactManual({
+              session,
+              resolveModel: context.resolveModel,
+              prepare: context.prepare,
+              messages: yield* store.context(sessionID),
+              inputID: pending.id,
+              started: true
+            });
+          })).pipe(Effect.exit);
+          if (Exit.isFailure(compacted)) {
+            yield* bus.publish(SessionEvent.Compaction.Failed, {
+              sessionID,
+              reason: "manual",
+              error: Cause.hasInterruptsOnly(compacted.cause) ? { type: "aborted", message: "Compaction cancelled" } : { type: "compaction.failed", message: Cause.pretty(compacted.cause) },
+              inputID: pending.id
+            });
+            return yield* Effect.failCause(compacted.cause);
+          }
+          force = false;
+          continue;
+        }
+        if (!force && !continuing && (!pending || pending.delivery === "queue" && promotable === "steer"))
+          return DrainResult.Complete();
+        return yield* restore(Effect.gen(function* () {
+          const selected = yield* prepareContext(sessionID);
+          const promoted = yield* exports_inbox.promote(db, bus, sessionID, entering && !continuing ? promotable : "steer");
+          if (promoted > 0 && !selected.session.parentID && exports_title.isUntitled(selected.session))
+            yield* FiberMap.run(titles, sessionID, title.generate(sessionID).pipe(Effect.ignore), {
+              onlyIfMissing: true
+            });
+          if (promoted > 0)
+            step = 1;
+          return { _tag: "Ready", context: yield* context.load(selected) };
+        }));
+      }
+    })));
+    while (true) {
+      const next = yield* advanceToStep();
+      if (next._tag !== "Ready")
+        return next;
+      continuing = yield* runStep(next.context, step);
+      step++;
+      force = false;
+      entering = false;
+    }
+  });
+  const prepareContext = Effect.fn("SessionRunner.prepareContext")(function* (sessionID) {
+    const selected = yield* context.select(sessionID);
+    yield* exports_instruction_state.prepare(db, bus, selected.instructions, sessionID);
+    return selected;
+  });
+  const runStep = Effect.fn("SessionRunner.runStep")(function* (first, step) {
+    const sessionID = first.session.id;
+    let assistantMessageID = SessionMessage.ID.create();
+    const retry = yield* Schedule.toStepWithSleep(exports_retry.schedule(bus, sessionID));
+    let initial = first;
+    let recoverOverflow = true;
+    let recoverContinuation = true;
+    while (true) {
+      const loaded = initial ?? (yield* prepareContext(sessionID).pipe(Effect.flatMap(context.load)));
+      initial = undefined;
+      const compactionInput = {
+        session: loaded.session,
+        messages: loaded.messages,
+        resolved: loaded.model,
+        prepare: context.prepare
+      };
+      if (compaction.required(compactionInput)) {
+        const compacted = yield* compaction.compact(compactionInput);
+        if (compacted.status !== "completed")
+          return yield* new StepFailedError({ error: compacted.error });
+        assistantMessageID = SessionMessage.ID.create();
+        continue;
+      }
+      const stepLimitReached = loaded.agent.info.steps !== undefined && step >= loaded.agent.info.steps;
+      const transcript = exports_model_request.baseTranscript({
+        agent: loaded.agent.info,
+        model: loaded.model,
+        tools: loaded.tools,
+        initial: loaded.initial,
+        messages: loaded.messages
+      });
+      const prepared = yield* context.prepare({
+        scope: { session: loaded.session, agentID: loaded.agent.id, model: loaded.model, tools: loaded.tools },
+        transcript: {
+          system: transcript.system,
+          messages: stepLimitReached ? [...transcript.messages, Message.assistant(MAX_STEPS_PROMPT)] : transcript.messages
+        },
+        toolChoice: stepLimitReached ? "none" : undefined,
+        webSocket: "session"
+      });
+      yield* diagnosePromptCache(sessionID, prepared.request);
+      const outcome = yield* steps.attempt({
+        sessionID,
+        assistantMessageID,
+        agent: loaded.agent.id,
+        model: loaded.model,
+        prepared,
+        toolsDisabled: stepLimitReached,
+        recoverContinuation,
+        recoverOverflow: Effect.suspend(() => recoverOverflow && compaction.enabled() ? compaction.compact(compactionInput).pipe(Effect.map((result) => result.status === "completed")) : Effect.succeed(false))
+      });
+      if (outcome._tag === "Completed")
+        return outcome.needsContinuation;
+      if (outcome._tag === "Retry" || outcome._tag === "Continue") {
+        yield* retry({ cause: outcome.cause, error: outcome.error, assistantMessageID }).pipe(Pull.catchDone(() => Effect.gen(function* () {
+          if (outcome._tag === "Retry")
+            yield* bus.publish(SessionEvent.Step.Failed, { sessionID, assistantMessageID, error: outcome.error });
+          return yield* outcome.cause;
+        })));
+        if (outcome._tag === "Continue") {
+          yield* bus.publish(SessionEvent.Synthetic, { sessionID, text: CONTINUE_AFTER_INCOMPLETE_STREAM });
+          assistantMessageID = SessionMessage.ID.create();
+        }
+        continue;
+      }
+      if (outcome._tag === "Compacted") {
+        recoverOverflow = false;
+        assistantMessageID = SessionMessage.ID.create();
+        continue;
+      }
+      recoverContinuation = false;
+    }
+  });
+  const settleStaleToolCalls = Effect.fn("SessionRunner.settleStaleToolCalls")(function* (sessionID) {
+    for (const message of yield* store.context(sessionID)) {
+      if (message.type !== "assistant")
+        continue;
+      for (const tool of message.content) {
+        if (tool.type !== "tool" || tool.state.status !== "streaming" && tool.state.status !== "running")
+          continue;
+        const metadata = tool.state.status === "running" ? tool.state.metadata : undefined;
+        const childID = tool.name === "subagent" && typeof metadata?.sessionID === "string" ? metadata.sessionID : undefined;
+        yield* bus.publish(SessionEvent.Tool.Failed, {
+          sessionID,
+          assistantMessageID: message.id,
+          id: tool.id,
+          error: {
+            type: "aborted",
+            message: `Tool execution interrupted: ${tool.name}${childID ? ` (sessionID: ${childID})` : ""}`
+          },
+          ...metadata && Object.keys(metadata).length > 0 ? { metadata } : {},
+          executed: tool.executed === true
+        });
+      }
+    }
+  });
+  return Service.of({ drain });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [
+    exports_bus.node,
+    llmClient,
+    exports_context.node,
+    exports_model_transport.node,
+    exports_store.node,
+    exports_compaction.node,
+    exports_supervisor.node,
+    exports_title.node,
+    exports_snapshot.node,
+    exports_tool_output.node,
+    exports_database.node
+  ]
+});
+
+export { node, exports_llm };

package/dist/chunks/{job-tb33ng7x.js → snapshot-mw2kp8b7.js}

@@ -1,9 +1,18 @@
 import {
   exports_id
-} from "./job-58xdvehb.js";
+} from "./snapshot-58xdvehb.js";
+import {
+  exports_kv
+} from "./snapshot-d2nk018e.js";
+import {
+  SessionMessage
+} from "./snapshot-8rpfd2h6.js";
+import {
+  SessionSchema
+} from "./snapshot-bjwj8hwv.js";
 import {
   __export
-} from "./job-rvfvac9x.js";
+} from "./snapshot-rvfvac9x.js";
 
 // src/job.ts
 var exports_job = {};
@@ -13,8 +22,33 @@ __export(exports_job, {
   Service: () => Service,
   Job: () => exports_job
 });
-import { Cause, Clock, Context, Deferred, Effect, Exit, Layer, Scope, SynchronizedRef } from "effect";
+import { Array, Cause, Clock, Context, Deferred, Effect, Exit, Layer, Schema, Scope, SynchronizedRef } from "effect";
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+var Background = Schema.Struct({
+  id: Schema.String,
+  notificationID: SessionMessage.ID,
+  recovery: Schema.Union([
+    Schema.Struct({
+      kind: Schema.Literal("shell"),
+      sessionID: SessionSchema.ID,
+      shellID: Schema.String,
+      command: Schema.String
+    }),
+    Schema.Struct({
+      kind: Schema.Literal("subagent"),
+      parentSessionID: SessionSchema.ID,
+      childSessionID: SessionSchema.ID,
+      agent: Schema.String,
+      description: Schema.String
+    })
+  ]),
+  status: Schema.Literals(["running", "completed", "error", "cancelled"]),
+  output: Schema.optionalKey(Schema.String),
+  error: Schema.optionalKey(Schema.String)
+});
+var decodeBackground = Schema.decodeUnknownResult(Background);
+var backgroundPrefix = "job.background/";
+
 class Service extends Context.Service()("@opencode/Job") {
 }
 function snapshot(job) {
@@ -43,13 +77,26 @@ function decrementSession(input, sessionID) {
   return next;
 }
 var make = Effect.gen(function* () {
+  const kv = yield* exports_kv.Service;
   const state = {
     jobs: yield* SynchronizedRef.make(new Map),
     scope: yield* Scope.Scope
   };
+  const persistBackground = Effect.fnUntraced(function* (job) {
+    if (!job.recovery || !job.info.notificationID)
+      return;
+    yield* kv.set(`${backgroundPrefix}${job.info.notificationID}`, {
+      id: job.info.id,
+      notificationID: job.info.notificationID,
+      recovery: job.recovery,
+      status: job.info.status,
+      ...job.info.output !== undefined ? { output: job.info.output } : {},
+      ...job.info.error !== undefined ? { error: job.info.error } : {}
+    });
+  });
   const settle = Effect.fnUntraced(function* (id, token, exit) {
     const completed_at = yield* Clock.currentTimeMillis;
-    const result = yield* SynchronizedRef.modify(state.jobs, (jobs) => {
+    const result = yield* SynchronizedRef.modifyEffect(state.jobs, Effect.fnUntraced(function* (jobs) {
       const job = jobs.get(id);
       if (!job)
         return [{}, jobs];
@@ -69,8 +116,10 @@ var make = Effect.gen(function* () {
           ...Exit.isFailure(exit) ? { error: errorText(Cause.squash(exit.cause)) } : {}
         }
       };
+      if (status !== "cancelled")
+        yield* persistBackground(next);
       return [{ info: snapshot(next), done: job.done, scope: job.scope }, new Map(jobs).set(id, next)];
-    });
+    }));
     if (result.info && result.done)
       yield* Deferred.succeed(result.done, result.info).pipe(Effect.ignore);
     if (result.scope) {
@@ -78,12 +127,6 @@ var make = Effect.gen(function* () {
     }
     return result.info;
   });
-  const fork = Effect.fnUntraced(function* (scope, id, token, run) {
-    return yield* run.pipe(Effect.matchCauseEffect({
-      onSuccess: (output) => settle(id, token, Exit.succeed(output)),
-      onFailure: (cause) => settle(id, token, Exit.failCause(cause))
-    }), Effect.asVoid, Effect.forkIn(scope, { startImmediately: true }));
-  });
   const get = Effect.fn("Job.get")(function* (id) {
     const job = (yield* SynchronizedRef.get(state.jobs)).get(id);
     if (!job)
@@ -110,19 +153,21 @@ var make = Effect.gen(function* () {
             title: input.title,
             status: "running",
             started_at,
-            metadata: input.metadata
+            metadata: input.metadata,
+            ...input.notificationID ? { notificationID: input.notificationID } : {}
           },
           done,
           backgrounded,
           scope,
           token,
           blockingSessions: new Map,
-          isBackgrounded: false
+          isBackgrounded: false,
+          recovery: input.recovery
         };
         return [{ info: snapshot(job), scope, token }, new Map(jobs).set(id, job)];
       }));
       if ("scope" in result)
-        yield* fork(result.scope, id, result.token, restore(input.run));
+        yield* restore(input.run).pipe(Effect.exit, Effect.flatMap((exit) => settle(id, result.token, exit)), Effect.asVoid, Effect.forkIn(result.scope, { startImmediately: true }));
       return result.info;
     }));
   });
@@ -177,26 +222,35 @@ var make = Effect.gen(function* () {
       return { type: "backgrounded", info: result.info };
     return yield* Effect.raceFirst(Deferred.await(result.wait.done).pipe(Effect.map((info) => ({ type: "finished", info }))), Deferred.await(result.wait.backgrounded).pipe(Effect.map((info) => ({ type: "backgrounded", info })))).pipe(Effect.ensuring(removeBlock(input)));
   });
+  const markBackground = Effect.fnUntraced(function* (job) {
+    const next = {
+      ...job,
+      isBackgrounded: true,
+      blockingSessions: new Map,
+      info: {
+        ...job.info,
+        ...job.recovery ? { notificationID: job.info.notificationID ?? SessionMessage.ID.create() } : {}
+      }
+    };
+    yield* persistBackground(next);
+    return next;
+  });
   const background = Effect.fn("Job.background")(function* (id) {
-    const result = yield* SynchronizedRef.modify(state.jobs, (jobs) => {
+    const result = yield* SynchronizedRef.modifyEffect(state.jobs, Effect.fnUntraced(function* (jobs) {
       const job = jobs.get(id);
-      if (!job || job.info.status !== "running")
+      if (!job || job.info.status !== "running" && !job.recovery)
         return [{}, jobs];
       if (job.isBackgrounded)
         return [{ info: snapshot(job) }, jobs];
-      const next = {
-        ...job,
-        isBackgrounded: true,
-        blockingSessions: new Map
-      };
+      const next = yield* markBackground(job);
       return [{ info: snapshot(next), backgrounded: job.backgrounded }, new Map(jobs).set(id, next)];
-    });
+    }));
     if (result.info && result.backgrounded)
       yield* Deferred.succeed(result.backgrounded, result.info).pipe(Effect.ignore);
     return result.info;
   });
   const backgroundAll = Effect.fn("Job.backgroundAll")(function* (input) {
-    const result = yield* SynchronizedRef.modify(state.jobs, (jobs) => {
+    const result = yield* SynchronizedRef.modifyEffect(state.jobs, Effect.fnUntraced(function* (jobs) {
       const results = [];
       const next = new Map(jobs);
       for (const [id, job] of jobs) {
@@ -208,22 +262,18 @@ var make = Effect.gen(function* () {
           continue;
         if (!job.blockingSessions.has(input.sessionID))
           continue;
-        const updated = {
-          ...job,
-          isBackgrounded: true,
-          blockingSessions: new Map
-        };
+        const updated = yield* markBackground(job);
         results.push({ info: snapshot(updated), backgrounded: job.backgrounded });
         next.set(id, updated);
       }
       return [results, next];
-    });
-    yield* Effect.forEach(result, (item) => item.info && item.backgrounded ? Deferred.succeed(item.backgrounded, item.info) : Effect.void, { discard: true });
-    return result.flatMap((item) => item.info ? [item.info] : []);
+    }));
+    yield* Effect.forEach(result, (item) => Deferred.succeed(item.backgrounded, item.info), { discard: true });
+    return result.map((item) => item.info);
   });
   const cancel = Effect.fn("Job.cancel")(function* (id) {
     const completed_at = yield* Clock.currentTimeMillis;
-    const result = yield* SynchronizedRef.modify(state.jobs, (jobs) => {
+    const result = yield* SynchronizedRef.modifyEffect(state.jobs, Effect.fnUntraced(function* (jobs) {
       const job = jobs.get(id);
       if (!job)
         return [{}, jobs];
@@ -238,17 +288,39 @@ var make = Effect.gen(function* () {
           completed_at
         }
       };
+      yield* persistBackground(next);
       return [{ info: snapshot(next), done: job.done, scope: job.scope }, new Map(jobs).set(id, next)];
-    });
+    }));
     if (result.info && result.done)
       yield* Deferred.succeed(result.done, result.info).pipe(Effect.ignore);
     if (result.scope)
       yield* Scope.close(result.scope, Exit.void);
     return result.info;
   });
-  return Service.of({ get, start, wait, block, background, backgroundAll, cancel });
+  const pendingBackground = Effect.gen(function* () {
+    const recovered = [];
+    let after;
+    do {
+      const page = yield* kv.scan({ prefix: backgroundPrefix, after });
+      recovered.push(...Array.filterMap(page.entries, (entry) => decodeBackground(entry.value)));
+      after = page.next;
+    } while (after);
+    return recovered;
+  }).pipe(Effect.withSpan("Job.pendingBackground"));
+  const completeBackground = Effect.fn("Job.completeBackground")((notificationID) => kv.remove(`${backgroundPrefix}${notificationID}`));
+  return Service.of({
+    get,
+    start,
+    wait,
+    block,
+    background,
+    backgroundAll,
+    cancel,
+    pendingBackground,
+    completeBackground
+  });
 });
 var layer = Layer.effect(Service, make);
-var node = makeGlobalNode({ service: Service, layer, deps: [] });
+var node = makeGlobalNode({ service: Service, layer, deps: [exports_kv.node] });
 
 export { Service, make, node, exports_job };

package/dist/chunks/{job-c6agw9t5.js → snapshot-mwb02z4x.js}

@@ -1,33 +1,33 @@
 import {
   exports_models
-} from "./job-rbnp2c85.js";
-import {
-  exports_agent
-} from "./job-9mhxn888.js";
-import {
-  exports_app
-} from "./job-50jxp3hw.js";
+} from "./snapshot-rbnp2c85.js";
 import {
   exports_catalog
-} from "./job-83vq7eg1.js";
+} from "./snapshot-vgtdbe2x.js";
 import {
   exports_integration
-} from "./job-vjt1s33f.js";
+} from "./snapshot-74ve57mp.js";
 import {
   exports_credential
-} from "./job-jtsr1kyk.js";
+} from "./snapshot-p62hky5s.js";
 import {
-  exports_model
-} from "./job-r13w8t0w.js";
+  exports_app
+} from "./snapshot-50jxp3hw.js";
 import {
-  exports_bus
-} from "./job-74sy20v2.js";
+  exports_agent
+} from "./snapshot-03r4d3d7.js";
+import {
+  exports_model
+} from "./snapshot-r13w8t0w.js";
 import {
   exports_provider
-} from "./job-krsqcmnj.js";
+} from "./snapshot-krsqcmnj.js";
+import {
+  exports_bus
+} from "./snapshot-prx0wmsc.js";
 import {
   __require
-} from "./job-rvfvac9x.js";
+} from "./snapshot-rvfvac9x.js";
 
 // src/plugin/provider/github-copilot.ts
 import { Effect, Option, Schema, Semaphore, Stream } from "effect";

package/dist/chunks/{job-mxvw03gv.js → snapshot-mxvw03gv.js}

@@ -1,6 +1,6 @@
 import {
   __require
-} from "./job-rvfvac9x.js";
+} from "./snapshot-rvfvac9x.js";
 
 // src/plugin/provider/openai-compatible.ts
 import { Effect } from "effect";