alchemylab-opencode 1.0.6 → 1.0.8

package/packages/opencode/src/session/retry.ts

@@ -1,106 +0,0 @@
-import type { NamedError } from "@opencode-ai/util/error"
-import { Cause, Clock, Duration, Effect, Schedule } from "effect"
-import { MessageV2 } from "./message-v2"
-import { iife } from "@/util/iife"
-
-export namespace SessionRetry {
-  export type Err = ReturnType<NamedError["toObject"]>
-
-  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?: MessageV2.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) {
-    // context overflow errors should not be retried
-    if (MessageV2.ContextOverflowError.isInstance(error)) return undefined
-    if (MessageV2.APIError.isInstance(error)) {
-      if (!error.data.isRetryable) return undefined
-      if (error.data.responseBody?.includes("FreeUsageLimitError"))
-        return `Free usage exceeded, subscribe to Go https://opencode.ai/go`
-      return error.data.message.includes("Overloaded") ? "Provider is overloaded" : error.data.message
-    }
-
-    const json = iife(() => {
-      try {
-        if (typeof error.data?.message === "string") {
-          const parsed = JSON.parse(error.data.message)
-          return parsed
-        }
-
-        return JSON.parse(error.data.message)
-      } catch {
-        return undefined
-      }
-    })
-    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 "Too Many Requests"
-    }
-    if (code.includes("exhausted") || code.includes("unavailable")) {
-      return "Provider is overloaded"
-    }
-    if (json.type === "error" && typeof json.error?.code === "string" && json.error.code.includes("rate_limit")) {
-      return "Rate Limited"
-    }
-    return undefined
-  }
-
-  export function policy(opts: {
-    parse: (error: unknown) => Err
-    set: (input: { attempt: number; message: string; next: number }) => Effect.Effect<void>
-  }) {
-    return Schedule.fromStepWithMetadata(
-      Effect.succeed((meta: Schedule.InputMetadata<unknown>) => {
-        const error = opts.parse(meta.input)
-        const message = retryable(error)
-        if (!message) return Cause.done(meta.attempt)
-        return Effect.gen(function* () {
-          const wait = delay(meta.attempt, MessageV2.APIError.isInstance(error) ? error : undefined)
-          const now = yield* Clock.currentTimeMillis
-          yield* opts.set({ attempt: meta.attempt, message, next: now + wait })
-          return [meta.attempt, Duration.millis(wait)] as [number, Duration.Duration]
-        })
-      }),
-    )
-  }
-}

package/packages/opencode/src/session/revert.ts

@@ -1,176 +0,0 @@
-import z from "zod"
-import { Effect, Layer, ServiceMap } from "effect"
-import { makeRuntime } from "@/effect/run-service"
-import { Bus } from "../bus"
-import { Snapshot } from "../snapshot"
-import { Storage } from "@/storage/storage"
-import { SyncEvent } from "../sync"
-import { Log } from "../util/log"
-import { Session } from "."
-import { MessageV2 } from "./message-v2"
-import { SessionID, MessageID, PartID } from "./schema"
-import { SessionPrompt } from "./prompt"
-import { SessionSummary } from "./summary"
-
-export namespace SessionRevert {
-  const log = Log.create({ service: "session.revert" })
-
-  export const RevertInput = z.object({
-    sessionID: SessionID.zod,
-    messageID: MessageID.zod,
-    partID: PartID.zod.optional(),
-  })
-  export type RevertInput = z.infer<typeof RevertInput>
-
-  export interface Interface {
-    readonly revert: (input: RevertInput) => Effect.Effect<Session.Info>
-    readonly unrevert: (input: { sessionID: SessionID }) => Effect.Effect<Session.Info>
-    readonly cleanup: (session: Session.Info) => Effect.Effect<void>
-  }
-
-  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/SessionRevert") {}
-
-  export const layer = Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const sessions = yield* Session.Service
-      const snap = yield* Snapshot.Service
-      const storage = yield* Storage.Service
-      const bus = yield* Bus.Service
-      const summary = yield* SessionSummary.Service
-
-      const revert = Effect.fn("SessionRevert.revert")(function* (input: RevertInput) {
-        yield* Effect.promise(() => SessionPrompt.assertNotBusy(input.sessionID))
-        const all = yield* sessions.messages({ sessionID: input.sessionID })
-        let lastUser: MessageV2.User | undefined
-        const session = yield* sessions.get(input.sessionID)
-
-        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 as string)
-        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* bus.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)
-      })
-
-      const unrevert = Effect.fn("SessionRevert.unrevert")(function* (input: { sessionID: SessionID }) {
-        log.info("unreverting", input)
-        yield* Effect.promise(() => SessionPrompt.assertNotBusy(input.sessionID))
-        const session = yield* sessions.get(input.sessionID)
-        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)
-      })
-
-      const cleanup = Effect.fn("SessionRevert.cleanup")(function* (session: Session.Info) {
-        if (!session.revert) return
-        const sessionID = session.id
-        const msgs = yield* sessions.messages({ sessionID })
-        const messageID = session.revert.messageID
-        const remove = [] as MessageV2.WithParts[]
-        let target: MessageV2.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) {
-          SyncEvent.run(MessageV2.Event.Removed, {
-            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) {
-              SyncEvent.run(MessageV2.Event.PartRemoved, {
-                sessionID,
-                messageID: target.info.id,
-                partID: part.id,
-              })
-            }
-          }
-        }
-        yield* sessions.clearRevert(sessionID)
-      })
-
-      return Service.of({ revert, unrevert, cleanup })
-    }),
-  )
-
-  export const defaultLayer = Layer.unwrap(
-    Effect.sync(() =>
-      layer.pipe(
-        Layer.provide(Session.defaultLayer),
-        Layer.provide(Snapshot.defaultLayer),
-        Layer.provide(Storage.defaultLayer),
-        Layer.provide(Bus.layer),
-        Layer.provide(SessionSummary.defaultLayer),
-      ),
-    ),
-  )
-
-  const { runPromise } = makeRuntime(Service, defaultLayer)
-
-  export async function revert(input: RevertInput) {
-    return runPromise((svc) => svc.revert(input))
-  }
-
-  export async function unrevert(input: { sessionID: SessionID }) {
-    return runPromise((svc) => svc.unrevert(input))
-  }
-
-  export async function cleanup(session: Session.Info) {
-    return runPromise((svc) => svc.cleanup(session))
-  }
-}

package/packages/opencode/src/session/schema.ts

@@ -1,38 +0,0 @@
-import { Schema } from "effect"
-import z from "zod"
-
-import { Identifier } from "@/id/id"
-import { withStatics } from "@/util/schema"
-
-export const SessionID = Schema.String.pipe(
-  Schema.brand("SessionID"),
-  withStatics((s) => ({
-    make: (id: string) => s.makeUnsafe(id),
-    descending: (id?: string) => s.makeUnsafe(Identifier.descending("session", id)),
-    zod: Identifier.schema("session").pipe(z.custom<Schema.Schema.Type<typeof s>>()),
-  })),
-)
-
-export type SessionID = Schema.Schema.Type<typeof SessionID>
-
-export const MessageID = Schema.String.pipe(
-  Schema.brand("MessageID"),
-  withStatics((s) => ({
-    make: (id: string) => s.makeUnsafe(id),
-    ascending: (id?: string) => s.makeUnsafe(Identifier.ascending("message", id)),
-    zod: Identifier.schema("message").pipe(z.custom<Schema.Schema.Type<typeof s>>()),
-  })),
-)
-
-export type MessageID = Schema.Schema.Type<typeof MessageID>
-
-export const PartID = Schema.String.pipe(
-  Schema.brand("PartID"),
-  withStatics((s) => ({
-    make: (id: string) => s.makeUnsafe(id),
-    ascending: (id?: string) => s.makeUnsafe(Identifier.ascending("part", id)),
-    zod: Identifier.schema("part").pipe(z.custom<Schema.Schema.Type<typeof s>>()),
-  })),
-)
-
-export type PartID = Schema.Schema.Type<typeof PartID>

package/packages/opencode/src/session/session.sql.ts

@@ -1,103 +0,0 @@
-import { sqliteTable, text, integer, index, primaryKey } from "drizzle-orm/sqlite-core"
-import { ProjectTable } from "../project/project.sql"
-import type { MessageV2 } from "./message-v2"
-import type { Snapshot } from "../snapshot"
-import type { Permission } from "../permission"
-import type { ProjectID } from "../project/schema"
-import type { SessionID, MessageID, PartID } from "./schema"
-import type { WorkspaceID } from "../control-plane/schema"
-import { Timestamps } from "../storage/schema.sql"
-
-type PartData = Omit<MessageV2.Part, "id" | "sessionID" | "messageID">
-type InfoData = Omit<MessageV2.Info, "id" | "sessionID">
-
-export const SessionTable = sqliteTable(
-  "session",
-  {
-    id: text().$type<SessionID>().primaryKey(),
-    project_id: text()
-      .$type<ProjectID>()
-      .notNull()
-      .references(() => ProjectTable.id, { onDelete: "cascade" }),
-    workspace_id: text().$type<WorkspaceID>(),
-    parent_id: text().$type<SessionID>(),
-    slug: text().notNull(),
-    directory: text().notNull(),
-    title: text().notNull(),
-    version: text().notNull(),
-    share_url: text(),
-    summary_additions: integer(),
-    summary_deletions: integer(),
-    summary_files: integer(),
-    summary_diffs: text({ mode: "json" }).$type<Snapshot.FileDiff[]>(),
-    revert: text({ mode: "json" }).$type<{ messageID: MessageID; partID?: PartID; snapshot?: string; diff?: string }>(),
-    permission: text({ mode: "json" }).$type<Permission.Ruleset>(),
-    ...Timestamps,
-    time_compacting: integer(),
-    time_archived: integer(),
-  },
-  (table) => [
-    index("session_project_idx").on(table.project_id),
-    index("session_workspace_idx").on(table.workspace_id),
-    index("session_parent_idx").on(table.parent_id),
-  ],
-)
-
-export const MessageTable = sqliteTable(
-  "message",
-  {
-    id: text().$type<MessageID>().primaryKey(),
-    session_id: text()
-      .$type<SessionID>()
-      .notNull()
-      .references(() => SessionTable.id, { onDelete: "cascade" }),
-    ...Timestamps,
-    data: text({ mode: "json" }).notNull().$type<InfoData>(),
-  },
-  (table) => [index("message_session_time_created_id_idx").on(table.session_id, table.time_created, table.id)],
-)
-
-export const PartTable = sqliteTable(
-  "part",
-  {
-    id: text().$type<PartID>().primaryKey(),
-    message_id: text()
-      .$type<MessageID>()
-      .notNull()
-      .references(() => MessageTable.id, { onDelete: "cascade" }),
-    session_id: text().$type<SessionID>().notNull(),
-    ...Timestamps,
-    data: text({ mode: "json" }).notNull().$type<PartData>(),
-  },
-  (table) => [
-    index("part_message_id_id_idx").on(table.message_id, table.id),
-    index("part_session_idx").on(table.session_id),
-  ],
-)
-
-export const TodoTable = sqliteTable(
-  "todo",
-  {
-    session_id: text()
-      .$type<SessionID>()
-      .notNull()
-      .references(() => SessionTable.id, { onDelete: "cascade" }),
-    content: text().notNull(),
-    status: text().notNull(),
-    priority: text().notNull(),
-    position: integer().notNull(),
-    ...Timestamps,
-  },
-  (table) => [
-    primaryKey({ columns: [table.session_id, table.position] }),
-    index("todo_session_idx").on(table.session_id),
-  ],
-)
-
-export const PermissionTable = sqliteTable("permission", {
-  project_id: text()
-    .primaryKey()
-    .references(() => ProjectTable.id, { onDelete: "cascade" }),
-  ...Timestamps,
-  data: text({ mode: "json" }).notNull().$type<Permission.Ruleset>(),
-})

package/packages/opencode/src/session/status.ts

@@ -1,102 +0,0 @@
-import { BusEvent } from "@/bus/bus-event"
-import { Bus } from "@/bus"
-import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
-import { SessionID } from "./schema"
-import { Effect, Layer, ServiceMap } from "effect"
-import z from "zod"
-
-export namespace SessionStatus {
-  export const Info = z
-    .union([
-      z.object({
-        type: z.literal("idle"),
-      }),
-      z.object({
-        type: z.literal("retry"),
-        attempt: z.number(),
-        message: z.string(),
-        next: z.number(),
-      }),
-      z.object({
-        type: z.literal("busy"),
-      }),
-    ])
-    .meta({
-      ref: "SessionStatus",
-    })
-  export type Info = z.infer<typeof Info>
-
-  export const Event = {
-    Status: BusEvent.define(
-      "session.status",
-      z.object({
-        sessionID: SessionID.zod,
-        status: Info,
-      }),
-    ),
-    // deprecated
-    Idle: BusEvent.define(
-      "session.idle",
-      z.object({
-        sessionID: SessionID.zod,
-      }),
-    ),
-  }
-
-  export interface Interface {
-    readonly get: (sessionID: SessionID) => Effect.Effect<Info>
-    readonly list: () => Effect.Effect<Map<SessionID, Info>>
-    readonly set: (sessionID: SessionID, status: Info) => Effect.Effect<void>
-  }
-
-  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/SessionStatus") {}
-
-  export const layer = Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const bus = yield* Bus.Service
-
-      const state = yield* InstanceState.make(
-        Effect.fn("SessionStatus.state")(() => Effect.succeed(new Map<SessionID, Info>())),
-      )
-
-      const get = Effect.fn("SessionStatus.get")(function* (sessionID: SessionID) {
-        const data = yield* InstanceState.get(state)
-        return data.get(sessionID) ?? { type: "idle" as const }
-      })
-
-      const list = Effect.fn("SessionStatus.list")(function* () {
-        return new Map(yield* InstanceState.get(state))
-      })
-
-      const set = Effect.fn("SessionStatus.set")(function* (sessionID: SessionID, status: Info) {
-        const data = yield* InstanceState.get(state)
-        yield* bus.publish(Event.Status, { sessionID, status })
-        if (status.type === "idle") {
-          yield* bus.publish(Event.Idle, { sessionID })
-          data.delete(sessionID)
-          return
-        }
-        data.set(sessionID, status)
-      })
-
-      return Service.of({ get, list, set })
-    }),
-  )
-
-  const defaultLayer = layer.pipe(Layer.provide(Bus.layer))
-  const { runPromise } = makeRuntime(Service, defaultLayer)
-
-  export async function get(sessionID: SessionID) {
-    return runPromise((svc) => svc.get(sessionID))
-  }
-
-  export async function list() {
-    return runPromise((svc) => svc.list())
-  }
-
-  export async function set(sessionID: SessionID, status: Info) {
-    return runPromise((svc) => svc.set(sessionID, status))
-  }
-}