@opencode/core 0.0.0-reserved → 2.0.0

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

@@ -0,0 +1,105 @@
+import {
+  Key3,
+  removed2,
+  empty3,
+  make20,
+  diffByKey2
+} from "./aisdk-native-rhjbct0v.js";
+import {
+  evaluate2
+} from "./aisdk-native-h05a6ep0.js";
+import {
+  Service31,
+  node35
+} from "./aisdk-native-es98n7aa.js";
+import {
+  namespace2,
+  name13
+} from "./aisdk-native-hzekcpqj.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/mcp/instructions.ts
+var exports_instructions4 = {};
+__export(exports_instructions4, {
+  McpInstructions: () => exports_instructions4,
+  Service: () => Service28,
+  layer: () => layer11,
+  node: () => node32
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+var Summary = Schema.Struct({
+  server: Schema.String,
+  instructions: Schema.String,
+  codemode: Schema.optionalKey(Schema.Literal(false))
+});
+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(namespace2(server.server))}]\`.`);
+  result.push(...server.instructions.split(`
+`).map((line) => `    ${line}`), "  </server>");
+  return result;
+});
+var render = (servers) => ["<mcp_instructions>", ...entries(servers), "</mcp_instructions>"].join(`
+`);
+var update = (previous, current) => {
+  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.",
+      render(current)
+    ].join(`
+`);
+  return [
+    ...diff.added.length === 0 ? [] : ["New MCP server instructions are available in addition to those previously listed:", ...entries(diff.added)],
+    ...diff.removed.length === 0 ? [] : [
+      `Instructions for the following MCP servers are no longer available: ${diff.removed.map((server) => server.server).join(", ")}.`
+    ]
+  ].join(`
+`);
+};
+
+class Service28 extends Context.Service()("@opencode/McpInstructions") {
+}
+var layer11 = Layer.effect(Service28, Effect.gen(function* () {
+  const mcp = yield* Service31;
+  return Service28.of({
+    load: Effect.fn("McpInstructions.load")(function* (selection) {
+      const agent = selection.info;
+      if (!agent)
+        return empty3;
+      const source = (value) => make20({
+        key: Key3.make("core/mcp-guidance"),
+        codec: Schema.toCodecJson(Schema.Array(Summary)),
+        read: Effect.succeed(value),
+        render: {
+          initial: render,
+          changed: update,
+          removed: () => "MCP server instructions are no longer available."
+        }
+      });
+      const [instructions, tools] = yield* Effect.all([mcp.instructions(), mcp.tools()], {
+        concurrency: "unbounded"
+      });
+      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) => 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 ? removed2 : visible);
+    })
+  });
+}));
+var node32 = makeLocationNode({ service: Service28, layer: layer11, deps: [node35] });
+
+export { Service28, layer11, node32, exports_instructions4 };

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

@@ -0,0 +1,463 @@
+import {
+  Service80,
+  node85
+} from "./aisdk-native-vfccn5yp.js";
+import {
+  reserveSequence2,
+  Service79,
+  node84
+} from "./aisdk-native-11nvngjf.js";
+import {
+  SessionEvent2
+} from "./aisdk-native-ec1grn59.js";
+import {
+  SessionMessage2
+} from "./aisdk-native-gftt206x.js";
+import {
+  update2
+} from "./aisdk-native-4y66k410.js";
+import {
+  AbsolutePath2,
+  RelativePath2
+} from "./aisdk-native-922hggd3.js";
+import {
+  ProjectTable2
+} from "./aisdk-native-8p4f9s12.js";
+import {
+  SessionTable2,
+  SessionMessageTable2,
+  SessionInboxTable2
+} from "./aisdk-native-a1bz86dw.js";
+import {
+  projectAdmitted2,
+  projectDelivered2,
+  projectCancelled2,
+  projectDeliveryChanged2
+} from "./aisdk-native-0fm13a2s.js";
+import {
+  apply2,
+  initialize3,
+  advanceEpoch2,
+  reset2
+} from "./aisdk-native-cq37gk0t.js";
+import {
+  initialize2
+} from "./aisdk-native-3175eqdp.js";
+import {
+  Slug2
+} from "./aisdk-native-gebd4c9n.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/session/projector.ts
+var exports_projector = {};
+__export(exports_projector, {
+  SessionAlreadyProjected: () => SessionAlreadyProjected2,
+  SessionProjector: () => exports_projector,
+  node: () => node25
+});
+import { and, asc, desc, eq, gt, gte, inArray, isNull, lt, lte, or, sql } from "drizzle-orm";
+import { DateTime, Effect, Layer, Schema, Stream } from "effect";
+import path from "path";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { Agent } from "@opencode/schema/agent";
+import { Model } from "@opencode/schema/model";
+import { Workspace } from "@opencode/schema/workspace";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Money } from "@opencode/schema/money";
+import { Worktree } from "@opencode/schema/worktree";
+import { Project } from "@opencode/schema/project";
+var decodeMessage = Schema.decodeUnknownSync(SessionMessage2.Info);
+var encodeMessage = Schema.encodeSync(SessionMessage2.Info);
+
+class SessionAlreadyProjected2 extends Error {
+}
+var ForkBatchSize = 500;
+var forkTitle = (value) => {
+  if (value === undefined)
+    return;
+  const match = value.match(/^(.+) \(fork #(\d+)\)$/);
+  if (match)
+    return `${match[1]} (fork #${Number.parseInt(match[2], 10) + 1})`;
+  return `${value} (fork #1)`;
+};
+function applyUsage(db, sessionID, value) {
+  return db.update(SessionTable2).set({
+    cost: sql`${SessionTable2.cost} + ${value.cost}`,
+    tokens_input: sql`${SessionTable2.tokens_input} + ${value.tokens.input}`,
+    tokens_output: sql`${SessionTable2.tokens_output} + ${value.tokens.output}`,
+    tokens_reasoning: sql`${SessionTable2.tokens_reasoning} + ${value.tokens.reasoning}`,
+    tokens_cache_read: sql`${SessionTable2.tokens_cache_read} + ${value.tokens.cache.read}`,
+    tokens_cache_write: sql`${SessionTable2.tokens_cache_write} + ${value.tokens.cache.write}`,
+    time_updated: sql`${SessionTable2.time_updated}`
+  }).where(eq(SessionTable2.id, sessionID)).run().pipe(Effect.orDie);
+}
+var publishSessionUsage = Effect.fn("SessionProjector.publishUsage")(function* (db, bus, sessionID) {
+  const row = yield* db.select({
+    cost: SessionTable2.cost,
+    input: SessionTable2.tokens_input,
+    output: SessionTable2.tokens_output,
+    reasoning: SessionTable2.tokens_reasoning,
+    cacheRead: SessionTable2.tokens_cache_read,
+    cacheWrite: SessionTable2.tokens_cache_write
+  }).from(SessionTable2).where(eq(SessionTable2.id, sessionID)).get().pipe(Effect.orDie);
+  if (!row)
+    return;
+  yield* bus.publish(SessionEvent2.UsageUpdated, {
+    sessionID,
+    cost: Money.USD.make(row.cost),
+    tokens: {
+      input: row.input,
+      output: row.output,
+      reasoning: row.reasoning,
+      cache: { read: row.cacheRead, write: row.cacheWrite }
+    }
+  });
+});
+var projectFork = Effect.fn("SessionProjector.projectFork")(function* (db, event) {
+  const parent = yield* db.select().from(SessionTable2).where(eq(SessionTable2.id, event.data.parentID)).get().pipe(Effect.orDie);
+  if (!parent)
+    return yield* Effect.die(new Error(`Fork parent session not found: ${event.data.parentID}`));
+  const boundary = yield* db.select({ seq: SessionMessageTable2.seq }).from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, event.data.parentID), eq(SessionMessageTable2.id, event.data.boundary.messageID))).get().pipe(Effect.orDie);
+  if (!boundary)
+    return yield* Effect.die(new Error(`Fork boundary message not found: ${event.data.boundary.messageID}`));
+  const copied = yield* db.select({ seq: SessionMessageTable2.seq }).from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, event.data.parentID), event.data.boundary.type === "before" ? lt(SessionMessageTable2.seq, boundary.seq) : lte(SessionMessageTable2.seq, boundary.seq))).orderBy(desc(SessionMessageTable2.seq)).limit(1).get().pipe(Effect.orDie);
+  const copiedSeq = copied?.seq;
+  const stored = yield* db.insert(SessionTable2).values({
+    id: event.data.sessionID,
+    parent_id: null,
+    fork_session_id: event.data.parentID,
+    fork_boundary: event.data.boundary,
+    project_id: parent.project_id,
+    workspace_id: parent.workspace_id,
+    slug: Slug2.create(),
+    directory: parent.directory,
+    path: parent.path,
+    title: forkTitle(parent.title ?? undefined),
+    agent: parent.agent,
+    model: parent.model,
+    metadata: parent.metadata,
+    permission: parent.permission,
+    version: parent.version,
+    cost: 0,
+    tokens_input: 0,
+    tokens_output: 0,
+    tokens_reasoning: 0,
+    tokens_cache_read: 0,
+    tokens_cache_write: 0,
+    time_created: event.created,
+    time_updated: event.created
+  }).onConflictDoNothing().returning({ sessionID: SessionTable2.id }).get().pipe(Effect.orDie);
+  if (!stored)
+    return yield* Effect.die(new SessionAlreadyProjected2);
+  if (event.data.instructionEntries)
+    yield* initialize2(db, event.data.sessionID, event.data.instructionEntries, event.created);
+  let cursor = -1;
+  while (copiedSeq !== undefined) {
+    const rows = yield* db.select().from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, event.data.parentID), gt(SessionMessageTable2.seq, cursor), lt(SessionMessageTable2.seq, copiedSeq + 1), sql`${SessionMessageTable2.type} != 'assistant' or json_extract(${SessionMessageTable2.data}, '$.time.completed') is not null`, sql`${SessionMessageTable2.type} != 'shell' or json_extract(${SessionMessageTable2.data}, '$.status') != 'running'`, sql`${SessionMessageTable2.type} != 'compaction' or json_extract(${SessionMessageTable2.data}, '$.status') != 'running'`)).orderBy(asc(SessionMessageTable2.seq)).limit(ForkBatchSize).all().pipe(Effect.orDie);
+    if (rows.length === 0)
+      break;
+    yield* db.insert(SessionMessageTable2).values(rows.map((row) => ({
+      id: SessionMessage2.ID.make(`${SessionMessage2.ID.fromEvent(event.id)}_${row.seq}`),
+      session_id: event.data.sessionID,
+      type: row.type,
+      seq: row.seq,
+      time_created: row.time_created,
+      time_updated: row.time_updated,
+      data: row.data
+    }))).run().pipe(Effect.orDie);
+    cursor = rows.at(-1).seq;
+  }
+  if (copiedSeq !== undefined)
+    yield* reserveSequence2(db, event.data.sessionID, copiedSeq);
+  if (event.data.instructions)
+    yield* initialize3(db, event.data.sessionID, event.durable.seq, event.data.instructions);
+});
+function run(db, event) {
+  return Effect.gen(function* () {
+    const decodeRow = (row) => decodeMessage({ ...row.data, id: row.id, type: row.type });
+    const updateMessage = (message) => {
+      const encoded = encodeMessage(message);
+      const { id, type, ...data } = encoded;
+      return db.update(SessionMessageTable2).set({ type, time_created: DateTime.toEpochMillis(message.time.created), data }).where(and(eq(SessionMessageTable2.id, SessionMessage2.ID.make(id)), eq(SessionMessageTable2.session_id, event.data.sessionID))).run().pipe(Effect.orDie);
+    };
+    const appendMessage = (message) => insertMessage(db, event, message);
+    const adapter = {
+      getAgent() {
+        return db.select({ agent: SessionTable2.agent }).from(SessionTable2).where(eq(SessionTable2.id, event.data.sessionID)).get().pipe(Effect.orDie, Effect.map((row) => row?.agent ? Agent.ID.make(row.agent) : undefined));
+      },
+      getModel() {
+        return db.select({ model: SessionTable2.model }).from(SessionTable2).where(eq(SessionTable2.id, event.data.sessionID)).get().pipe(Effect.orDie, Effect.map((row) => row?.model ? Schema.decodeUnknownSync(Model.Ref)(row.model) : undefined));
+      },
+      getLocation() {
+        return db.select({
+          directory: SessionTable2.directory,
+          workspaceID: SessionTable2.workspace_id,
+          projectID: SessionTable2.project_id,
+          subpath: SessionTable2.path
+        }).from(SessionTable2).where(eq(SessionTable2.id, event.data.sessionID)).get().pipe(Effect.orDie, Effect.map((row) => row ? {
+          location: {
+            directory: AbsolutePath2.make(row.directory),
+            workspaceID: row.workspaceID ? Workspace.ID.make(row.workspaceID) : undefined
+          },
+          projectID: row.projectID,
+          subpath: row.subpath === null ? undefined : RelativePath2.make(row.subpath)
+        } : undefined));
+      },
+      getCurrentAssistant() {
+        return Effect.gen(function* () {
+          const row = yield* db.select().from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, event.data.sessionID), eq(SessionMessageTable2.type, "assistant"))).orderBy(desc(SessionMessageTable2.seq)).limit(1).get().pipe(Effect.orDie);
+          if (!row)
+            return;
+          const message = decodeRow(row);
+          return message.type === "assistant" && !message.time.completed ? message : undefined;
+        });
+      },
+      getAssistant(messageID) {
+        return Effect.gen(function* () {
+          const row = yield* db.select().from(SessionMessageTable2).where(and(eq(SessionMessageTable2.id, messageID), eq(SessionMessageTable2.session_id, event.data.sessionID), eq(SessionMessageTable2.type, "assistant"))).get().pipe(Effect.orDie);
+          if (!row)
+            return;
+          const message = decodeRow(row);
+          return message.type === "assistant" ? message : undefined;
+        });
+      },
+      getShell(shellID) {
+        return Effect.gen(function* () {
+          const row = yield* db.select().from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, event.data.sessionID), eq(SessionMessageTable2.type, "shell"), sql`json_extract(${SessionMessageTable2.data}, '$.shellID') = ${shellID}`)).orderBy(desc(SessionMessageTable2.seq)).limit(1).get().pipe(Effect.orDie);
+          if (!row)
+            return;
+          const message = decodeRow(row);
+          return message.type === "shell" ? message : undefined;
+        });
+      },
+      getCompaction() {
+        return Effect.gen(function* () {
+          const row = yield* db.select().from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, event.data.sessionID), eq(SessionMessageTable2.type, "compaction"), sql`json_extract(${SessionMessageTable2.data}, '$.status') = 'running'`)).orderBy(desc(SessionMessageTable2.seq)).limit(1).get().pipe(Effect.orDie);
+          if (!row)
+            return;
+          const message = decodeRow(row);
+          return message.type === "compaction" ? message : undefined;
+        });
+      },
+      updateAssistant: updateMessage,
+      updateShell: updateMessage,
+      updateCompaction: updateMessage,
+      appendMessage
+    };
+    yield* update2(adapter, event);
+  });
+}
+function insertMessage(db, event, message) {
+  const encoded = encodeMessage(message);
+  const { id, type, ...data } = encoded;
+  return db.insert(SessionMessageTable2).values({
+    id: SessionMessage2.ID.make(id),
+    session_id: event.data.sessionID,
+    type,
+    seq: event.durable.seq,
+    time_created: DateTime.toEpochMillis(message.time.created),
+    data
+  }).run().pipe(Effect.orDie);
+}
+function projectIdle(db, event) {
+  return Effect.gen(function* () {
+    yield* run(db, event);
+    if (event.type === SessionEvent2.Execution.Interrupted.type && event.data.reason === "shutdown")
+      return;
+    const time = event.created;
+    const outcome = event.type === SessionEvent2.Execution.Succeeded.type ? "succeeded" : event.type === SessionEvent2.Execution.Failed.type ? "failed" : "interrupted";
+    yield* db.update(SessionTable2).set({
+      time_idle: sql`max(${time}, coalesce(${SessionTable2.time_idle} + 1, ${time}))`,
+      idle_outcome: outcome,
+      time_updated: sql`${SessionTable2.time_updated}`
+    }).where(eq(SessionTable2.id, event.data.sessionID)).run().pipe(Effect.orDie);
+  });
+}
+var layer = Layer.effectDiscard(Effect.gen(function* () {
+  const bus = yield* Service79;
+  const db = (yield* Service80).db;
+  yield* bus.project(SessionEvent2.Created, (event) => Effect.gen(function* () {
+    const stored = yield* db.insert(SessionTable2).values({
+      id: event.data.sessionID,
+      project_id: event.data.projectID,
+      workspace_id: event.data.location.workspaceID ? Workspace.ID.make(event.data.location.workspaceID) : null,
+      parent_id: event.data.parentID,
+      slug: event.data.slug,
+      directory: event.data.location.directory,
+      path: event.data.subpath,
+      title: event.data.title,
+      agent: event.data.agent,
+      model: event.data.model,
+      metadata: event.data.metadata,
+      permission: event.data.permissions,
+      version: event.data.version,
+      time_created: event.created,
+      time_updated: event.created
+    }).onConflictDoNothing().returning({ sessionID: SessionTable2.id }).get().pipe(Effect.orDie);
+    if (!stored)
+      return yield* Effect.die(new SessionAlreadyProjected2);
+  }));
+  yield* bus.project(SessionEvent2.Moved, (event) => Effect.gen(function* () {
+    yield* run(db, event);
+    yield* db.update(SessionTable2).set({
+      directory: event.data.location.directory,
+      path: event.data.subpath,
+      ...event.data.projectID ? { project_id: event.data.projectID } : {},
+      workspace_id: event.data.location.workspaceID ? Workspace.ID.make(event.data.location.workspaceID) : null,
+      time_updated: event.created
+    }).where(eq(SessionTable2.id, event.data.sessionID)).run().pipe(Effect.orDie);
+  }));
+  yield* bus.project(Worktree.Event.Resolved, (event) => Effect.gen(function* () {
+    const candidates = [
+      ...new Set([event.data.previous, Project.ID.global, ...event.data.adopted ?? []].filter((id) => id !== event.data.projectID))
+    ];
+    if (candidates.length === 0)
+      return;
+    const rows = yield* db.select({
+      id: SessionTable2.id,
+      directory: SessionTable2.directory,
+      projectID: SessionTable2.project_id,
+      canonical: ProjectTable2.worktree
+    }).from(SessionTable2).innerJoin(ProjectTable2, eq(SessionTable2.project_id, ProjectTable2.id)).where(and(inArray(SessionTable2.project_id, candidates), isNull(SessionTable2.workspace_id), or(event.data.adopted?.length ? inArray(SessionTable2.project_id, event.data.adopted) : undefined, and(gte(SessionTable2.directory, event.data.directory), lte(SessionTable2.directory, AbsolutePath2.make(event.data.directory + "￿")))))).all().pipe(Effect.orDie);
+    yield* Effect.forEach(rows, (row) => {
+      const directory = event.data.adopted?.includes(row.projectID) ? row.canonical : AbsolutePath2.make(path.resolve(row.directory));
+      if (!FSUtil.contains(event.data.directory, directory))
+        return Effect.void;
+      return db.update(SessionTable2).set({
+        project_id: event.data.projectID,
+        path: RelativePath2.make(path.relative(event.data.directory, directory).replaceAll("\\", "/")),
+        time_updated: sql`${SessionTable2.time_updated}`
+      }).where(eq(SessionTable2.id, row.id)).run().pipe(Effect.orDie);
+    }, { discard: true });
+  }));
+  yield* bus.project(SessionEvent2.Deleted, (event) => db.delete(SessionTable2).where(eq(SessionTable2.id, event.data.sessionID)).run().pipe(Effect.orDie));
+  yield* bus.project(SessionEvent2.AgentSelected, (event) => Effect.gen(function* () {
+    yield* run(db, event);
+    yield* db.update(SessionTable2).set({ agent: event.data.agent, time_updated: event.created }).where(eq(SessionTable2.id, event.data.sessionID)).run().pipe(Effect.orDie);
+  }));
+  yield* bus.project(SessionEvent2.ModelSelected, (event) => Effect.gen(function* () {
+    yield* run(db, event);
+    yield* db.update(SessionTable2).set({ model: event.data.model, time_updated: event.created }).where(eq(SessionTable2.id, event.data.sessionID)).run().pipe(Effect.orDie);
+  }));
+  yield* bus.project(SessionEvent2.Renamed, (event) => db.update(SessionTable2).set({ title: event.data.title, time_updated: event.created }).where(eq(SessionTable2.id, event.data.sessionID)).run().pipe(Effect.orDie));
+  yield* bus.project(SessionEvent2.PermissionsUpdated, (event) => db.update(SessionTable2).set({ permission: event.data.permissions, time_updated: event.created }).where(eq(SessionTable2.id, event.data.sessionID)).run().pipe(Effect.orDie));
+  yield* bus.project(SessionEvent2.Viewed, (event) => {
+    const idle = event.data.idle;
+    return db.update(SessionTable2).set({
+      time_viewed: sql`max(${idle}, coalesce(${SessionTable2.time_viewed}, ${idle}))`,
+      time_updated: sql`${SessionTable2.time_updated}`
+    }).where(eq(SessionTable2.id, event.data.sessionID)).run().pipe(Effect.orDie);
+  });
+  yield* bus.project(SessionEvent2.MessageContentUpdated, (event) => run(db, event));
+  yield* bus.project(SessionEvent2.UsageRecorded, (event) => applyUsage(db, event.data.sessionID, event.data));
+  yield* bus.project(SessionEvent2.Forked, (event) => projectFork(db, event));
+  yield* bus.project(SessionEvent2.InboxDelivered, (event) => Effect.gen(function* () {
+    const input = yield* projectDelivered2(db, {
+      id: event.data.inboxID,
+      sessionID: event.data.sessionID
+    });
+    if (input.type === "compaction" || input.type === "move")
+      return;
+    yield* insertMessage(db, event, input.type === "user" ? {
+      id: input.id,
+      type: "user",
+      metadata: input.payload.metadata,
+      text: input.payload.text,
+      files: input.payload.files,
+      agents: input.payload.agents,
+      skills: input.payload.skills,
+      time: { created: DateTime.makeUnsafe(event.created) }
+    } : {
+      id: input.id,
+      type: "synthetic",
+      text: input.payload.text,
+      description: input.payload.description,
+      metadata: input.payload.metadata,
+      time: { created: DateTime.makeUnsafe(event.created) }
+    });
+  }));
+  yield* bus.project(SessionEvent2.InboxEnqueued, (event) => Effect.gen(function* () {
+    yield* projectAdmitted2(db, {
+      enqueuedSeq: event.durable.seq,
+      id: event.data.inboxID,
+      sessionID: event.data.sessionID,
+      item: event.data.item,
+      timeCreated: event.created
+    });
+    yield* db.update(SessionTable2).set({ time_updated: event.created }).where(eq(SessionTable2.id, event.data.sessionID)).run().pipe(Effect.orDie);
+  }));
+  yield* bus.project(SessionEvent2.InboxCancelled, (event) => projectCancelled2(db, {
+    id: event.data.inboxID,
+    sessionID: event.data.sessionID
+  }));
+  yield* bus.project(SessionEvent2.InboxDeliveryChanged, (event) => projectDeliveryChanged2(db, {
+    id: event.data.inboxID,
+    sessionID: event.data.sessionID,
+    delivery: event.data.delivery
+  }));
+  yield* bus.project(SessionEvent2.Execution.Succeeded, (event) => projectIdle(db, event));
+  yield* bus.project(SessionEvent2.Execution.Failed, (event) => projectIdle(db, event));
+  yield* bus.project(SessionEvent2.Execution.Interrupted, (event) => projectIdle(db, event));
+  yield* bus.project(SessionEvent2.InstructionsUpdated, (event) => Effect.gen(function* () {
+    yield* run(db, event);
+    yield* apply2(db, event.data.sessionID, event.durable.seq, event.data.delta);
+  }));
+  yield* bus.project(SessionEvent2.Synthetic, (event) => run(db, event));
+  yield* bus.project(SessionEvent2.Skill.Activated, (event) => run(db, event));
+  yield* bus.project(SessionEvent2.Shell.Started, (event) => run(db, event));
+  yield* bus.project(SessionEvent2.Shell.Ended, (event) => run(db, event));
+  yield* bus.project(SessionEvent2.Step.Started, (event) => run(db, event));
+  yield* bus.project(SessionEvent2.Step.Streamed, (event) => run(db, event));
+  yield* bus.project(SessionEvent2.Step.Ended, (event) => Effect.gen(function* () {
+    yield* run(db, event);
+    yield* applyUsage(db, event.data.sessionID, event.data);
+  }));
+  yield* bus.project(SessionEvent2.Step.Failed, (event) => Effect.gen(function* () {
+    yield* run(db, event);
+    if (event.data.cost !== undefined && event.data.tokens !== undefined)
+      yield* applyUsage(db, event.data.sessionID, { cost: event.data.cost, tokens: event.data.tokens });
+  }));
+  yield* bus.project(SessionEvent2.Text.Started, (event) => run(db, event));
+  yield* bus.project(SessionEvent2.Text.Ended, (event) => run(db, event));
+  yield* bus.project(SessionEvent2.Tool.Input.Started, (event) => run(db, event));
+  yield* bus.project(SessionEvent2.Tool.Input.Ended, (event) => run(db, event));
+  yield* bus.project(SessionEvent2.Tool.Called, (event) => run(db, event));
+  yield* bus.project(SessionEvent2.Tool.Success, (event) => run(db, event));
+  yield* bus.project(SessionEvent2.Tool.Failed, (event) => run(db, event));
+  yield* bus.project(SessionEvent2.Reasoning.Started, (event) => run(db, event));
+  yield* bus.project(SessionEvent2.Reasoning.Ended, (event) => run(db, event));
+  yield* bus.project(SessionEvent2.RetryScheduled, (event) => run(db, event));
+  yield* bus.project(SessionEvent2.Compaction.Started, (event) => run(db, event));
+  yield* bus.project(SessionEvent2.Compaction.Ended, (event) => Effect.gen(function* () {
+    yield* run(db, event);
+    yield* advanceEpoch2(db, event.data.sessionID, event.durable.seq);
+  }));
+  yield* bus.project(SessionEvent2.Compaction.Failed, (event) => run(db, event));
+  yield* bus.project(SessionEvent2.RevertEvent.Staged, (event) => Effect.gen(function* () {
+    const revert = event.data.revert;
+    yield* db.update(SessionTable2).set({
+      revert: { ...revert, files: revert.files ? [...revert.files] : undefined },
+      time_updated: event.created
+    }).where(eq(SessionTable2.id, event.data.sessionID)).run().pipe(Effect.orDie);
+  }));
+  yield* bus.project(SessionEvent2.RevertEvent.Cleared, (event) => db.update(SessionTable2).set({ revert: null, time_updated: event.created }).where(eq(SessionTable2.id, event.data.sessionID)).run().pipe(Effect.orDie, Effect.asVoid));
+  yield* bus.project(SessionEvent2.RevertEvent.Committed, (event) => Effect.gen(function* () {
+    const boundary = yield* db.select({ seq: SessionMessageTable2.seq }).from(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, event.data.sessionID), eq(SessionMessageTable2.id, event.data.to))).get().pipe(Effect.orDie);
+    if (!boundary)
+      return yield* Effect.die(new Error(`Revert boundary message not found: ${event.data.to}`));
+    yield* db.delete(SessionMessageTable2).where(and(eq(SessionMessageTable2.session_id, event.data.sessionID), gte(SessionMessageTable2.seq, boundary.seq))).run().pipe(Effect.orDie);
+    yield* db.delete(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, event.data.sessionID), gte(SessionInboxTable2.enqueued_seq, boundary.seq))).run().pipe(Effect.orDie);
+    yield* db.update(SessionTable2).set({ revert: null, time_updated: event.created }).where(eq(SessionTable2.id, event.data.sessionID)).run().pipe(Effect.orDie);
+    yield* reset2(db, event.data.sessionID);
+  }));
+  yield* bus.subscribe([SessionEvent2.Step.Ended, SessionEvent2.Step.Failed, SessionEvent2.UsageRecorded]).pipe(Stream.runForEach((event) => {
+    if (event.type === SessionEvent2.Step.Failed.type && (event.data.cost === undefined || event.data.tokens === undefined))
+      return Effect.void;
+    return publishSessionUsage(db, bus, event.data.sessionID);
+  }), Effect.forkScoped({ startImmediately: true }));
+}));
+var node25 = makeGlobalNode({ name: "session-projector", layer, deps: [node84, node85] });
+
+export { SessionAlreadyProjected2, node25, exports_projector };

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

@@ -0,0 +1,116 @@
+import {
+  SessionEvent2
+} from "./aisdk-native-ec1grn59.js";
+import {
+  toSessionError2
+} from "./aisdk-native-bp3wckns.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/session/runner/retry.ts
+var exports_retry = {};
+__export(exports_retry, {
+  SessionRunnerRetry: () => exports_retry,
+  isRetryable: () => isRetryable2,
+  make: () => make8,
+  policy: () => policy2,
+  transient: () => transient2
+});
+import { isContextOverflowFailure } from "@opencode/ai";
+import { Clock, Duration, Effect, Pull, Schedule } from "effect";
+function isRetryable2(error) {
+  const override = error.reason.http?.headers["x-should-retry"];
+  if (override === "true")
+    return true;
+  if (override === "false")
+    return false;
+  switch (error.reason._tag) {
+    case "RateLimit":
+    case "ProviderInternal":
+      return true;
+    case "Transport":
+      return error.reason.delivery !== "accepted" && error.reason.delivery !== "rejected";
+    case "InvalidProviderOutput":
+      return error.reason.classification === "incomplete-stream";
+    case "UnknownProvider":
+      return true;
+    case "Authentication":
+    case "QuotaExceeded":
+    case "ContentPolicy":
+    case "InvalidRequest":
+    case "UnsupportedOperation":
+    case "NoRoute":
+      return false;
+    default: {
+      const exhaustive = error.reason;
+      return exhaustive;
+    }
+  }
+}
+var RETRY_AFTER_MAX = Duration.toMillis("15 minutes");
+var retryAfter = (input) => {
+  if (input.cause.reason._tag === "RateLimit" || input.cause.reason._tag === "ProviderInternal")
+    return input.cause.reason.retryAfterMs === undefined ? undefined : Math.min(input.cause.reason.retryAfterMs, RETRY_AFTER_MAX);
+  return;
+};
+var schedule = Schedule.max([Schedule.exponential("2 seconds"), Schedule.recurs(4)]).pipe(Schedule.jittered, Schedule.setInputType(), Schedule.modifyDelay(({ input, duration: delay }) => {
+  const minimum = retryAfter(input);
+  const duration = minimum === undefined ? delay : Duration.max(delay, Duration.millis(minimum));
+  return Effect.succeed(Duration.millis(Math.ceil(Duration.toMillis(duration))));
+}));
+var policy2 = (sessionID) => Effect.gen(function* () {
+  const step = yield* Schedule.toStep(schedule);
+  let attempt = 1;
+  return (input) => Effect.gen(function* () {
+    const now = yield* Clock.currentTimeMillis;
+    const next = yield* step(now, input).pipe(Pull.catchDone(() => Effect.succeed(undefined)));
+    if (!next)
+      return { retry: false };
+    const [, duration] = next;
+    attempt++;
+    const delay = Math.ceil(Duration.toMillis(duration));
+    const event = {
+      sessionID,
+      agent: input.agent,
+      model: input.model,
+      error: input.error,
+      attempt,
+      decision: input.retry ? { retry: true, delay } : { retry: false }
+    };
+    yield* input.hook(event);
+    if (!event.decision.retry)
+      return event.decision;
+    const normalized = Number.isFinite(event.decision.delay) && event.decision.delay >= 0 ? Math.ceil(event.decision.delay) : delay;
+    return { retry: true, attempt, delay: normalized };
+  });
+});
+var transient2 = (decide, input) => (effect) => Effect.retry(effect, {
+  while: (cause) => Effect.gen(function* () {
+    if (isContextOverflowFailure(cause))
+      return false;
+    const decision = yield* decide({ ...input, cause, error: toSessionError2(cause), retry: isRetryable2(cause) });
+    if (!decision.retry)
+      return false;
+    yield* Effect.sleep(decision.delay);
+    return true;
+  })
+});
+var make8 = (bus, sessionID) => Effect.gen(function* () {
+  const decide = yield* policy2(sessionID);
+  const wait = (input) => Effect.gen(function* () {
+    const scheduled = yield* Clock.currentTimeMillis;
+    yield* bus.publish(SessionEvent2.RetryScheduled, {
+      sessionID,
+      assistantMessageID: input.assistantMessageID,
+      attempt: input.decision.attempt,
+      at: scheduled + input.decision.delay,
+      error: input.error
+    });
+    const remaining = Math.max(0, scheduled + input.decision.delay - (yield* Clock.currentTimeMillis));
+    yield* Effect.sleep(Duration.millis(remaining));
+  });
+  return { decide, wait };
+});
+
+export { isRetryable2, policy2, transient2, make8, exports_retry };