saeeol 1.4.1 → 1.4.3

package/src/overlay/session/llm.ts

@@ -1,53 +0,0 @@
-import type { ModelMessage } from "ai"
-import type { Provider } from "@/provider/provider"
-import { Token } from "@/util/token"
-
-// Token.estimate consistently under-counts by ~15-30% vs. actual provider tokenizers.
-// Multiply all estimates by this factor and add a fixed safety margin to compensate.
-const ESTIMATE_FACTOR = 1.3
-const SAFETY = 2048
-const MIN_OUTPUT = 1024
-
-export namespace SaeeolLLM {
-  /**
-   * Caps `maxOutputTokens` to fit within the model's context window after
-   * accounting for the actual estimated input tokens (messages + tool schemas).
-   *
-   * Many small models (e.g. qwen 7B, 32K context) ship with a default
-   * max_output of 32K, leaving no room for input once tools are included.
-   * This prevents the provider from rejecting the request with a context
-   * overflow error.
-   */
-  export function capOutputTokens(input: {
-    model: Provider.Model
-    messages: ModelMessage[]
-    tools: Record<string, { description?: string; inputSchema?: unknown }>
-    configured: number | undefined
-  }): number | undefined {
-    if (input.configured == null) return input.configured
-    if (input.configured <= 0) return undefined
-    const { context } = input.model.limit
-    if (!context) return input.configured
-
-    const msgTokens = Math.ceil(Token.estimate(JSON.stringify(input.messages)) * ESTIMATE_FACTOR)
-    const toolTokens = Math.ceil(
-      Token.estimate(
-        JSON.stringify(
-          Object.entries(input.tools).map(([name, t]) => ({
-            name,
-            description: t.description,
-            inputSchema: t.inputSchema,
-          })),
-        ),
-      ) * ESTIMATE_FACTOR,
-    )
-
-    const available = context - msgTokens - toolTokens - SAFETY
-    // If available is ≤0 the input alone exceeds context — return the original
-    // value so the provider returns a natural overflow error which triggers
-    // compaction (compactionAttempts guard stops the loop eventually).
-    if (available <= 0) return input.configured
-    if (available >= input.configured) return input.configured
-    return Math.max(MIN_OUTPUT, available)
-  }
-}

package/src/overlay/session/overflow.ts

@@ -1,15 +0,0 @@
-import type { Config } from "@/config/config"
-import type { Provider } from "@/provider/provider"
-
-export namespace SaeeolSessionOverflow {
-  export function limit(input: { cfg: Config.Info; model: Provider.Model; usable: number }) {
-    const percent = input.cfg.compaction?.threshold_percent
-    if (typeof percent !== "number") return input.usable
-
-    const context = input.model.limit.input || input.model.limit.context
-    if (context === 0) return input.usable
-
-    const cap = Math.floor(context * (percent / 100))
-    return Math.min(input.usable, cap)
-  }
-}

package/src/overlay/session/platform.ts

@@ -1,97 +0,0 @@
-import { Schema } from "effect"
-import { BusEvent } from "@/bus/bus-event"
-import { SessionID } from "@/session/schema"
-import { ENV_FEATURE } from "@saeeol/gateway"
-
-const CloseReasonSchema = Schema.Literals(["completed", "error", "interrupted"])
-
-const Event = {
-  TurnOpen: BusEvent.define(
-    "session.turn.open",
-    Schema.Struct({
-      sessionID: SessionID,
-    }),
-  ),
-  TurnClose: BusEvent.define(
-    "session.turn.close",
-    Schema.Struct({
-      sessionID: SessionID,
-      reason: CloseReasonSchema,
-    }),
-  ),
-}
-
-type CloseReason = Schema.Schema.Type<typeof CloseReasonSchema>
-
-const overrides = new Map<string, string>()
-const parents = new Map<string, string>()
-const roots = new Map<string, string>()
-
-function register(input: { id: string; parentID?: string; platform?: string }) {
-  const root = input.parentID ? (roots.get(input.parentID) ?? input.parentID) : input.id
-  const platform = input.platform ?? (input.parentID ? resolvePlatform(input.parentID) : undefined)
-
-  roots.set(input.id, root)
-  if (input.parentID) parents.set(input.id, input.parentID)
-  if (platform) overrides.set(input.id, platform)
-}
-
-function setPlatformOverride(id: string, platform: string) {
-  overrides.set(id, platform)
-}
-
-function getPlatformOverride(id: string): string | undefined {
-  return overrides.get(id)
-}
-
-function resolvePlatform(id: string): string | undefined {
-  const override = overrides.get(id)
-  if (override) return override
-  const parent = parents.get(id)
-  if (!parent) return undefined
-  return resolvePlatform(parent)
-}
-
-function resolveRoot(id: string): string {
-  return roots.get(id) ?? id
-}
-
-function featureForPlatform(platform: string | undefined): string | undefined {
-  switch (platform) {
-    case "agent-manager":
-      return "agent-manager"
-    case "vscode":
-      return "vscode-extension"
-    case "cli":
-      return "cli"
-    default:
-      return undefined
-  }
-}
-
-function clearPlatformOverride(id: string) {
-  overrides.delete(id)
-  parents.delete(id)
-  roots.delete(id)
-}
-
-function attribution(id: string): { rootID: string; feature?: string } {
-  const rootID = resolveRoot(id)
-  const platform = resolvePlatform(rootID) ?? process.env["SAEEOL_PLATFORM"]
-  const feature = featureForPlatform(platform) ?? process.env[ENV_FEATURE]
-  return { rootID, ...(feature ? { feature } : {}) }
-}
-
-export {
-  Event,
-  CloseReasonSchema,
-  register,
-  setPlatformOverride,
-  getPlatformOverride,
-  resolvePlatform,
-  resolveRoot,
-  featureForPlatform,
-  clearPlatformOverride,
-  attribution,
-}
-export type { CloseReason }

package/src/overlay/session/processor.ts

@@ -1,200 +0,0 @@
-import { Telemetry } from "@saeeol/telemetry"
-import { SessionNetwork } from "@/session/network"
-import type { SessionID } from "@/session/schema"
-import type { SessionStatus } from "@/session/status"
-import { MessageV2 } from "@/session/message-v2"
-import * as Log from "@saeeol/core/util/log"
-import { Effect } from "effect"
-import { Flag } from "@saeeol/core/flag/flag"
-
-export type ReviewTelemetry = {
-  mode: "review"
-  feature: "code_reviews"
-  command: "review" | "local-review" | "local-review-uncommitted"
-}
-
-export namespace SaeeolSessionProcessor {
-  const log = Log.create({ service: "session.processor.saeeol" })
-  export const OUTPUT_LENGTH_WARNING = "The model hit its output limit, so this response may be incomplete."
-  export const REASONING_LENGTH_WARNING =
-    "The model hit its output limit while reasoning and produced no actionable output. Try disabling reasoning or increasing the output limit."
-  export const PROVIDER_FINISH_ERROR_MESSAGE =
-    "The provider ended the response with an error before returning details. Start a new message to retry; Saeeol will compact the oversized conversation first if needed."
-
-  export function reviewTelemetry(command: string | undefined): ReviewTelemetry | undefined {
-    if (command === "review" || command === "local-review" || command === "local-review-uncommitted") {
-      return { mode: "review", feature: "code_reviews", command }
-    }
-  }
-
-  /**
-   * Tag the text parts of a prompt with review telemetry metadata so that
-   * downstream LLM completions in the same turn (including child sessions
-   * spawned by subtask commands) are attributed to the originating review
-   * command. No-op when the command is not a recognized review command.
-   */
-  export function markReviewTelemetry(
-    parts: Array<{ type: string; metadata?: Record<string, unknown> }>,
-    command: string | undefined,
-  ): ReviewTelemetry | undefined {
-    const tel = reviewTelemetry(command)
-    if (!tel) return
-    for (const part of parts) {
-      if (part.type !== "text") continue
-      part.metadata = { ...part.metadata, ...tel }
-    }
-    return tel
-  }
-
-  export function extractReviewTelemetry(parts: MessageV2.Part[]): ReviewTelemetry | undefined {
-    for (const part of parts) {
-      if (part.type !== "text") continue
-      const meta: Record<string, unknown> | undefined = part.metadata
-      if (!meta) continue
-      if (meta.mode !== "review") continue
-      if (meta.feature !== "code_reviews") continue
-      const tel = reviewTelemetry(typeof meta.command === "string" ? meta.command : undefined)
-      if (tel) return tel
-    }
-  }
-
-  /**
-   * Track LLM completion telemetry for a finished step.
-   * Only fires if at least one token bucket is non-zero.
-   */
-  export function trackStep(input: {
-    sessionID: string
-    model: { providerID: string; id: string }
-    tokens: { input: number; output: number; cache: { read: number; write: number } }
-    cost: number
-    elapsed: number
-    telemetry?: ReviewTelemetry
-  }) {
-    const { tokens } = input
-    if (tokens.input > 0 || tokens.output > 0 || tokens.cache.write > 0 || tokens.cache.read > 0) {
-      Telemetry.trackLlmCompletion({
-        taskId: input.sessionID,
-        ...(input.telemetry ?? {}),
-        apiProvider: input.model.providerID,
-        modelId: input.model.id,
-        inputTokens: tokens.input,
-        outputTokens: tokens.output,
-        cacheReadTokens: tokens.cache.read,
-        cacheWriteTokens: tokens.cache.write,
-        cost: input.cost,
-        completionTime: input.elapsed,
-      })
-    }
-  }
-
-  /**
-   * Effect-based offline handler for the retry schedule.
-   * Shows offline status, waits for network reconnection or user rejection.
-   *
-   * Returns:
-   * - "retry"   → network restored, retry immediately
-   * - "blocked" → user rejected reconnection
-   * - "aborted" → abort signal fired
-   */
-  export function handleOffline(input: {
-    error: unknown
-    sessionID: SessionID
-    abort: AbortSignal
-    set: (sessionID: SessionID, status: SessionStatus.Info) => Effect.Effect<void>
-  }): Effect.Effect<"retry" | "blocked" | "aborted"> {
-    return Effect.gen(function* () {
-      const msg = SessionNetwork.message(input.error)
-
-      const { id, promise } = yield* Effect.promise(() =>
-        SessionNetwork.ask({
-          sessionID: input.sessionID,
-          message: msg,
-          abort: input.abort,
-        }),
-      )
-
-      log.warn("session offline", {
-        sessionID: input.sessionID,
-        requestID: id,
-        message: msg,
-      })
-
-      yield* input.set(input.sessionID, {
-        type: "offline",
-        requestID: id,
-        message: msg,
-      })
-
-      return yield* Effect.promise(() =>
-        promise
-          .then(() => "retry" as const)
-          .catch((err) => {
-            if (err instanceof SessionNetwork.RejectedError) return "blocked" as const
-            if (err instanceof DOMException && err.name === "AbortError") return "aborted" as const
-            throw err
-          }),
-      )
-    })
-  }
-
-  /**
-   * Returns the Saeeol-specific retry policy options (limit + offline handler).
-   * Designed to be spread into SessionRetry.policy() opts.
-   *
-   * The `abort` signal is used by the offline handler to cancel the network
-   * reconnection wait when the session is interrupted.
-   */
-  export function retryOpts(input: {
-    sessionID: SessionID
-    abort: AbortSignal
-    set: (sessionID: SessionID, status: SessionStatus.Info) => Effect.Effect<void>
-  }) {
-    return {
-      limit: Flag.SAEEOL_SESSION_RETRY_LIMIT,
-      offline: (info: { error: unknown; message: string }) =>
-        handleOffline({
-          error: info.error,
-          sessionID: input.sessionID,
-          abort: input.abort,
-          set: input.set,
-        }),
-    }
-  }
-
-  /**
-   * Guard: if finish reason is "tool-calls" but no tool parts exist,
-   * downgrade to "stop" to prevent an infinite loop (#7756).
-   */
-  export function guardEmptyToolCalls(msg: MessageV2.Assistant, parts: MessageV2.Part[]) {
-    if (msg.finish === "tool-calls" && !parts.some((p) => p.type === "tool")) {
-      log.warn("empty tool-calls", { messageID: msg.id })
-      msg.finish = "stop"
-    }
-  }
-
-  export function lengthWarning(input: {
-    msg: MessageV2.Assistant
-    step: { reasoning: boolean; text: boolean; tool: boolean }
-  }) {
-    if (input.msg.summary) return
-    if (input.msg.finish !== "length") return
-    if (input.step.reasoning && !input.step.text && !input.step.tool) {
-      log.warn("reasoning-only length stop", { messageID: input.msg.id })
-      return REASONING_LENGTH_WARNING
-    }
-    log.warn("length stop", { messageID: input.msg.id })
-    return OUTPUT_LENGTH_WARNING
-  }
-
-  export function providerFinishError(msg: MessageV2.Assistant) {
-    if (msg.finish !== "error") return false
-    if (msg.error) return false
-    const err = new MessageV2.APIError({
-      message: PROVIDER_FINISH_ERROR_MESSAGE,
-      isRetryable: true,
-    }).toObject()
-    msg.error = err
-    log.warn("provider finish error", { messageID: msg.id })
-    return err
-  }
-}

package/src/overlay/session/prompt-context.ts

@@ -1,110 +0,0 @@
-import { SessionID, PartID } from "@/session/schema"
-import { MessageV2 } from "@/session/message-v2"
-import { Instance } from "@/project/instance"
-import { Identifier } from "@/id/id"
-import { environmentDetails } from "@/saeeol/editor-context"
-import { StringDecoder } from "string_decoder"
-
-export interface EnvCache {
-  block?: string
-  user?: string
-}
-
-export function injectEditorContext(input: {
-  msgs: MessageV2.WithParts[]
-  lastUser: MessageV2.User
-  sessionID: SessionID
-  cache: EnvCache
-}) {
-  if (input.cache.user !== input.lastUser.id) {
-    const ctx = (() => {
-      try {
-        return Instance.current
-      } catch {
-        return undefined
-      }
-    })()
-    input.cache.block = environmentDetails({
-      ...input.lastUser.editorContext,
-      ...(ctx ? { directory: ctx.directory, worktree: ctx.worktree } : {}),
-    })
-    input.cache.user = input.lastUser.id
-  }
-  if (!input.cache.block) return
-  const idx = input.msgs.findLastIndex((m) => m.info.role === "user")
-  if (idx === -1) return
-  input.msgs[idx] = {
-    ...input.msgs[idx],
-    parts: [
-      ...input.msgs[idx].parts,
-      {
-        id: PartID.make(Identifier.ascending("part")),
-        sessionID: input.sessionID,
-        messageID: input.msgs[idx].info.id,
-        type: "text",
-        text: input.cache.block,
-        synthetic: true,
-      } satisfies MessageV2.TextPart,
-    ],
-  }
-}
-
-export function createShellDecoders() {
-  const stdout = new StringDecoder("utf8")
-  const stderr = new StringDecoder("utf8")
-  return {
-    write(stream: "stdout" | "stderr", chunk: Buffer) {
-      return stream === "stdout" ? stdout.write(chunk) : stderr.write(chunk)
-    },
-    flush() {
-      return stdout.end() + stderr.end()
-    },
-  }
-}
-
-export function hasCompletedSummary(msgs: MessageV2.WithParts[]): boolean {
-  return msgs.some((m) => m.info.role === "assistant" && m.info.summary === true && !!m.info.finish && !m.info.error)
-}
-
-export function trimBeforeLastSummary(msgs: MessageV2.WithParts[]): MessageV2.WithParts[] {
-  for (let i = msgs.length - 1; i >= 0; i--) {
-    const info = msgs[i].info
-    if (info.role !== "assistant" || info.summary !== true || !info.finish || info.error) continue
-    const parentIdx = msgs.findIndex((m) => m.info.id === info.parentID)
-    if (parentIdx === -1) return msgs
-    return parentIdx === 0 ? msgs : msgs.slice(parentIdx)
-  }
-  return msgs
-}
-
-export function stripHistoricalMedia(msgs: MessageV2.WithParts[]): MessageV2.WithParts[] {
-  const cutoff = msgs.findLastIndex(
-    (m) => m.info.role === "user" && m.parts.some((p) => p.type !== "text" || !p.synthetic),
-  )
-  if (cutoff <= 0) return msgs
-  return msgs.map((msg, idx) => {
-    if (idx >= cutoff) return msg
-    const parts = msg.parts.map((part) => {
-      if (part.type === "file" && MessageV2.isMedia(part.mime)) {
-        return {
-          id: part.id,
-          sessionID: part.sessionID,
-          messageID: part.messageID,
-          type: "text" as const,
-          text: `[Attached ${part.mime}: ${part.filename ?? "file"}]`,
-        } satisfies MessageV2.TextPart
-      }
-      if (part.type === "tool" && part.state.status === "completed" && part.state.attachments?.length) {
-        const kept = part.state.attachments.filter((a) => !MessageV2.isMedia(a.mime))
-        if (kept.length === part.state.attachments.length) return part
-        return { ...part, state: { ...part.state, attachments: kept } }
-      }
-      return part
-    })
-    return { ...msg, parts }
-  })
-}
-
-export function maybeStripHistoricalMedia(msgs: MessageV2.WithParts[]): MessageV2.WithParts[] {
-  return hasCompletedSummary(msgs) ? stripHistoricalMedia(msgs) : msgs
-}

package/src/overlay/session/prompt-plan.ts

@@ -1,149 +0,0 @@
-import path from "path"
-import fs from "fs/promises"
-import { Cause, Effect, Exit } from "effect"
-import { SessionID, PartID } from "@/session/schema"
-import { MessageV2 } from "@/session/message-v2"
-import { Session } from "@/session/session"
-import { Instance } from "@/project/instance"
-import type { SessionStatus } from "@/session/status"
-import { Flag } from "@saeeol/core/flag/flag"
-import { PlanFollowup } from "@/saeeol/plan-followup"
-import type { SaeeolSession } from "@/saeeol/session"
-import { Filesystem } from "@/util/filesystem"
-import PROMPT_PLAN from "@/session/prompt/plan.txt"
-import CODE_SWITCH from "@/session/prompt/code-switch.txt"
-
-export function shouldAskPlanFollowup(input: { messages: MessageV2.WithParts[]; abort: AbortSignal }) {
-  if (input.abort.aborted) return false
-  if (!["cli", "vscode"].includes(Flag.SAEEOL_CLIENT)) return false
-  const idx = input.messages.findLastIndex((m) => m.info.role === "user")
-  return input.messages
-    .slice(idx + 1)
-    .some((msg) =>
-      msg.parts.some((p) => p.type === "tool" && p.tool === "plan_exit" && p.state.status === "completed"),
-    )
-}
-
-export async function askPlanFollowup(input: {
-  sessionID: SessionID
-  messages: MessageV2.WithParts[]
-  abort: AbortSignal
-}): Promise<"continue" | "break"> {
-  if (!shouldAskPlanFollowup({ messages: input.messages, abort: input.abort })) return "break"
-  const action = await PlanFollowup.ask({
-    sessionID: input.sessionID,
-    messages: input.messages,
-    abort: input.abort,
-  })
-  return action === "continue" ? "continue" : "break"
-}
-
-export function abortPlanFollowup(sessionID: SessionID) {
-  return PlanFollowup.abort(sessionID)
-}
-
-export const recoverDanglingAssistant = Effect.fn("SaeeolSessionPrompt.recoverDanglingAssistant")(function* (input: {
-  sessionID: SessionID
-  status: Pick<SessionStatus.Interface, "get">
-  sessions: Pick<Session.Interface, "messages" | "removeMessage">
-}) {
-  const state = yield* input.status.get(input.sessionID)
-  if (state.type !== "idle") return
-
-  const msgs = yield* input.sessions.messages({ sessionID: input.sessionID, limit: 2 })
-  const tail = msgs.at(-1)
-  if (!tail || tail.info.role !== "assistant") return
-  if (tail.parts.length > 0 || tail.info.finish || tail.info.error) return
-
-  const prev = msgs.at(-2)
-  if (!prev || prev.info.role !== "user") return
-  if (tail.info.parentID !== prev.info.id) return
-
-  yield* input.sessions.removeMessage({ sessionID: input.sessionID, messageID: tail.info.id })
-})
-
-export const recoverProviderFinishError = Effect.fn("SaeeolSessionPrompt.recoverProviderFinishError")(
-  function* (input: {
-    sessionID: SessionID
-    status: Pick<SessionStatus.Interface, "get">
-    sessions: Pick<Session.Interface, "messages" | "removeMessage">
-  }) {
-    const state = yield* input.status.get(input.sessionID)
-    if (state.type !== "idle") return
-
-    const msgs = yield* input.sessions.messages({ sessionID: input.sessionID, limit: 2 })
-    const tail = msgs.at(-1)
-    if (!tail || tail.info.role !== "assistant") return
-    if (tail.info.finish !== "error" || tail.info.error) return
-    if (!tail.parts.some((part) => part.type === "step-finish" && part.reason === "error")) return
-
-    const prev = msgs.at(-2)
-    if (!prev || prev.info.role !== "user") return
-    if (tail.info.parentID !== prev.info.id) return
-
-    yield* input.sessions.removeMessage({ sessionID: input.sessionID, messageID: tail.info.id })
-  },
-)
-
-export async function ensurePlanDir(dir: string) {
-  if (await Filesystem.isDir(dir)) return
-  await fs.mkdir(dir, { recursive: true })
-}
-
-export async function insertPlanReminders(input: {
-  agent: { name: string }
-  session: Session.Info
-  userMessage: MessageV2.WithParts
-}) {
-  if (input.agent.name !== "plan") return
-  const plan = Session.plan(input.session, Instance.current)
-  const exists = await Filesystem.exists(plan)
-  if (!exists) await ensurePlanDir(path.dirname(plan))
-  const info = 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.`
-  input.userMessage.parts.push({
-    id: PartID.ascending(),
-    messageID: input.userMessage.info.id,
-    sessionID: input.userMessage.info.sessionID,
-    type: "text",
-    text: PROMPT_PLAN + `\n\n## Plan File\n${info}\nThis is the ONLY file you are allowed to write to or edit.`,
-    synthetic: true,
-  })
-}
-
-export const CODE_SWITCH_TEXT = CODE_SWITCH
-
-export function resolveCloseReason(input: {
-  sessionID: string
-  closeReasons: Map<string, SaeeolSession.CloseReason>
-  exit: Exit.Exit<any, any>
-}): SaeeolSession.CloseReason {
-  const explicit = input.closeReasons.get(input.sessionID)
-  input.closeReasons.delete(input.sessionID)
-  if (explicit) return explicit
-  if (Exit.isFailure(input.exit)) {
-    return Cause.hasInterruptsOnly(input.exit.cause) ? "interrupted" : "error"
-  }
-  return "completed"
-}
-
-export const MAX_COMPACTION_ATTEMPTS = 3
-
-export function guardCompactionAttempt(input: {
-  sessionID: string
-  attempts: number
-  closeReasons: Map<string, SaeeolSession.CloseReason>
-  message?: MessageV2.Assistant
-}) {
-  if (input.attempts < MAX_COMPACTION_ATTEMPTS) return { exhausted: false as const }
-  const error = new MessageV2.ContextOverflowError({
-    message: `Compaction exhausted: context still exceeds model limits after ${MAX_COMPACTION_ATTEMPTS} attempts`,
-  }).toObject()
-  input.closeReasons.set(input.sessionID, "error")
-  if (input.message) {
-    input.message.error ??= error
-    input.message.finish ??= "error"
-  }
-  return { exhausted: true as const, error }
-}