anymous 1.0.0

package/src/session/reminders.ts

@@ -0,0 +1,92 @@
+import path from "path"
+import { SessionV1 } from "@opencode-ai/core/v1/session"
+import { Effect } from "effect"
+import { Agent } from "@/agent/agent"
+import { FSUtil } from "@opencode-ai/core/fs-util"
+import { InstanceState } from "@/effect/instance-state"
+import { RuntimeFlags } from "@/effect/runtime-flags"
+import { PartID } from "./schema"
+import { MessageV2 } from "./message-v2"
+import { Session } from "./session"
+import PROMPT_PLAN from "./prompt/plan.txt"
+import BUILD_SWITCH from "./prompt/build-switch.txt"
+import PLAN_MODE from "./prompt/plan-mode.txt"
+
+export const apply = Effect.fn("SessionReminders.apply")(function* (input: {
+  messages: SessionV1.WithParts[]
+  agent: Agent.Info
+  session: Session.Info
+}) {
+  const flags = yield* RuntimeFlags.Service
+  const fsys = yield* FSUtil.Service
+  const sessions = yield* Session.Service
+  const userMessage = input.messages.findLast((msg) => msg.info.role === "user")
+  if (!userMessage) return input.messages
+
+  if (!flags.experimentalPlanMode) {
+    if (input.agent.name === "plan") {
+      userMessage.parts.push({
+        id: PartID.ascending(),
+        messageID: userMessage.info.id,
+        sessionID: userMessage.info.sessionID,
+        type: "text",
+        text: PROMPT_PLAN,
+        synthetic: true,
+      })
+    }
+    const wasPlan = input.messages.some((msg) => msg.info.role === "assistant" && msg.info.agent === "plan")
+    if (wasPlan && input.agent.name === "build") {
+      userMessage.parts.push({
+        id: PartID.ascending(),
+        messageID: userMessage.info.id,
+        sessionID: userMessage.info.sessionID,
+        type: "text",
+        text: BUILD_SWITCH,
+        synthetic: true,
+      })
+    }
+    return input.messages
+  }
+
+  const assistantMessage = input.messages.findLast((msg) => msg.info.role === "assistant")
+  if (input.agent.name !== "plan" && assistantMessage?.info.agent === "plan") {
+    const ctx = yield* InstanceState.context
+    const plan = Session.plan(input.session, ctx)
+    const exists = yield* fsys.existsSafe(plan)
+    const part = yield* sessions.updatePart({
+      id: PartID.ascending(),
+      messageID: userMessage.info.id,
+      sessionID: userMessage.info.sessionID,
+      type: "text",
+      text: exists
+        ? `${BUILD_SWITCH}\n\nA plan file exists at ${plan}. You should execute on the plan defined within it`
+        : BUILD_SWITCH,
+      synthetic: true,
+    })
+    userMessage.parts.push(part)
+    return input.messages
+  }
+
+  if (input.agent.name !== "plan" || assistantMessage?.info.agent === "plan") return input.messages
+
+  const ctx = yield* InstanceState.context
+  const plan = Session.plan(input.session, ctx)
+  const exists = yield* fsys.existsSafe(plan)
+  if (!exists) yield* fsys.ensureDir(path.dirname(plan)).pipe(Effect.catch(Effect.die))
+  const part = yield* sessions.updatePart({
+    id: PartID.ascending(),
+    messageID: userMessage.info.id,
+    sessionID: userMessage.info.sessionID,
+    type: "text",
+    text: PLAN_MODE.replace("${planInfo}", () =>
+      exists
+        ? `A plan file already exists at ${plan}. You can read it and make incremental edits using the edit tool.`
+        : `No plan file exists yet. You should create your plan at ${plan} using the write tool.`,
+    ),
+    synthetic: true,
+  })
+  userMessage.parts.push(part)
+  return input.messages
+})
+
+export * as SessionReminders from "./reminders"

package/src/session/retry.ts

@@ -0,0 +1,201 @@
+import type { NamedError } from "@opencode-ai/core/util/error"
+import { SessionV1 } from "@opencode-ai/core/v1/session"
+import { Cause, Clock, Duration, Effect, Schedule } from "effect"
+import { MessageV2 } from "./message-v2"
+import { iife } from "@/util/iife"
+import { isRecord } from "@/util/record"
+
+export type Err = ReturnType<NamedError["toObject"]>
+
+export const GO_UPSELL_MESSAGE = "Free usage exceeded, subscribe to Go"
+export const GO_UPSELL_URL = "https://opencode.ai/go"
+export type RetryReason = "free_tier_limit" | "account_rate_limit" | (string & {})
+
+export type Retryable = {
+  message: string
+  action?: {
+    reason: RetryReason
+    provider: string
+    title: string
+    message: string
+    label: string
+    link?: string
+  }
+}
+
+export const RETRY_INITIAL_DELAY = 2000
+export const RETRY_BACKOFF_FACTOR = 2
+export const RETRY_MAX_DELAY_NO_HEADERS = 30_000 // 30 seconds
+export const RETRY_MAX_DELAY = 2_147_483_647 // max 32-bit signed integer for setTimeout
+
+function cap(ms: number) {
+  return Math.min(ms, RETRY_MAX_DELAY)
+}
+
+export function delay(attempt: number, error?: SessionV1.APIError) {
+  if (error) {
+    const headers = error.data.responseHeaders
+    if (headers) {
+      const retryAfterMs = headers["retry-after-ms"]
+      if (retryAfterMs) {
+        const parsedMs = Number.parseFloat(retryAfterMs)
+        if (!Number.isNaN(parsedMs)) {
+          return cap(parsedMs)
+        }
+      }
+
+      const retryAfter = headers["retry-after"]
+      if (retryAfter) {
+        const parsedSeconds = Number.parseFloat(retryAfter)
+        if (!Number.isNaN(parsedSeconds)) {
+          // convert seconds to milliseconds
+          return cap(Math.ceil(parsedSeconds * 1000))
+        }
+        // Try parsing as HTTP date format
+        const parsed = Date.parse(retryAfter) - Date.now()
+        if (!Number.isNaN(parsed) && parsed > 0) {
+          return cap(Math.ceil(parsed))
+        }
+      }
+
+      return cap(RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1))
+    }
+  }
+
+  return cap(Math.min(RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1), RETRY_MAX_DELAY_NO_HEADERS))
+}
+
+export function retryable(error: Err, provider: string) {
+  // context overflow errors should not be retried
+  if (SessionV1.ContextOverflowError.isInstance(error)) return undefined
+  if (SessionV1.APIError.isInstance(error)) {
+    const status = error.data.statusCode
+    // 5xx errors are transient server failures and should always be retried,
+    // even when the provider SDK doesn't explicitly mark them as retryable.
+    if (!error.data.isRetryable && !(status !== undefined && status >= 500)) return undefined
+    if (error.data.responseBody?.includes("FreeUsageLimitError")) {
+      return {
+        message: GO_UPSELL_MESSAGE,
+        action: {
+          reason: "free_tier_limit",
+          provider,
+          title: "Free limit reached",
+          message: "Subscribe to OpenCode Go for reliable access to the best open-source models, starting at $5/month.",
+          label: "subscribe",
+          link: GO_UPSELL_URL,
+        },
+      }
+    }
+    if (error.data.responseBody?.includes("GoUsageLimitError")) {
+      const body = parseJSON(error.data.responseBody)
+      const workspace = str(body?.metadata?.workspace)
+      const limitName = str(body?.metadata?.limitName)
+      const retryAfter = num(error.data.responseHeaders?.["retry-after"])
+      const resetIn = iife(() => {
+        if (retryAfter === undefined) return ""
+        const seconds = Math.max(0, Math.ceil(retryAfter))
+        const days = Math.floor(seconds / 86_400)
+        const hours = Math.floor((seconds % 86_400) / 3_600)
+        const minutes = Math.ceil((seconds % 3_600) / 60)
+        const unit = (value: number, name: string) => `${value} ${name}${value === 1 ? "" : "s"}`
+
+        if (days > 0) return hours > 0 ? `${unit(days, "day")} ${unit(hours, "hour")}` : unit(days, "day")
+        if (hours > 0) return minutes > 0 ? `${unit(hours, "hour")} ${unit(minutes, "minute")}` : unit(hours, "hour")
+        return minutes > 0 ? unit(minutes, "minute") : "less than a minute"
+      })
+
+      const message = `${limitName ? `${limitName} usage limit` : "Usage limit"} reached. It will reset in ${resetIn}. To continue using this model now, enable usage from your available balance`
+
+      const link = `https://opencode.ai/workspace/${workspace}/go`
+      return {
+        message: `${message} - ${link}`,
+        action: {
+          reason: "account_rate_limit",
+          provider,
+          title: "Go limit reached",
+          message,
+          label: "open settings",
+          link,
+        },
+      }
+    }
+    return { message: error.data.message.includes("Overloaded") ? "Provider is overloaded" : error.data.message }
+  }
+
+  // Check for rate limit patterns in plain text error messages
+  const msg = isRecord(error.data) ? error.data.message : undefined
+  if (typeof msg === "string") {
+    const lower = msg.toLowerCase()
+    if (
+      lower.includes("rate increased too quickly") ||
+      lower.includes("rate limit") ||
+      lower.includes("too many requests")
+    ) {
+      return { message: msg }
+    }
+  }
+
+  const json = parseJSON(msg)
+  if (!json || typeof json !== "object") return undefined
+  const code = typeof json.code === "string" ? json.code : ""
+
+  if (json.type === "error" && json.error?.type === "too_many_requests") {
+    return { message: "Too Many Requests" }
+  }
+  if (code.includes("exhausted") || code.includes("unavailable")) {
+    return { message: "Provider is overloaded" }
+  }
+  if (json.type === "error" && typeof json.error?.code === "string" && json.error.code.includes("rate_limit")) {
+    return { message: "Rate Limited" }
+  }
+  return undefined
+}
+
+function str(value: unknown) {
+  if (value === undefined || value === null) return ""
+  return String(value)
+}
+
+function num(value: unknown) {
+  const parsed = Number.parseFloat(str(value))
+  if (Number.isNaN(parsed)) return undefined
+  return parsed
+}
+
+function parseJSON(value: unknown) {
+  return iife(() => {
+    try {
+      if (typeof value !== "string") return undefined
+      return JSON.parse(value)
+    } catch {
+      return undefined
+    }
+  })
+}
+
+export function policy(opts: {
+  provider: string
+  parse: (error: unknown) => Err
+  set: (input: { attempt: number; message: string; action?: Retryable["action"]; next: number }) => Effect.Effect<void>
+}) {
+  return Schedule.fromStepWithMetadata(
+    Effect.succeed((meta: Schedule.InputMetadata<unknown>) => {
+      const error = opts.parse(meta.input)
+      const retry = retryable(error, opts.provider)
+      if (!retry) return Cause.done(meta.attempt)
+      return Effect.gen(function* () {
+        const wait = delay(meta.attempt, SessionV1.APIError.isInstance(error) ? error : undefined)
+        const now = yield* Clock.currentTimeMillis
+        yield* opts.set({
+          attempt: meta.attempt,
+          message: retry.message,
+          action: retry.action,
+          next: now + wait,
+        })
+        return [meta.attempt, Duration.millis(wait)] as [number, Duration.Duration]
+      })
+    }),
+  )
+}
+
+export * as SessionRetry from "./retry"

package/src/session/revert.ts

@@ -0,0 +1,146 @@
+import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { Effect, Layer, Context, Schema } from "effect"
+import { SessionV1 } from "@opencode-ai/core/v1/session"
+import { EventV2Bridge } from "@/event-v2-bridge"
+import { Snapshot } from "../snapshot"
+import { Storage } from "@/storage/storage"
+import { Session } from "./session"
+import { MessageV2 } from "./message-v2"
+import { SessionID, MessageID, PartID } from "./schema"
+import { SessionRunState } from "./run-state"
+import { SessionSummary } from "./summary"
+
+export const RevertInput = Schema.Struct({
+  sessionID: SessionID,
+  messageID: MessageID,
+  partID: Schema.optional(PartID),
+})
+export type RevertInput = Schema.Schema.Type<typeof RevertInput>
+
+export interface Interface {
+  readonly revert: (input: RevertInput) => Effect.Effect<Session.Info, Session.BusyError>
+  readonly unrevert: (input: { sessionID: SessionID }) => Effect.Effect<Session.Info, Session.BusyError>
+  readonly cleanup: (session: Session.Info) => Effect.Effect<void>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/SessionRevert") {}
+
+const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const sessions = yield* Session.Service
+    const snap = yield* Snapshot.Service
+    const storage = yield* Storage.Service
+    const events = yield* EventV2Bridge.Service
+    const summary = yield* SessionSummary.Service
+    const state = yield* SessionRunState.Service
+
+    const revert = Effect.fn("SessionRevert.revert")(function* (input: RevertInput) {
+      yield* state.assertNotBusy(input.sessionID)
+      const all = yield* sessions.messages({ sessionID: input.sessionID }).pipe(Effect.orDie)
+      let lastUser: SessionV1.User | undefined
+      const session = yield* sessions.get(input.sessionID).pipe(Effect.orDie)
+
+      let rev: Session.Info["revert"]
+      const patches: Snapshot.Patch[] = []
+      for (const msg of all) {
+        if (msg.info.role === "user") lastUser = msg.info
+        const remaining = []
+        for (const part of msg.parts) {
+          if (rev) {
+            if (part.type === "patch") patches.push(part)
+            continue
+          }
+
+          if (!rev) {
+            if ((msg.info.id === input.messageID && !input.partID) || part.id === input.partID) {
+              const partID = remaining.some((item) => ["text", "tool"].includes(item.type)) ? input.partID : undefined
+              rev = {
+                messageID: !partID && lastUser ? lastUser.id : msg.info.id,
+                partID,
+              }
+            }
+            remaining.push(part)
+          }
+        }
+      }
+
+      if (!rev) return session
+
+      rev.snapshot = session.revert?.snapshot ?? (yield* snap.track())
+      if (session.revert?.snapshot) yield* snap.restore(session.revert.snapshot)
+      yield* snap.revert(patches)
+      if (rev.snapshot) rev.diff = yield* snap.diff(rev.snapshot)
+      const range = all.filter((msg) => msg.info.id >= rev.messageID)
+      const diffs = yield* summary.computeDiff({ messages: range })
+      yield* storage.write(["session_diff", input.sessionID], diffs).pipe(Effect.ignore)
+      yield* events.publish(Session.Event.Diff, { sessionID: input.sessionID, diff: diffs })
+      yield* sessions.setRevert({
+        sessionID: input.sessionID,
+        revert: rev,
+        summary: {
+          additions: diffs.reduce((sum, x) => sum + x.additions, 0),
+          deletions: diffs.reduce((sum, x) => sum + x.deletions, 0),
+          files: diffs.length,
+        },
+      })
+      return yield* sessions.get(input.sessionID).pipe(Effect.orDie)
+    })
+
+    const unrevert = Effect.fn("SessionRevert.unrevert")(function* (input: { sessionID: SessionID }) {
+      yield* Effect.logInfo("unreverting", { sessionID: input.sessionID })
+      yield* state.assertNotBusy(input.sessionID)
+      const session = yield* sessions.get(input.sessionID).pipe(Effect.orDie)
+      if (!session.revert) return session
+      if (session.revert.snapshot) yield* snap.restore(session.revert.snapshot)
+      yield* sessions.clearRevert(input.sessionID)
+      return yield* sessions.get(input.sessionID).pipe(Effect.orDie)
+    })
+
+    const cleanup = Effect.fn("SessionRevert.cleanup")(function* (session: Session.Info) {
+      if (!session.revert) return
+      const sessionID = session.id
+      const msgs = yield* sessions.messages({ sessionID }).pipe(Effect.orDie)
+      const messageID = session.revert.messageID
+      const remove = [] as SessionV1.WithParts[]
+      let target: SessionV1.WithParts | undefined
+      for (const msg of msgs) {
+        if (msg.info.id < messageID) continue
+        if (msg.info.id > messageID) {
+          remove.push(msg)
+          continue
+        }
+        if (session.revert.partID) {
+          target = msg
+          continue
+        }
+        remove.push(msg)
+      }
+      for (const msg of remove) {
+        yield* sessions.removeMessage({ sessionID, messageID: msg.info.id })
+      }
+      if (session.revert.partID && target) {
+        const partID = session.revert.partID
+        const idx = target.parts.findIndex((part) => part.id === partID)
+        if (idx >= 0) {
+          const removeParts = target.parts.slice(idx)
+          target.parts = target.parts.slice(0, idx)
+          for (const part of removeParts) {
+            yield* sessions.removePart({ sessionID, messageID: target.info.id, partID: part.id })
+          }
+        }
+      }
+      yield* sessions.clearRevert(sessionID)
+    })
+
+    return Service.of({ revert, unrevert, cleanup })
+  }),
+)
+
+export const node = LayerNode.make({
+  service: Service,
+  layer: layer,
+  deps: [Session.node, Snapshot.node, Storage.node, EventV2Bridge.node, SessionSummary.node, SessionRunState.node],
+})
+
+export * as SessionRevert from "./revert"

package/src/session/run-state.ts

@@ -0,0 +1,151 @@
+import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { InstanceState } from "@/effect/instance-state"
+import { SessionV1 } from "@opencode-ai/core/v1/session"
+import { Runner } from "@/effect/runner"
+import { BackgroundJob } from "@/background/job"
+import { Effect, Latch, Layer, Scope, Context } from "effect"
+import { Session } from "./session"
+import { SessionID } from "./schema"
+import { SessionStatus } from "./status"
+
+export interface Interface {
+  readonly assertNotBusy: (sessionID: SessionID) => Effect.Effect<void, Session.BusyError>
+  readonly cancel: (sessionID: SessionID) => Effect.Effect<void>
+  readonly ensureRunning: (
+    sessionID: SessionID,
+    onInterrupt: Effect.Effect<SessionV1.WithParts>,
+    work: Effect.Effect<SessionV1.WithParts>,
+  ) => Effect.Effect<SessionV1.WithParts>
+  readonly startShell: (
+    sessionID: SessionID,
+    onInterrupt: Effect.Effect<SessionV1.WithParts>,
+    work: Effect.Effect<SessionV1.WithParts>,
+    ready?: Latch.Latch,
+  ) => Effect.Effect<SessionV1.WithParts, Session.BusyError>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/SessionRunState") {}
+
+const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const background = yield* BackgroundJob.Service
+    const status = yield* SessionStatus.Service
+
+    const state = yield* InstanceState.make(
+      Effect.fn("SessionRunState.state")(function* () {
+        const scope = yield* Scope.Scope
+        const runners = new Map<SessionID, Runner.Runner<SessionV1.WithParts>>()
+        yield* Effect.addFinalizer(
+          Effect.fnUntraced(function* () {
+            yield* Effect.forEach(runners.values(), (runner) => runner.cancel, {
+              concurrency: "unbounded",
+              discard: true,
+            })
+            runners.clear()
+          }),
+        )
+        return { runners, scope }
+      }),
+    )
+
+    const runner = Effect.fn("SessionRunState.runner")(function* (
+      sessionID: SessionID,
+      onInterrupt: Effect.Effect<SessionV1.WithParts>,
+    ) {
+      const data = yield* InstanceState.get(state)
+      const existing = data.runners.get(sessionID)
+      if (existing) return existing
+      const next = Runner.make<SessionV1.WithParts>(data.scope, {
+        onIdle: Effect.gen(function* () {
+          data.runners.delete(sessionID)
+          yield* status.set(sessionID, { type: "idle" })
+        }),
+        onBusy: status.set(sessionID, { type: "busy" }),
+        onInterrupt,
+      })
+      data.runners.set(sessionID, next)
+      return next
+    })
+
+    const assertNotBusy = Effect.fn("SessionRunState.assertNotBusy")(function* (sessionID: SessionID) {
+      const data = yield* InstanceState.get(state)
+      const existing = data.runners.get(sessionID)
+      if (existing?.busy) yield* busyError(sessionID)
+    })
+
+    const cancel = Effect.fn("SessionRunState.cancel")(function* (sessionID: SessionID) {
+      yield* cancelBackgroundJobs(background, sessionID)
+      const data = yield* InstanceState.get(state)
+      const existing = data.runners.get(sessionID)
+      if (!existing) {
+        yield* status.set(sessionID, { type: "idle" })
+        return
+      }
+      yield* existing.cancel
+    })
+
+    const ensureRunning = Effect.fn("SessionRunState.ensureRunning")(function* (
+      sessionID: SessionID,
+      onInterrupt: Effect.Effect<SessionV1.WithParts>,
+      work: Effect.Effect<SessionV1.WithParts>,
+    ) {
+      return yield* (yield* runner(sessionID, onInterrupt)).ensureRunning(work)
+    })
+
+    const startShell = Effect.fn("SessionRunState.startShell")(function* (
+      sessionID: SessionID,
+      onInterrupt: Effect.Effect<SessionV1.WithParts>,
+      work: Effect.Effect<SessionV1.WithParts>,
+      ready?: Latch.Latch,
+    ) {
+      return yield* (yield* runner(sessionID, onInterrupt))
+        .startShell(work, ready)
+        .pipe(Effect.catchTag("RunnerBusy", () => Effect.fail(busyError(sessionID))))
+    })
+
+    return Service.of({ assertNotBusy, cancel, ensureRunning, startShell })
+  }),
+)
+
+const cancelBackgroundJobs = Effect.fn("SessionRunState.cancelBackgroundJobs")(function* (
+  background: BackgroundJob.Interface,
+  sessionID: SessionID,
+) {
+  const jobs = yield* background.list()
+  const pending = new Set<string>([sessionID])
+  const cancelled = new Set<string>()
+  const matches = (job: BackgroundJob.Info) => {
+    if (job.status !== "running") return false
+    if (cancelled.has(job.id)) return false
+    if (pending.has(job.id)) return true
+    if (typeof job.metadata?.sessionId === "string" && pending.has(job.metadata.sessionId)) return true
+    return typeof job.metadata?.parentSessionId === "string" && pending.has(job.metadata.parentSessionId)
+  }
+  let batch = jobs.filter(matches)
+  while (batch.length > 0) {
+    yield* Effect.forEach(
+      batch,
+      (job) =>
+        background.cancel(job.id).pipe(
+          Effect.tap(() =>
+            Effect.sync(() => {
+              cancelled.add(job.id)
+              pending.add(job.id)
+              if (typeof job.metadata?.sessionId === "string") pending.add(job.metadata.sessionId)
+            }),
+          ),
+        ),
+      { concurrency: "unbounded", discard: true },
+    )
+    batch = jobs.filter(matches)
+  }
+})
+
+function busyError(sessionID: SessionID) {
+  return new Session.BusyError({ sessionID })
+}
+
+export const node = LayerNode.make({ service: Service, layer: layer, deps: [BackgroundJob.node, SessionStatus.node] })
+
+export * as SessionRunState from "./run-state"

package/src/session/schema.ts

@@ -0,0 +1,26 @@
+import { Schema } from "effect"
+
+import { Identifier } from "@/id/id"
+import { SessionV2 } from "@opencode-ai/core/session"
+import { statics } from "@opencode-ai/core/schema"
+
+export const SessionID = SessionV2.ID
+export type SessionID = Schema.Schema.Type<typeof SessionID>
+
+export const MessageID = Schema.String.check(Schema.isStartsWith("msg")).pipe(
+  Schema.brand("MessageID"),
+  statics((s) => ({
+    ascending: (id?: string) => s.make(Identifier.ascending("message", id)),
+  })),
+)
+
+export type MessageID = Schema.Schema.Type<typeof MessageID>
+
+export const PartID = Schema.String.check(Schema.isStartsWith("prt")).pipe(
+  Schema.brand("PartID"),
+  statics((s) => ({
+    ascending: (id?: string) => s.make(Identifier.ascending("part", id)),
+  })),
+)
+
+export type PartID = Schema.Schema.Type<typeof PartID>