saeeol 1.2.0 → 1.2.1

package/src/session/core/projectors.ts

@@ -0,0 +1,139 @@
+import { NotFoundError } from "@/storage/storage"
+import { eq } from "drizzle-orm"
+import { and } from "drizzle-orm"
+import { SyncEvent } from "@/sync"
+import * as Session from "./session"
+import { MessageV2 } from "../message/message-v2"
+import { SessionTable, MessageTable, PartTable } from "./session.sql"
+import * as Log from "@saeeol/core/util/log"
+
+const log = Log.create({ service: "session.projector" })
+
+function foreign(err: unknown) {
+  if (typeof err !== "object" || err === null) return false
+  if ("code" in err && err.code === "SQLITE_CONSTRAINT_FOREIGNKEY") return true
+  return "message" in err && typeof err.message === "string" && err.message.includes("FOREIGN KEY constraint failed")
+}
+
+export type DeepPartial<T> = T extends object ? { [K in keyof T]?: DeepPartial<T[K]> | null } : T
+
+function grab<T extends object, K1 extends keyof T, X>(
+  obj: T,
+  field1: K1,
+  cb?: (val: NonNullable<T[K1]>) => X,
+): X | undefined {
+  if (obj == undefined || !(field1 in obj)) return undefined
+
+  const val = obj[field1]
+  if (val && typeof val === "object" && cb) {
+    return cb(val)
+  }
+  if (val === undefined) {
+    throw new Error(
+      "Session update failure: pass `null` to clear a field instead of `undefined`: " + JSON.stringify(obj),
+    )
+  }
+  return val as X | undefined
+}
+
+export function toPartialRow(info: DeepPartial<Session.Info>) {
+  const obj = {
+    id: grab(info, "id"),
+    project_id: grab(info, "projectID"),
+    workspace_id: grab(info, "workspaceID"),
+    parent_id: grab(info, "parentID"),
+    slug: grab(info, "slug"),
+    directory: grab(info, "directory"),
+    path: grab(info, "path"),
+    title: grab(info, "title"),
+    version: grab(info, "version"),
+    share_url: grab(info, "share", (v) => grab(v, "url")),
+    summary_additions: grab(info, "summary", (v) => grab(v, "additions")),
+    summary_deletions: grab(info, "summary", (v) => grab(v, "deletions")),
+    summary_files: grab(info, "summary", (v) => grab(v, "files")),
+    summary_diffs: grab(info, "summary", (v) => grab(v, "diffs")),
+    revert: grab(info, "revert"),
+    permission: grab(info, "permission"),
+    time_created: grab(info, "time", (v) => grab(v, "created")),
+    time_updated: grab(info, "time", (v) => grab(v, "updated")),
+    time_compacting: grab(info, "time", (v) => grab(v, "compacting")),
+    time_archived: grab(info, "time", (v) => grab(v, "archived")),
+  }
+
+  return Object.fromEntries(Object.entries(obj).filter(([_, val]) => val !== undefined))
+}
+
+export default [
+  SyncEvent.project(Session.Event.Created, (db, data) => {
+    db.insert(SessionTable)
+      .values(Session.toRow(data.info as Session.Info))
+      .run()
+  }),
+
+  SyncEvent.project(Session.Event.Updated, (db, data) => {
+    const info = data.info
+    const row = db
+      .update(SessionTable)
+      .set(toPartialRow(info as Session.Patch))
+      .where(eq(SessionTable.id, data.sessionID))
+      .returning()
+      .get()
+    if (!row) throw new NotFoundError({ message: `Session not found: ${data.sessionID}` })
+  }),
+
+  SyncEvent.project(Session.Event.Deleted, (db, data) => {
+    db.delete(SessionTable).where(eq(SessionTable.id, data.sessionID)).run()
+  }),
+
+  SyncEvent.project(MessageV2.Event.Updated, (db, data) => {
+    const time_created = data.info.time.created
+    const { id, sessionID, ...rest } = data.info
+
+    try {
+      db.insert(MessageTable)
+        .values({
+          id,
+          session_id: sessionID,
+          time_created,
+          data: rest,
+        })
+        .onConflictDoUpdate({ target: MessageTable.id, set: { data: rest } })
+        .run()
+    } catch (err) {
+      if (!foreign(err)) throw err
+      log.warn("ignored late message update", { messageID: id, sessionID })
+    }
+  }),
+
+  SyncEvent.project(MessageV2.Event.Removed, (db, data) => {
+    db.delete(MessageTable)
+      .where(and(eq(MessageTable.id, data.messageID), eq(MessageTable.session_id, data.sessionID)))
+      .run()
+  }),
+
+  SyncEvent.project(MessageV2.Event.PartRemoved, (db, data) => {
+    db.delete(PartTable)
+      .where(and(eq(PartTable.id, data.partID), eq(PartTable.session_id, data.sessionID)))
+      .run()
+  }),
+
+  SyncEvent.project(MessageV2.Event.PartUpdated, (db, data) => {
+    const { id, messageID, sessionID, ...rest } = data.part
+
+    try {
+      db.insert(PartTable)
+        .values({
+          id,
+          message_id: messageID,
+          session_id: sessionID,
+          time_created: data.time,
+          data: rest,
+        })
+        .onConflictDoUpdate({ target: PartTable.id, set: { data: rest } })
+        .run()
+    } catch (err) {
+      if (!foreign(err)) throw err
+      log.warn("ignored late part update", { partID: id, messageID, sessionID })
+    }
+  }),
+]

package/src/session/core/resolve-tools.ts

@@ -0,0 +1,241 @@
+import { type Tool as AITool, tool, jsonSchema, type ToolExecutionOptions, asSchema } from "ai"
+import { Effect, Context, Layer } from "effect"
+import * as EffectZod from "@/util/effect-zod"
+import { ModelID, ProviderID } from "../../provider/schema"
+import { SessionID, PartID } from "./schema"
+import { MessageV2 } from "../message/message-v2"
+import * as Session from "./session"
+import { Agent } from "../../agent/agent"
+import { Provider } from "@/provider/provider"
+import { ProviderTransform } from "@/provider/transform"
+import { ToolRegistry } from "@/tool/registry"
+import { MCP } from "../../mcp"
+import { Plugin } from "../../plugin"
+import { Permission } from "@/permission"
+import { Truncate } from "@/tool/truncate"
+import { SessionProcessor } from "./processor"
+import { SaeeolSessionPrompt } from "@/saeeol/session/prompt" 
+import { EffectBridge } from "@/effect/bridge"
+import { Tool } from "@/tool/tool"
+import { type TaskPromptOps } from "@/tool/task"
+import * as Log from "@saeeol/core/util/log"
+
+const log = Log.create({ service: "session.resolve-tools" })
+
+export interface ResolveToolsInput {
+  agent: Agent.Info
+  model: Provider.Model
+  session: Session.Info
+  tools?: Record<string, boolean>
+  processor: Pick<SessionProcessor.Handle, "message" | "updateToolCall" | "completeToolCall">
+  bypassAgentCheck: boolean
+  messages: MessageV2.WithParts[]
+}
+
+export interface Interface {
+  readonly resolve: (input: ResolveToolsInput) => Effect.Effect<Record<string, AITool>>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@saeeol/SessionResolveTools") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const registry = yield* ToolRegistry.Service
+    const plugin = yield* Plugin.Service
+    const permission = yield* Permission.Service
+    const mcp = yield* MCP.Service
+    const truncate = yield* Truncate.Service
+
+    const resolve = Effect.fn("SessionResolveTools.resolve")(function* (input: ResolveToolsInput) {
+      using _ = log.time("resolveTools")
+      const tools: Record<string, AITool> = {}
+      const bridge = yield* EffectBridge.make()
+      const promptOps: TaskPromptOps = {
+        cancel: (sessionID: SessionID) => Effect.void,
+        resolvePromptParts: (template: string) => Effect.succeed([{ type: "text" as const, text: template }]) as any,
+        prompt: (_input: any) => Effect.fail(new Error("not available")) as any,
+      }
+
+      const context = (args: any, options: ToolExecutionOptions): Tool.Context => ({
+        sessionID: input.session.id,
+        abort: options.abortSignal!,
+        messageID: input.processor.message.id,
+        callID: options.toolCallId,
+        extra: { model: input.model, bypassAgentCheck: input.bypassAgentCheck, promptOps },
+        agent: input.agent.name,
+        messages: input.messages,
+        metadata: (val: any) =>
+          input.processor.updateToolCall(options.toolCallId, (match) => {
+            if (!["running", "pending"].includes(match.state.status)) return match
+            return {
+              ...match,
+              state: {
+                title: val.title,
+                metadata: val.metadata,
+                status: "running",
+                input: args,
+                time: { start: Date.now() },
+              },
+            }
+          }),
+        ask: (req: any) =>
+          permission
+            .ask({
+              ...req,
+              sessionID: input.session.id,
+              tool: { messageID: input.processor.message.id, callID: options.toolCallId },
+              ruleset: Permission.merge(
+                input.agent.permission,
+                SaeeolSessionPrompt.guardPermissions({ agent: input.agent, session: input.session }),
+              ),
+              hardRuleset: SaeeolSessionPrompt.hardPermissions({ agent: input.agent }),
+            })
+            .pipe(Effect.orDie),
+      })
+
+      for (const item of yield* registry.tools({
+        modelID: ModelID.make(input.model.api.id),
+        providerID: input.model.providerID,
+        agent: input.agent,
+      })) {
+        const schema = ProviderTransform.schema(input.model, EffectZod.toJsonSchema(item.parameters))
+        tools[item.id] = tool({
+          description: item.description,
+          inputSchema: jsonSchema(schema),
+          execute(args, options) {
+            return bridge.promise(
+              Effect.gen(function* () {
+                const ctx = context(args, options)
+                yield* plugin.trigger(
+                  "tool.execute.before",
+                  { tool: item.id, sessionID: ctx.sessionID, callID: ctx.callID },
+                  { args },
+                )
+                const result = yield* item.execute(args, ctx)
+                const output = {
+                  ...result,
+                  attachments: result.attachments?.map((attachment) => ({
+                    ...attachment,
+                    id: PartID.ascending(),
+                    sessionID: ctx.sessionID,
+                    messageID: input.processor.message.id,
+                  })),
+                }
+                yield* plugin.trigger(
+                  "tool.execute.after",
+                  { tool: item.id, sessionID: ctx.sessionID, callID: ctx.callID, args },
+                  output,
+                )
+                if (options.abortSignal?.aborted) {
+                  yield* input.processor.completeToolCall(options.toolCallId, output)
+                }
+                return output
+              }),
+            )
+          },
+        })
+      }
+
+      for (const [key, item] of Object.entries(yield* mcp.tools())) {
+        const execute = item.execute
+        if (!execute) continue
+        const schema = yield* Effect.promise(() => Promise.resolve(asSchema(item.inputSchema).jsonSchema))
+        const transformed = ProviderTransform.schema(input.model, schema)
+        item.inputSchema = jsonSchema(transformed)
+        item.execute = (args, opts) =>
+          bridge.promise(
+            Effect.gen(function* () {
+              const ctx = context(args, opts)
+              yield* plugin.trigger(
+                "tool.execute.before",
+                { tool: key, sessionID: ctx.sessionID, callID: opts.toolCallId },
+                { args },
+              )
+              const result: Awaited<ReturnType<NonNullable<typeof execute>>> = yield* Effect.gen(function* () {
+                yield* ctx.ask({ permission: key, metadata: {}, patterns: ["*"], always: ["*"] })
+                return yield* Effect.promise(() => execute(args, opts))
+              }).pipe(
+                Effect.withSpan("Tool.execute", {
+                  attributes: {
+                    "tool.name": key,
+                    "tool.call_id": opts.toolCallId,
+                    "session.id": ctx.sessionID,
+                    "message.id": input.processor.message.id,
+                  },
+                }),
+              )
+              yield* plugin.trigger(
+                "tool.execute.after",
+                { tool: key, sessionID: ctx.sessionID, callID: opts.toolCallId, args },
+                result,
+              )
+
+              const textParts: string[] = []
+              const attachments: Omit<MessageV2.FilePart, "id" | "sessionID" | "messageID">[] = []
+              for (const contentItem of result.content) {
+                if (contentItem.type === "text") textParts.push(contentItem.text)
+                else if (contentItem.type === "image") {
+                  attachments.push({
+                    type: "file",
+                    mime: contentItem.mimeType,
+                    url: `data:${contentItem.mimeType};base64,${contentItem.data}`,
+                  })
+                } else if (contentItem.type === "resource") {
+                  const { resource } = contentItem
+                  if (resource.text) textParts.push(resource.text)
+                  if (resource.blob) {
+                    attachments.push({
+                      type: "file",
+                      mime: resource.mimeType ?? "application/octet-stream",
+                      url: `data:${resource.mimeType ?? "application/octet-stream"};base64,${resource.blob}`,
+                      filename: resource.uri,
+                    })
+                  }
+                }
+              }
+
+              const truncated = yield* truncate.output(textParts.join("\n\n"), {}, input.agent)
+              const metadata = {
+                ...result.metadata,
+                truncated: truncated.truncated,
+                ...(truncated.truncated && { outputPath: truncated.outputPath }),
+              }
+              const output = {
+                title: "",
+                metadata,
+                output: truncated.content,
+                attachments: attachments.map((attachment) => ({
+                  ...attachment,
+                  id: PartID.ascending(),
+                  sessionID: ctx.sessionID,
+                  messageID: input.processor.message.id,
+                })),
+                content: result.content,
+              }
+              if (opts.abortSignal?.aborted) {
+                yield* input.processor.completeToolCall(opts.toolCallId, output)
+              }
+              return output
+            }),
+          )
+        tools[key] = item
+      }
+
+      return tools
+    })
+
+    return { resolve }
+  }),
+)
+
+export const defaultLayer = Layer.suspend(() =>
+  layer.pipe(
+    Layer.provide(ToolRegistry.defaultLayer),
+    Layer.provide(MCP.defaultLayer),
+    Layer.provide(Plugin.defaultLayer),
+    Layer.provide(Permission.defaultLayer),
+    Layer.provide(Truncate.defaultLayer),
+    Layer.provide(Provider.defaultLayer),
+  ),
+)

package/src/session/core/retry.ts

@@ -0,0 +1,149 @@
+import type { NamedError } from "@saeeol/core/util/error"
+import { Cause, Clock, Duration, Effect, Schedule } from "effect"
+import { MessageV2 } from "../message/message-v2"
+import { isSaeeolError } from "@/saeeol/errors" 
+import { SessionNetwork } from "./network" 
+import { iife } from "@/util/iife"
+
+export type Err = ReturnType<NamedError["toObject"]>
+
+// This exported message is shared with the TUI upsell detector. Matching on a
+// literal error string kind of sucks, but it is the simplest for now.
+export const GO_UPSELL_MESSAGE = "Free usage exceeded, subscribe to Go https://saeeol.ai/go"
+
+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)) {
+    const status = error.data.statusCode
+    if (isSaeeolError(error)) return undefined
+
+    // 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
+    // capped model is futile and the backoff loop cannot be broken by switching
+    // models in the chat selector (the retry loop holds a stale model ref).
+    if (error.data.responseBody?.includes("FreeUsageLimitError")) return undefined
+    return error.data.message.includes("Overloaded") ? "Provider is overloaded" : error.data.message
+  }
+
+  // Check for rate limit patterns in plain text error messages
+  const msg = error.data?.message
+  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 msg
+    }
+  }
+
+  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>
+  limit?: number
+  offline?: (input: { error: unknown; message: string }) => Effect.Effect<"retry" | "blocked" | "aborted">
+}) {
+  return Schedule.fromStepWithMetadata(
+    Effect.succeed((meta: Schedule.InputMetadata<unknown>) => {
+      if (opts.limit !== undefined && meta.attempt > opts.limit) {
+        return Cause.done(meta.attempt)
+      }
+
+      const error = opts.parse(meta.input)
+      const message = retryable(error)
+      if (!message) return Cause.done(meta.attempt)
+      return Effect.gen(function* () {
+        if (opts.offline && SessionNetwork.disconnected(meta.input)) {
+          const result = yield* opts.offline({
+            error: meta.input,
+            message: SessionNetwork.message(meta.input),
+          })
+          if (result !== "retry") {
+            return yield* Cause.done(meta.attempt)
+          }
+          yield* opts.set({ attempt: 0, message: "Reconnected", next: Date.now() })
+          return [0, Duration.zero] as [number, Duration.Duration]
+        }
+
+        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]
+      })
+    }),
+  )
+}
+
+export * as SessionRetry from "./retry"