@opencode/core 0.0.0-reserved → 2.0.0

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

@@ -0,0 +1,208 @@
+import {
+  Service79
+} from "./aisdk-native-11nvngjf.js";
+import {
+  Service53
+} from "./aisdk-native-y6jb2tes.js";
+import {
+  Error2
+} from "./aisdk-native-g27wjat6.js";
+import {
+  Service55
+} from "./aisdk-native-9jdakqgh.js";
+import {
+  StepFailedError2
+} from "./aisdk-native-3x8gcmrs.js";
+import {
+  SessionEvent2
+} from "./aisdk-native-ec1grn59.js";
+import {
+  toSessionError2
+} from "./aisdk-native-bp3wckns.js";
+import {
+  calculateCost2
+} from "./aisdk-native-tdstcens.js";
+import {
+  createLLMEventPublisher2
+} from "./aisdk-native-h03wrkyp.js";
+import {
+  isRetryable2
+} from "./aisdk-native-xv61b48b.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/session/runner/step.ts
+var exports_step = {};
+__export(exports_step, {
+  Outcome: () => Outcome2,
+  SessionStep: () => exports_step,
+  make: () => make3
+});
+import {
+  AIError,
+  InvalidProviderOutputError,
+  LLMClient,
+  LLMEvent,
+  isContextOverflowFailure
+} from "@opencode/ai";
+import { Cause, Data, Effect, Exit, Fiber, Option, Stream } from "effect";
+var Outcome2 = Data.taggedEnum();
+var TOOLS_INTERRUPTED = { type: "aborted", message: "Tool execution interrupted" };
+var STEP_INTERRUPTED = { type: "aborted", message: "Step interrupted" };
+var RESULT_MISSING = { type: "tool.result-missing", message: "Provider did not return a tool result" };
+var make3 = Effect.gen(function* () {
+  const bus = yield* Service79;
+  const llm = yield* LLMClient.Service;
+  const snapshots = yield* Service53;
+  const toolOutput = yield* Service55;
+  const attempt = Effect.fn("SessionStep.attempt")(function* (input) {
+    const startSnapshot = yield* snapshots.capture();
+    const publisher = createLLMEventPublisher2(bus, {
+      sessionID: input.sessionID,
+      assistantMessageID: input.assistantMessageID,
+      agent: input.agent,
+      model: input.model.ref,
+      providerMetadataKey: input.model.model.route.providerMetadataKey ?? input.model.model.provider,
+      snapshot: startSnapshot
+    });
+    const toolRuns = [];
+    const interruptTools = Effect.suspend(() => Fiber.interruptAll(toolRuns.map((run) => run.fiber)));
+    const executeTool = (call) => {
+      if (input.prepared.request.toolChoice?.type === "none")
+        return new Error2({ message: "Tools are disabled after the maximum agent steps" });
+      return input.prepared.executeTool({
+        sessionID: input.sessionID,
+        agent: input.agent,
+        messageID: input.assistantMessageID,
+        call,
+        progress: (update) => publisher.progress(call.id, update)
+      });
+    };
+    let overflowFailure;
+    const providerStream = llm.stream(input.prepared.request, input.prepared.options).pipe(Stream.runForEach((event) => Effect.gen(function* () {
+      if (overflowFailure || publisher.hasProviderError())
+        return;
+      if (LLMEvent.is.providerError(event) && isContextOverflowFailure(event) && !publisher.record().outputStarted) {
+        overflowFailure = event;
+        return;
+      }
+      yield* publisher.publish(event);
+      if (event.type !== "tool-call" || event.providerExecuted)
+        return;
+      toolRuns.push({
+        call: event,
+        fiber: yield* Effect.uninterruptibleMask((restore) => restore(executeTool(event)).pipe(Effect.flatMap(toolOutput.truncate), Effect.flatMap((outcome) => publisher.toolExecution(event.id, event.name, outcome)), Effect.catchTag("Tool.Error", (error) => publisher.failTool(event.id, toSessionError2(error), error.metadata).pipe(Effect.asVoid)))).pipe(Effect.forkScoped)
+      });
+    })), Effect.ensuring(publisher.flush()));
+    return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+      const stream = yield* restore(providerStream).pipe(Effect.exit);
+      const streamFailure = Option.getOrUndefined(Exit.findErrorOption(stream));
+      const streamInterrupted = Exit.hasInterrupts(stream);
+      if (!overflowFailure && publisher.hasStarted())
+        yield* publisher.streamed();
+      if (streamInterrupted)
+        yield* interruptTools;
+      const joined = yield* restore(Fiber.awaitAll(toolRuns.map((run) => run.fiber))).pipe(Effect.exit);
+      if (Exit.isFailure(joined))
+        yield* interruptTools;
+      const tools = classifyToolExits(joined, toolRuns);
+      if (!publisher.record().outputStarted && isContextOverflowFailure(overflowFailure ?? streamFailure) && (yield* restore(input.recoverOverflow)))
+        return Outcome2.Compacted();
+      if (overflowFailure)
+        yield* publisher.publish(overflowFailure);
+      const recorded = publisher.record();
+      const unknownFinish = Exit.isSuccess(stream) && recorded.finish?.finish === "unknown" ? new AIError({
+        reason: new InvalidProviderOutputError({
+          message: "The provider response ended with an unknown finish reason.",
+          classification: "incomplete-stream"
+        })
+      }) : undefined;
+      const llmFailure = streamFailure instanceof AIError ? streamFailure : unknownFinish;
+      const llmError = llmFailure && !recorded.providerFailed ? toSessionError2(llmFailure) : undefined;
+      if (input.recoverContinuation && llmFailure?.reason._tag === "Transport" && (llmFailure.reason.recovery === "retry-full" || llmFailure.reason.recovery === "rotate-and-retry-full") && !recorded.outputStarted)
+        return Outcome2.RecoverFull();
+      const retry = llmFailure && llmError && !isContextOverflowFailure(llmFailure) ? yield* restore(input.retry(llmFailure, llmError, isRetryable2(llmFailure) || recorded.outputStarted && isInterruptedStream(llmFailure))) : undefined;
+      if (llmFailure && llmError && retry?.retry && !recorded.outputStarted) {
+        yield* publisher.startAssistant();
+        return Outcome2.Retry({ error: llmError, decision: retry });
+      }
+      if (llmError)
+        yield* publisher.failAssistant(llmError);
+      for (const decline of tools.declines)
+        yield* publisher.failTool(decline.call.id, {
+          type: "aborted",
+          message: decline.reason._tag === "QuestionTool.CancelledError" ? decline.reason.message : "The user declined this tool call"
+        });
+      const interrupted = tools.declines.length > 0 || streamInterrupted || tools.interrupted;
+      const toolFailure = interrupted ? TOOLS_INTERRUPTED : tools.failure !== undefined ? toSessionError2(Cause.squash(tools.failure)) : recorded.providerFailed ? TOOLS_INTERRUPTED : undefined;
+      if (toolFailure)
+        yield* publisher.failUnsettledTools(toolFailure);
+      if (interrupted)
+        yield* publisher.failAssistant(STEP_INTERRUPTED);
+      if (llmError || Exit.isSuccess(stream) && !recorded.providerFailed) {
+        const missing = yield* publisher.failUnsettledTools(RESULT_MISSING, "hosted");
+        if (missing && !llmError && !recorded.finish)
+          yield* publisher.failAssistant(RESULT_MISSING);
+      }
+      const record = publisher.record();
+      if (record.finish || record.failure) {
+        const snapshot = yield* snapshots.capture();
+        const files = startSnapshot && snapshot ? startSnapshot === snapshot ? [] : yield* snapshots.files({ from: startSnapshot, to: snapshot }).pipe(Effect.orElseSucceed(() => {
+          return;
+        })) : undefined;
+        const usage = record.finish ? { cost: calculateCost2(input.model.cost, record.finish.tokens), tokens: record.finish.tokens } : undefined;
+        if (record.failure)
+          yield* publisher.publishStepFailure({ ...usage, snapshot, files });
+        if (record.finish && usage && !record.failure)
+          yield* bus.publish(SessionEvent2.Step.Ended, {
+            sessionID: input.sessionID,
+            assistantMessageID: yield* publisher.startAssistant(),
+            finish: record.finish.finish,
+            rawFinish: record.finish.rawFinish,
+            providerState: record.finish.providerState,
+            ...usage,
+            snapshot,
+            files
+          });
+      }
+      if (llmFailure && llmError && retry?.retry && record.outputStarted && tools.declines.length === 0 && !tools.interrupted)
+        return Outcome2.Continue({ error: llmError, decision: retry });
+      if (Exit.isFailure(stream))
+        return yield* Effect.failCause(stream.cause);
+      if (tools.declines.length > 0)
+        return yield* Effect.interrupt;
+      if (tools.interrupted && tools.failure)
+        return yield* Effect.failCause(tools.failure);
+      if (tools.interrupted && Exit.isFailure(joined))
+        return yield* Effect.failCause(joined.cause);
+      if (record.failure)
+        return yield* new StepFailedError2({ error: record.failure });
+      return Outcome2.Completed({
+        needsContinuation: input.prepared.request.toolChoice?.type !== "none" && record.needsContinuation
+      });
+    }));
+  }, Effect.scoped);
+  return { attempt };
+});
+var isInterruptedStream = (failure) => {
+  if (failure.reason._tag === "InvalidProviderOutput")
+    return failure.reason.classification === "incomplete-stream";
+  if (failure.reason._tag === "Transport")
+    return failure.reason.operation === "read";
+  return false;
+};
+var classifyToolExits = (settled, runs) => {
+  const exits = Exit.isSuccess(settled) ? settled.value : [];
+  const declines = exits.flatMap((exit, index) => Exit.isFailure(exit) ? exit.cause.reasons.flatMap((reason) => Cause.isFailReason(reason) ? [{ call: runs[index].call, reason: reason.error }] : []) : []);
+  const causes = Exit.isFailure(settled) ? [settled.cause] : exits.flatMap((exit) => Exit.isFailure(exit) ? [exit.cause] : []);
+  const failure = causes.flatMap((cause) => {
+    if (Cause.hasInterrupts(cause))
+      return [];
+    const reasons = cause.reasons.filter(Cause.isDieReason);
+    return reasons.length > 0 ? [Cause.fromReasons(reasons)] : [];
+  }).at(0);
+  return { interrupted: causes.some(Cause.hasInterrupts), declines, failure };
+};
+
+export { Outcome2, make3, exports_step };

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

@@ -0,0 +1,25 @@
+// src/database/migration/20260611035744_credential.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260611035744_credential",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`credential\` (
+          \`id\` text PRIMARY KEY,
+          \`connector_id\` text NOT NULL,
+          \`method_id\` text NOT NULL,
+          \`label\` text NOT NULL,
+          \`value\` text NOT NULL,
+          \`active\` integer DEFAULT false NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL
+        );
+      `);
+      yield* tx.run(`CREATE UNIQUE INDEX \`credential_connector_active_idx\` ON \`credential\` (\`connector_id\`) WHERE "credential"."active" = 1;`);
+    });
+  }
+};
+var _20260611035744_credential_default = migration;
+
+export { _20260611035744_credential_default };

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

@@ -0,0 +1,282 @@
+import {
+  AbsolutePath2
+} from "./aisdk-native-922hggd3.js";
+import {
+  Service80,
+  node85
+} from "./aisdk-native-vfccn5yp.js";
+import {
+  Service79,
+  node84
+} from "./aisdk-native-11nvngjf.js";
+import {
+  Service75,
+  node80
+} from "./aisdk-native-7zdm33ac.js";
+import {
+  ID17,
+  Current3,
+  Info32,
+  UpdateInput4,
+  Event20,
+  Vcs3
+} from "./aisdk-native-rsym84ch.js";
+import {
+  ProjectTable2,
+  upsertProject2
+} from "./aisdk-native-8p4f9s12.js";
+import {
+  WorktreeTable2
+} from "./aisdk-native-cfpkc3c9.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/project.ts
+var exports_project = {};
+__export(exports_project, {
+  Current: () => Current2,
+  ID: () => ID16,
+  Info: () => Info31,
+  NotFoundError: () => NotFoundError9,
+  Project: () => exports_project,
+  Service: () => Service74,
+  UpdateInput: () => UpdateInput3,
+  Vcs: () => Vcs2,
+  node: () => node79,
+  root: () => root2
+});
+import { Context, Effect, Layer, Schema } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { and, asc, desc, eq, gte, isNull, lte } from "drizzle-orm";
+import path from "path";
+import { Worktree } from "@opencode/schema/worktree";
+import { FSUtil } from "@opencode/util/fs-util";
+import { AppProcess } from "@opencode/util/process";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { Hash } from "@opencode/util/hash";
+var ID16 = ID17;
+var Vcs2 = Vcs3;
+var Current2 = Current3;
+var Info31 = Info32;
+var UpdateInput3 = UpdateInput4;
+
+class NotFoundError9 extends Schema.TaggedError()("Project.NotFoundError", {
+  projectID: ID16
+}) {
+}
+var root2 = Effect.fn("Project.root")(function* (fs, input, markers = [".git", ".hg"]) {
+  return yield* fs.up({ targets: [...markers], start: input, mode: "first" }).pipe(Effect.map((matches) => matches[0] ? AbsolutePath2.make(path.dirname(matches[0])) : undefined), Effect.orElseSucceed(() => {
+    return;
+  }));
+});
+
+class Service74 extends Context.Service()("@opencode/Project") {
+}
+function fromRow(row) {
+  const icon = row.icon_url || row.icon_url_override || row.icon_color ? {
+    url: row.icon_url ?? undefined,
+    override: row.icon_url_override ?? undefined,
+    color: row.icon_color ?? undefined
+  } : undefined;
+  return {
+    id: row.id,
+    canonical: row.worktree,
+    vcs: row.vcs ?? undefined,
+    name: row.name ?? undefined,
+    icon,
+    commands: row.commands ?? undefined,
+    time: {
+      created: row.time_created,
+      updated: row.time_updated,
+      initialized: row.time_initialized ?? undefined
+    },
+    sandboxes: row.sandboxes
+  };
+}
+var layer = Layer.effect(Service74, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const git = yield* Service75;
+  const proc = yield* AppProcess.Service;
+  const bus = yield* Service79;
+  const db = (yield* Service80).db;
+  const announcing = new Set;
+  const persist = Effect.fnUntraced(function* (project) {
+    const previous = yield* db.select({ canonical: ProjectTable2.worktree }).from(ProjectTable2).where(eq(ProjectTable2.id, project.id)).get().pipe(Effect.orDie);
+    yield* upsertProject2(db, project).pipe(Effect.orDie);
+    if (previous && previous.canonical !== project.canonical && !(yield* fs.exists(previous.canonical).pipe(Effect.orElseSucceed(() => true)))) {
+      const row = yield* db.update(ProjectTable2).set({ worktree: project.canonical }).where(eq(ProjectTable2.id, project.id)).returning().get().pipe(Effect.orDie);
+      if (row)
+        yield* bus.publish(Event20.Updated, fromRow(row));
+    }
+    if (!project.vcs)
+      return project;
+    const directories = [
+      { projectID: project.id, directory: project.canonical }
+    ];
+    if (project.directory !== project.canonical)
+      directories.push({
+        projectID: project.id,
+        directory: project.directory,
+        strategy: project.vcs.type === "git" ? "git" : undefined
+      });
+    for (const item of directories) {
+      const key = item.projectID + "\x00" + item.directory;
+      if (announcing.has(key))
+        continue;
+      announcing.add(key);
+      yield* Effect.gen(function* () {
+        const stored = yield* db.select({ directory: WorktreeTable2.directory }).from(WorktreeTable2).where(and(eq(WorktreeTable2.project_id, item.projectID), eq(WorktreeTable2.directory, item.directory))).get().pipe(Effect.orDie);
+        if (stored)
+          return;
+        const directory = AbsolutePath2.make(yield* fs.resolve(item.directory));
+        const markerless = yield* db.select({ id: ProjectTable2.id, directory: ProjectTable2.worktree }).from(ProjectTable2).where(and(isNull(ProjectTable2.vcs), gte(ProjectTable2.worktree, directory), lte(ProjectTable2.worktree, AbsolutePath2.make(directory + "￿")))).all().pipe(Effect.orDie);
+        const adopted = yield* Effect.filter(markerless, (candidate) => Effect.gen(function* () {
+          if (candidate.id === item.projectID)
+            return false;
+          if (!FSUtil.contains(directory, candidate.directory))
+            return false;
+          const found = yield* fs.up({ targets: [".git", ".hg"], start: candidate.directory, stop: directory, mode: "first" }).pipe(Effect.orElseSucceed(() => []));
+          if (!found[0])
+            return false;
+          return (yield* fs.resolve(path.dirname(found[0]))) === directory;
+        }));
+        yield* bus.publish(Worktree.Event.Resolved, {
+          projectID: item.projectID,
+          directory: item.directory,
+          previous: project.previous ?? ID16.global,
+          ...adopted.length ? { adopted: adopted.map((candidate) => candidate.id) } : {}
+        }, {
+          commit: () => db.insert(WorktreeTable2).values({ project_id: item.projectID, directory: item.directory, strategy: item.strategy }).onConflictDoNothing().run().pipe(Effect.orDie, Effect.asVoid)
+        });
+      }).pipe(Effect.ensuring(Effect.sync(() => announcing.delete(key))));
+    }
+    return project;
+  });
+  const list = Effect.fn("Project.list")(function* () {
+    const rows = yield* db.select().from(ProjectTable2).orderBy(desc(ProjectTable2.time_updated), asc(ProjectTable2.id)).all().pipe(Effect.orDie);
+    return rows.map(fromRow);
+  });
+  const update = Effect.fn("Project.update")(function* (input) {
+    const row = yield* db.update(ProjectTable2).set({
+      worktree: input.canonical,
+      name: input.name === undefined ? undefined : input.name || null,
+      icon_url_override: input.icon?.override === undefined ? undefined : input.icon.override || null,
+      icon_color: input.icon?.color === undefined ? undefined : input.icon.color || null,
+      commands: input.commands?.start === undefined ? undefined : input.commands.start ? { start: input.commands.start } : null,
+      time_updated: Date.now()
+    }).where(eq(ProjectTable2.id, input.projectID)).returning().get().pipe(Effect.orDie);
+    if (!row)
+      return yield* new NotFoundError9({ projectID: input.projectID });
+    const project = fromRow(row);
+    yield* bus.publish(Event20.Updated, project);
+    return project;
+  });
+  const cached = Effect.fnUntraced(function* (dir) {
+    return yield* fs.readFileString(path.join(dir, "opencode")).pipe(Effect.map((value) => value.trim()), Effect.map((value) => value ? ID16.make(value) : undefined), Effect.orElseSucceed(() => {
+      return;
+    }));
+  });
+  const remote = Effect.fnUntraced(function* (repo) {
+    const origin = yield* git.remote.get(repo);
+    if (!origin)
+      return;
+    const normalized = url(origin);
+    if (!normalized)
+      return;
+    return ID16.make(Hash.fast(`git-remote:${normalized}`));
+  });
+  function url(input) {
+    const value = input.trim();
+    if (!value)
+      return;
+    const parsed = URL.parse(value);
+    if (parsed) {
+      if (parsed.protocol === "file:")
+        return;
+      return parts(parsed.hostname, parsed.pathname);
+    }
+    const scp = value.match(/^([^@/:]+@)?([^/:]+):(.+)$/);
+    if (scp)
+      return parts(scp[2], scp[3]);
+    return;
+  }
+  function parts(host, name) {
+    const pathname = name.replace(/^\/+/, "").replace(/\.git\/?$/, "").replace(/\/+$/, "");
+    if (!host || !pathname)
+      return;
+    return `${host.toLowerCase()}/${pathname}`;
+  }
+  const rootCommit = Effect.fnUntraced(function* (repo) {
+    const root = (yield* git.history.rootCommits(repo))[0];
+    return root ? ID16.make(root) : undefined;
+  });
+  const hgRoot = Effect.fnUntraced(function* (worktree) {
+    const result = yield* proc.run(ChildProcess.make("hg", ["log", "-r", "roots(all())", "-T", `{node}
+`], {
+      cwd: worktree,
+      env: { HGPLAIN: "1" },
+      extendEnv: true,
+      stdin: "ignore"
+    })).pipe(Effect.orElseSucceed(() => {
+      return;
+    }));
+    if (!result || result.exitCode !== 0)
+      return;
+    const node = result.stdout.toString("utf8").split(`
+`).map((item) => item.trim()).filter(Boolean).toSorted()[0];
+    return node ? ID16.make(node) : undefined;
+  });
+  const hgDiscover = Effect.fnUntraced(function* (dotHg) {
+    const worktree = AbsolutePath2.make(path.dirname(dotHg));
+    const store = AbsolutePath2.make(dotHg);
+    const previous = yield* cached(store);
+    const id = previous ?? (yield* hgRoot(worktree));
+    return {
+      previous,
+      id: id ?? ID16.global,
+      directory: worktree,
+      vcs: { type: "hg", store }
+    };
+  });
+  const resolve = Effect.fn("Project.resolve")(function* (input, _options) {
+    const directory = AbsolutePath2.make(yield* fs.resolve(input));
+    const native = yield* fs.up({ targets: [".git", ".hg"], start: directory, mode: "first" }).pipe(Effect.map((matches) => matches[0]), Effect.orElseSucceed(() => {
+      return;
+    }));
+    const repo = native && path.basename(native) === ".git" ? yield* git.repo.discover(AbsolutePath2.make(path.dirname(native))) : undefined;
+    if (repo) {
+      const previous = yield* cached(repo.commonDirectory);
+      const id = (yield* remote(repo)) ?? previous ?? (yield* rootCommit(repo));
+      const canonical = repo.gitDirectory === repo.commonDirectory ? repo.worktree : yield* git.worktree.list(repo).pipe(Effect.map((items) => items.find((item) => item.kind === "main")?.directory ?? repo.worktree), Effect.orElseSucceed(() => repo.worktree));
+      return yield* persist({
+        previous,
+        id: id ?? ID16.global,
+        directory: repo.worktree,
+        canonical,
+        vcs: { type: "git", store: repo.commonDirectory }
+      });
+    }
+    const hg = native && path.basename(native) === ".hg" ? yield* hgDiscover(AbsolutePath2.make(native)) : undefined;
+    if (hg) {
+      return yield* persist({
+        ...hg,
+        canonical: hg.directory
+      });
+    }
+    return yield* persist({
+      id: ID16.make(Hash.fast(`directory:${directory}`)),
+      directory,
+      canonical: directory,
+      vcs: undefined
+    });
+  });
+  return Service74.of({ list, update, resolve });
+}));
+var node79 = makeGlobalNode({
+  service: Service74,
+  layer,
+  deps: [node84, node85, FSUtil.node, node80, AppProcess.node]
+});
+
+export { ID16, Vcs2, Current2, Info31, UpdateInput3, NotFoundError9, root2, Service74, node79, exports_project };

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

@@ -0,0 +1,17 @@
+// src/plugin/provider/factory.ts
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect } from "effect";
+function createProviderPlugin2(input) {
+  return define({
+    id: input.id,
+    effect: Effect.fn(function* (ctx) {
+      yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+        if (evt.package !== input.package)
+          return;
+        evt.sdk = yield* Effect.promise(() => input.load(evt.options));
+      }));
+    })
+  });
+}
+
+export { createProviderPlugin2 };

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

@@ -0,0 +1,145 @@
+import {
+  Service80,
+  node85
+} from "./aisdk-native-vfccn5yp.js";
+import {
+  Service79,
+  node84
+} from "./aisdk-native-11nvngjf.js";
+import {
+  Service46,
+  node49
+} from "./aisdk-native-n09f2zd2.js";
+import {
+  Service42,
+  node45
+} from "./aisdk-native-81rrwt6s.js";
+import {
+  SessionEvent2
+} from "./aisdk-native-ec1grn59.js";
+import {
+  make16
+} from "./aisdk-native-yp2x3t23.js";
+import {
+  DrainResult2,
+  Service39
+} from "./aisdk-native-06x8he3q.js";
+import {
+  UserInterruptedError2
+} from "./aisdk-native-3x8gcmrs.js";
+import {
+  Service61,
+  node65
+} from "./aisdk-native-smbad60v.js";
+import {
+  toSessionError2
+} from "./aisdk-native-bp3wckns.js";
+import {
+  nextPromotable2
+} from "./aisdk-native-0fm13a2s.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/session/execution.ts
+var exports_execution = {};
+__export(exports_execution, {
+  Service: () => Service38,
+  SessionExecution: () => exports_execution,
+  layer: () => layer17,
+  node: () => node42,
+  noopLayer: () => noopLayer2,
+  terminal: () => terminal2
+});
+import { Cause, Context, Effect, Exit, Layer } from "effect";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+class Service38 extends Context.Service()("@opencode/SessionExecution") {
+}
+function terminal2(exit, reason) {
+  if (Exit.isSuccess(exit))
+    return { type: "succeeded" };
+  if (Cause.hasInterrupts(exit.cause))
+    return { type: "interrupted", reason: reason ?? "shutdown" };
+  const failure = Cause.squash(exit.cause);
+  if (failure instanceof UserInterruptedError2)
+    return { type: "interrupted", reason: "user" };
+  return { type: "failed", error: toSessionError2(failure) };
+}
+var layer17 = Layer.effect(Service38, Effect.gen(function* () {
+  const store = yield* Service61;
+  const instances = yield* Service42;
+  const bus = yield* Service79;
+  const jobs = yield* Service46;
+  const db = (yield* Service80).db;
+  const reportLifecycle = (sessionID, effect) => effect.pipe(Effect.tapCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.logError("Failed to publish Session execution lifecycle", cause).pipe(Effect.annotateLogs({ sessionID }))), Effect.asVoid);
+  const claimOnCommit = (sessionID) => ({
+    commit: () => store.claim(sessionID)
+  });
+  const releaseOnCommit = (sessionID) => ({
+    commit: () => store.release(sessionID)
+  });
+  const drain = Effect.fnUntraced(function* (sessionID, force, continuation, promotable = "input") {
+    const session = yield* store.get(sessionID);
+    if (!session)
+      return yield* Effect.die(new Error(`Session not found: ${sessionID}`));
+    const result = yield* Service39.use((runner) => runner.drain({ sessionID, force, continuation, promotable })).pipe(instances.provide(session), Effect.tapCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.logError("Failed to drain Session", cause).pipe(Effect.annotateLogs({ sessionID }))));
+    return yield* DrainResult2.$match(result, {
+      Complete: () => Effect.void,
+      Moved: (result) => drain(sessionID, false, result.continuation, promotable)
+    });
+  });
+  const coordinator = yield* make16({
+    started: (sessionID) => reportLifecycle(sessionID, bus.publish(SessionEvent2.Execution.Started, { sessionID }, claimOnCommit(sessionID))),
+    drain: (sessionID, force, promotable) => drain(sessionID, force, undefined, promotable),
+    settled: (sessionID, exit, reason) => reportLifecycle(sessionID, Effect.gen(function* () {
+      const outcome = terminal2(exit, reason);
+      if (outcome.type === "succeeded") {
+        yield* bus.publish(SessionEvent2.Execution.Succeeded, { sessionID }, releaseOnCommit(sessionID));
+        return;
+      }
+      if (outcome.type === "interrupted") {
+        if (outcome.reason !== "shutdown")
+          yield* jobs.cancel(sessionID);
+        yield* bus.publish(SessionEvent2.Execution.Interrupted, { sessionID, reason: outcome.reason }, outcome.reason === "shutdown" ? undefined : releaseOnCommit(sessionID));
+        return;
+      }
+      yield* bus.publish(SessionEvent2.Execution.Failed, {
+        sessionID,
+        error: outcome.error
+      }, releaseOnCommit(sessionID));
+    }))
+  });
+  return Service38.of({
+    active: coordinator.active,
+    isActive: coordinator.isActive,
+    interrupt: (sessionID, options) => Effect.gen(function* () {
+      const interrupted = yield* coordinator.interrupt(sessionID, options?.reason ?? "user", options);
+      if (!options?.continue)
+        return interrupted;
+      const next = yield* nextPromotable2(db, sessionID, "input");
+      if (next === undefined)
+        return interrupted;
+      if (next.delivery === "steer" || next.type === "compaction" || next.type === "move")
+        yield* coordinator.wake(sessionID, "steer");
+      return interrupted;
+    }),
+    resume: coordinator.run,
+    wake: coordinator.wake,
+    awaitIdle: coordinator.awaitIdle
+  });
+}));
+var node42 = makeGlobalNode({
+  service: Service38,
+  layer: layer17,
+  deps: [node65, node45, node84, node85, node49]
+});
+var noopLayer2 = Layer.succeed(Service38, Service38.of({
+  active: Effect.succeed(new Set),
+  isActive: () => Effect.succeed(false),
+  resume: () => Effect.void,
+  wake: () => Effect.void,
+  interrupt: () => Effect.succeed(false),
+  awaitIdle: () => Effect.void
+}));
+
+export { Service38, terminal2, layer17, node42, noopLayer2, exports_execution };