@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-f8jtvgnz.js

@@ -0,0 +1,179 @@
+import {
+  NonNegativeInt2,
+  PositiveInt2,
+  RelativePath2
+} from "./worktree-922hggd3.js";
+import {
+  Service52,
+  node55
+} from "./worktree-pr7ch8ks.js";
+import {
+  RipgrepBinary2
+} from "./worktree-8d7r5vzw.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/ripgrep.ts
+var exports_ripgrep = {};
+__export(exports_ripgrep, {
+  Error: () => Error3,
+  InvalidPatternError: () => InvalidPatternError2,
+  Ripgrep: () => exports_ripgrep,
+  Service: () => Service45,
+  node: () => node48
+});
+import { Context, Effect, Fiber, Layer, Schema, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { Entry, Match } from "@opencode/schema/filesystem";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { collectStream, waitForAbort } from "@opencode/util/process";
+var ERROR_BYTES = 8 * 1024;
+var MAX_SUBMATCHES = 100;
+var RawMatch = Schema.Struct({
+  type: Schema.Literal("match"),
+  data: Schema.Struct({
+    path: Schema.Struct({ text: Schema.String }),
+    lines: Schema.Struct({ text: Schema.String }),
+    line_number: PositiveInt2,
+    absolute_offset: NonNegativeInt2,
+    submatches: Schema.Array(Schema.Struct({
+      match: Schema.Struct({ text: Schema.String }),
+      start: NonNegativeInt2,
+      end: NonNegativeInt2
+    }))
+  })
+});
+var decodeJsonRecord = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
+
+class Error3 extends Schema.TaggedError()("Ripgrep.Error", {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect())
+}) {
+}
+
+class InvalidPatternError2 extends Schema.TaggedError()("Ripgrep.InvalidPatternError", {
+  pattern: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class Service45 extends Context.Service()("@opencode/Ripgrep") {
+}
+var failure = (message, cause) => new Error3({ 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(Service45, Effect.gen(function* () {
+  const environment = yield* Service52;
+  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" }));
+      const stderrFiber = yield* collectStream(handle.stderr, ERROR_BYTES).pipe(Effect.map((output) => output.buffer.toString("utf8")), Effect.forkScoped);
+      let observed = 0;
+      const rows = yield* Stream.decodeText(handle.stdout).pipe(Stream.splitLines, Stream.filter((line) => line.length > 0), Stream.mapEffect(input.parse), Stream.filter((row) => row !== undefined), Stream.tap((row) => {
+        if (!input.onItem || observed++ >= input.limit)
+          return Effect.void;
+        return input.onItem(row);
+      }), Stream.take(input.limit + 1), Stream.runCollect);
+      const truncated = rows.length > input.limit;
+      if (truncated)
+        return rows.slice(0, input.limit);
+      const code = yield* handle.exitCode;
+      const stderr = yield* Fiber.join(stderrFiber);
+      if (input.pattern && code === 2 && isInvalidPattern(stderr)) {
+        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}`);
+      }
+      return code === 1 ? [] : rows;
+    }));
+    const abortable = input.signal ? program.pipe(Effect.raceFirst(waitForAbort(input.signal))) : program;
+    return abortable.pipe(Effect.mapError((cause) => cause instanceof Error3 || cause instanceof InvalidPatternError2 ? cause : failure("ripgrep execution failed", cause)));
+  };
+  return Service45.of({
+    glob: (input) => run({
+      cwd: input.cwd,
+      limit: input.limit,
+      signal: input.signal,
+      args: [
+        "--no-config",
+        "--files",
+        ...input.hidden ? ["--hidden"] : [],
+        ...input.follow ? ["--follow"] : [],
+        `--glob=${input.pattern}`,
+        "--glob=!**/.git/**",
+        "."
+      ],
+      parse: (line) => Effect.succeed(normalizePath(line))
+    }).pipe(Effect.map((result) => result.map((relative) => Entry.make({
+      path: RelativePath2.make(relative),
+      type: "file"
+    }))), Effect.catchTag("Ripgrep.InvalidPatternError", (cause) => Effect.fail(failure(cause.message, cause)))),
+    find: (input) => run({
+      cwd: input.cwd,
+      limit: input.limit,
+      signal: input.signal,
+      args: [
+        "--no-config",
+        "--files",
+        ...input.hidden ? ["--hidden"] : [],
+        ...input.follow ? ["--follow"] : [],
+        ...input.pattern === "*" ? [] : [`--glob=${input.pattern}`],
+        ...(input.exclude ?? []).map((pattern) => `--glob=!${pattern}`),
+        "--glob=!**/.git/**",
+        "."
+      ],
+      parse: (line) => {
+        const relative = normalizePath(line);
+        return Effect.succeed(Entry.make({
+          path: RelativePath2.make(relative),
+          type: "file"
+        }));
+      },
+      onItem: input.onEntry
+    }).pipe(Effect.catchTag("Ripgrep.InvalidPatternError", (cause) => Effect.fail(failure(cause.message, cause)))),
+    grep: (input) => run({
+      ...input,
+      args: [
+        "--no-config",
+        "--json",
+        "--hidden",
+        "--no-messages",
+        ...input.literal ? ["--fixed-strings"] : [],
+        ...input.caseSensitive === false ? ["--ignore-case"] : [],
+        ...input.include ? [`--glob=${input.include}`] : [],
+        "--glob=!**/.git/**",
+        "--",
+        input.pattern,
+        input.file ?? "."
+      ],
+      parse: (line) => decodeJsonRecord(line).pipe(Effect.mapError((cause) => failure("Invalid ripgrep JSON output", cause)), Effect.flatMap((json) => {
+        if (!json || typeof json !== "object" || !("type" in json) || json.type !== "match")
+          return Effect.undefined;
+        return Schema.decodeUnknownEffect(RawMatch)(json).pipe(Effect.map((match) => ({
+          ...match.data,
+          path: { text: normalizePath(match.data.path.text) },
+          submatches: match.data.submatches.slice(0, MAX_SUBMATCHES)
+        })), Effect.mapError((cause) => failure("Invalid ripgrep match output", cause)));
+      }))
+    }).pipe(Effect.map((result) => result.map((match) => Match.make({
+      entry: Entry.make({
+        path: RelativePath2.make(match.path.text),
+        type: "file"
+      }),
+      line: match.line_number,
+      offset: match.absolute_offset,
+      text: match.lines.text.length > 2000 ? match.lines.text.slice(0, 2000) + "..." : match.lines.text,
+      submatches: match.submatches.map((submatch) => ({
+        text: submatch.match.text,
+        start: submatch.start,
+        end: submatch.end
+      }))
+    }))))
+  });
+}));
+var node48 = makeLocationNode({ service: Service45, layer, deps: [node55, RipgrepBinary2.node] });
+
+export { Error3, InvalidPatternError2, Service45, node48, exports_ripgrep };

package/dist/chunks/worktree-fa0cr6zp.js

@@ -0,0 +1,51 @@
+import {
+  ID12,
+  packageName2
+} from "./worktree-9qn3qky1.js";
+
+// src/plugin/provider/amazon-bedrock.ts
+import { Effect } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+var CHAIN_ENV = [
+  "AWS_PROFILE",
+  "AWS_ACCESS_KEY_ID",
+  "AWS_WEB_IDENTITY_TOKEN_FILE",
+  "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI",
+  "AWS_CONTAINER_CREDENTIALS_FULL_URI"
+];
+var isBedrock = (item) => {
+  const name = packageName2(item.package);
+  return name.startsWith("@ai-sdk/amazon-bedrock") || name.startsWith("@opencode/ai/providers/amazon-bedrock");
+};
+var AmazonBedrockPlugin2 = define({
+  id: "opencode.provider.amazon.bedrock",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.integration.transform((editor) => {
+      editor.method.update({
+        integrationID: ID12.amazonBedrock,
+        method: { type: "env", names: ["AWS_BEARER_TOKEN_BEDROCK"] }
+      });
+    });
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (!isBedrock(item.provider))
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          const settings = provider.settings ?? {};
+          const chain = typeof settings.profile === "string" || CHAIN_ENV.some((name) => process.env[name]);
+          if (chain && provider.activation === "auto")
+            provider.activation = "enabled";
+          const region = process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? "us-east-1";
+          provider.settings = {
+            ...settings,
+            ...typeof settings.region !== "string" ? { region } : {},
+            ...typeof settings.baseURL !== "string" && typeof settings.endpoint === "string" ? { baseURL: settings.endpoint } : {}
+          };
+          delete provider.settings.endpoint;
+        });
+      }
+    });
+  })
+});
+
+export { AmazonBedrockPlugin2 };

package/dist/chunks/worktree-faypxj3z.js

@@ -0,0 +1,11 @@
+// src/workspace/sql.ts
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+var WorkspaceTable2 = sqliteTable("workspace", {
+  id: text().$type().primaryKey(),
+  provider: text().notNull(),
+  binding: text({ mode: "json" }).$type(),
+  created_at: integer().notNull(),
+  last_used_at: integer().notNull()
+});
+
+export { WorkspaceTable2 };

package/dist/chunks/worktree-fd410y7t.js

@@ -0,0 +1,13 @@
+// src/database/migration/20260504145000_add_sync_owner.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260504145000_add_sync_owner",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`event_sequence\` ADD \`owner_id\` text;`);
+    });
+  }
+};
+var _20260504145000_add_sync_owner_default = migration;
+
+export { _20260504145000_add_sync_owner_default };

package/dist/chunks/worktree-ffx4mq6v.js

@@ -0,0 +1,32 @@
+import {
+  isAISDK2,
+  packageName2
+} from "./worktree-9qn3qky1.js";
+
+// src/plugin/provider/zenmux.ts
+import { Effect } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+var ZenmuxPlugin2 = define({
+  id: "opencode.provider.zenmux",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (!isAISDK2(item.provider.package))
+          continue;
+        if (packageName2(item.provider.package) !== "@ai-sdk/openai-compatible")
+          continue;
+        if (item.provider.settings?.baseURL !== "https://zenmux.ai/api/v1")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = {
+            "HTTP-Referer": "https://opencode.ai/",
+            "X-Title": "opencode",
+            ...provider.headers
+          };
+        });
+      }
+    });
+  })
+});
+
+export { ZenmuxPlugin2 };

package/dist/chunks/worktree-fjttjfbj.js

@@ -0,0 +1,374 @@
+import {
+  Service80,
+  node85
+} from "./worktree-ecj1wrg9.js";
+import {
+  Service79,
+  node84
+} from "./worktree-vrm5r67w.js";
+import {
+  SessionEvent2
+} from "./worktree-ec1grn59.js";
+import {
+  SessionMessageTable2
+} from "./worktree-5c4hm403.js";
+import {
+  prepare4
+} from "./worktree-gnx4ytbv.js";
+import {
+  llmClient2
+} from "./worktree-5t3nmthw.js";
+import {
+  SessionMessage2
+} from "./worktree-gftt206x.js";
+import {
+  StepFailedError2
+} from "./worktree-k7d0894y.js";
+import {
+  provenance2
+} from "./worktree-w1k39n5e.js";
+import {
+  decodeMessageRow2,
+  preview2
+} from "./worktree-wpdyyhk3.js";
+import {
+  Service72,
+  node77
+} from "./worktree-3bgy0jaw.js";
+import {
+  Service23,
+  node28
+} from "./worktree-nqyaavw9.js";
+import {
+  baseTranscript2
+} from "./worktree-tm64n74p.js";
+import {
+  make6
+} from "./worktree-26tj7vag.js";
+import {
+  Service9,
+  node12
+} from "./worktree-dvh2p5hy.js";
+import {
+  Service19,
+  node24
+} from "./worktree-0k40b2vq.js";
+import {
+  serialized2,
+  nextPromotable2,
+  promote2
+} from "./worktree-vece14gy.js";
+import {
+  Service3,
+  isUntitled2,
+  node4
+} from "./worktree-q18k77y0.js";
+import {
+  DrainResult2,
+  Service33
+} from "./worktree-ca7w653e.js";
+import {
+  node35
+} from "./worktree-mp9h7a8n.js";
+import {
+  node52
+} from "./worktree-qr42g2ex.js";
+import {
+  Outcome2,
+  make3
+} from "./worktree-jgrg7y22.js";
+import {
+  Service27
+} from "./worktree-1x11rq2a.js";
+import {
+  node20
+} from "./worktree-dvgvg99t.js";
+import {
+  MAX_STEPS_PROMPT2
+} from "./worktree-y44na4kk.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/session/runner/llm.ts
+var exports_llm = {};
+__export(exports_llm, {
+  SessionRunnerLLM: () => exports_llm,
+  node: () => node2
+});
+import { Message } from "@opencode/ai";
+import { and, desc, eq, sql } from "drizzle-orm";
+import { Cause, Effect, Exit, FiberMap, Layer } from "effect";
+import { makeLocationNode } from "@opencode/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(Service33, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const store = yield* Service72;
+  const context = yield* Service19;
+  const modelTransport = yield* Service23;
+  const db = (yield* Service80).db;
+  const compaction = yield* Service9;
+  const plugins = yield* Service27;
+  const title = yield* Service3;
+  const steps = yield* make3;
+  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* nextPromotable2(db, sessionID, "input");
+      if (!pending)
+        return DrainResult2.Complete();
+      const control = pending.type === "compaction" || pending.type === "move";
+      if (promotable === "steer" && pending.delivery === "queue" && !control)
+        return DrainResult2.Complete();
+    }
+    yield* plugins.awaitActivation;
+    yield* settleStaleCompactions(sessionID);
+    yield* settleStaleToolCalls(sessionID);
+    const advanceToStep = Effect.fn("SessionRunner.advanceToStep")(() => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+      while (true) {
+        const pending = yield* serialized2(sessionID, Effect.gen(function* () {
+          const next = yield* nextPromotable2(db, sessionID, entering || !continuing ? "input" : "steer");
+          if (next?.type === "compaction")
+            yield* bus.publishAll([
+              [SessionEvent2.InboxDelivered, { sessionID, inboxID: next.id }],
+              [SessionEvent2.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([
+                [SessionEvent2.InboxDelivered, { sessionID, inboxID: next.id }],
+                [SessionEvent2.Moved, { sessionID, ...next.payload }]
+              ]);
+            }));
+          return next;
+        }));
+        if (!continuing && pending?.delivery !== "steer") {
+          entering = true;
+          step = 1;
+        }
+        if (pending?.type === "move")
+          return DrainResult2.Moved({ continuation: 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,
+              resolveContext: (session) => Effect.gen(function* () {
+                const selected = yield* context.select(session.id);
+                const model = yield* context.resolveModel(selected.session);
+                const history = yield* preview2(db, session.id, selected.instructions, provenance2(model) ?? "local");
+                return {
+                  session: selected.session,
+                  agent: selected.agent,
+                  tools: selected.tools,
+                  model,
+                  initial: history.initial,
+                  messages: history.messages,
+                  instructionUpdate: history.instructionUpdate
+                };
+              }),
+              prepare: context.prepare,
+              messages: yield* store.context(sessionID),
+              inputID: pending.id,
+              started: true
+            });
+          })).pipe(Effect.exit);
+          if (Exit.isFailure(compacted)) {
+            yield* bus.publish(SessionEvent2.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 DrainResult2.Complete();
+        const ready = yield* restore(Effect.gen(function* () {
+          const selected = yield* prepareContext(sessionID);
+          const promoted = yield* promote2(db, bus, sessionID, entering && !continuing ? promotable : "steer");
+          if (promoted === undefined)
+            return;
+          if (promoted > 0 && !selected.session.parentID && isUntitled2(selected.session))
+            yield* FiberMap.run(titles, sessionID, title.generate(sessionID), {
+              onlyIfMissing: true
+            });
+          if (promoted > 0)
+            step = 1;
+          return { _tag: "Ready", context: yield* context.load(selected) };
+        }));
+        if (ready)
+          return ready;
+      }
+    })));
+    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* prepare4(db, bus, selected.instructions, sessionID);
+    return selected;
+  });
+  const runStep = Effect.fn("SessionRunner.runStep")(function* (first, step) {
+    const sessionID = first.session.id;
+    let assistantMessageID = SessionMessage2.ID.create();
+    const retry = yield* make6(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 = {
+        context: loaded,
+        prepare: context.prepare
+      };
+      if (compaction.required({ messages: loaded.messages, resolved: loaded.model, context: loaded })) {
+        const result = yield* compaction.compact(compactionInput);
+        if (result.status !== "completed")
+          return yield* new StepFailedError2({ error: result.error });
+        if (result.recoveredOverflow)
+          recoverOverflow = false;
+        assistantMessageID = SessionMessage2.ID.create();
+        continue;
+      }
+      const stepLimitReached = loaded.agent.info.steps !== undefined && step >= loaded.agent.info.steps;
+      const transcript = baseTranscript2({
+        agent: loaded.agent.info,
+        model: loaded.model,
+        tools: loaded.tools,
+        initial: loaded.initial,
+        messages: loaded.messages
+      });
+      const prepared = yield* context.prepare({
+        kind: "primary",
+        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_PROMPT2)] : transcript.messages
+        },
+        toolChoice: stepLimitReached ? "none" : undefined,
+        webSocket: "session"
+      });
+      const outcome = yield* steps.attempt({
+        sessionID,
+        assistantMessageID,
+        agent: loaded.agent.id,
+        model: loaded.model,
+        prepared,
+        retry: (cause, error, proposed) => retry.decide({
+          cause,
+          error,
+          agent: loaded.agent.id,
+          model: loaded.model.ref,
+          hook: prepared.retry,
+          retry: proposed
+        }),
+        recoverContinuation,
+        recoverOverflow: Effect.suspend(() => recoverOverflow && compaction.enabled() ? compaction.compact({ ...compactionInput, overflow: true }).pipe(Effect.map((result) => result.status === "completed")) : Effect.succeed(false))
+      });
+      const completed = yield* Outcome2.$match(outcome, {
+        Completed: (outcome) => Effect.succeed(outcome.needsContinuation),
+        Retry: (outcome) => retry.wait({
+          decision: outcome.decision,
+          error: outcome.error,
+          assistantMessageID
+        }),
+        Continue: Effect.fnUntraced(function* (outcome) {
+          yield* retry.wait({
+            decision: outcome.decision,
+            error: outcome.error,
+            assistantMessageID
+          });
+          yield* bus.publish(SessionEvent2.Synthetic, { sessionID, text: CONTINUE_AFTER_INCOMPLETE_STREAM });
+          assistantMessageID = SessionMessage2.ID.create();
+        }),
+        Compacted: Effect.fnUntraced(function* () {
+          recoverOverflow = false;
+          assistantMessageID = SessionMessage2.ID.create();
+        }),
+        RecoverFull: Effect.fnUntraced(function* () {
+          recoverContinuation = false;
+        })
+      });
+      if (completed !== undefined)
+        return completed;
+    }
+  });
+  const settleStaleCompactions = Effect.fn("SessionRunner.settleStaleCompactions")(function* (sessionID) {
+    const rows = yield* db.select().from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, sessionID), eq(SessionMessageTable2.type, "compaction"), sql`json_extract(${SessionMessageTable2.data}, '$.status') = 'running'`)).orderBy(desc(SessionMessageTable2.seq)).all().pipe(Effect.orDie);
+    for (const row of rows) {
+      const message = yield* decodeMessageRow2(row);
+      if (message.type !== "compaction")
+        continue;
+      yield* bus.publish(SessionEvent2.Compaction.Failed, {
+        sessionID,
+        reason: message.reason,
+        inputID: message.id,
+        error: { type: "compaction.interrupted", message: "Compaction was interrupted" }
+      });
+    }
+  });
+  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(SessionEvent2.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 Service33.of({ drain });
+}));
+var node2 = makeLocationNode({
+  service: Service33,
+  layer,
+  deps: [
+    node84,
+    llmClient2,
+    node24,
+    node28,
+    node77,
+    node12,
+    node20,
+    node4,
+    node35,
+    node52,
+    node85
+  ]
+});
+
+export { node2, exports_llm };

package/dist/chunks/worktree-fm2qvscf.js

@@ -0,0 +1,21 @@
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/v1/config/command.ts
+var exports_command5 = {};
+__export(exports_command5, {
+  ConfigCommandV1: () => exports_command5,
+  Info: () => Info17
+});
+import { Schema } from "effect";
+var Info17 = Schema.Struct({
+  template: Schema.String,
+  description: Schema.optional(Schema.String),
+  agent: Schema.optional(Schema.String),
+  model: Schema.optional(Schema.String),
+  variant: Schema.optional(Schema.String),
+  subtask: Schema.optional(Schema.Boolean)
+});
+
+export { Info17, exports_command5 };