@bloxystudios/bloxycode 1.0.0

package/src/session/compaction.ts

@@ -0,0 +1,225 @@
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import { Session } from "."
+import { Identifier } from "../id/id"
+import { Instance } from "../project/instance"
+import { Provider } from "../provider/provider"
+import { MessageV2 } from "./message-v2"
+import z from "zod"
+import { SessionPrompt } from "./prompt"
+import { Token } from "../util/token"
+import { Log } from "../util/log"
+import { SessionProcessor } from "./processor"
+import { fn } from "@/util/fn"
+import { Agent } from "@/agent/agent"
+import { Plugin } from "@/plugin"
+import { Config } from "@/config/config"
+
+export namespace SessionCompaction {
+  const log = Log.create({ service: "session.compaction" })
+
+  export const Event = {
+    Compacted: BusEvent.define(
+      "session.compacted",
+      z.object({
+        sessionID: z.string(),
+      }),
+    ),
+  }
+
+  export async function isOverflow(input: { tokens: MessageV2.Assistant["tokens"]; model: Provider.Model }) {
+    const config = await Config.get()
+    if (config.compaction?.auto === false) return false
+    const context = input.model.limit.context
+    if (context === 0) return false
+    const count = input.tokens.input + input.tokens.cache.read + input.tokens.output
+    const output = Math.min(input.model.limit.output, SessionPrompt.OUTPUT_TOKEN_MAX) || SessionPrompt.OUTPUT_TOKEN_MAX
+    const usable = input.model.limit.input || context - output
+    return count > usable
+  }
+
+  export const PRUNE_MINIMUM = 20_000
+  export const PRUNE_PROTECT = 40_000
+
+  const PRUNE_PROTECTED_TOOLS = ["skill"]
+
+  // goes backwards through parts until there are 40_000 tokens worth of tool
+  // calls. then erases output of previous tool calls. idea is to throw away old
+  // tool calls that are no longer relevant.
+  export async function prune(input: { sessionID: string }) {
+    const config = await Config.get()
+    if (config.compaction?.prune === false) return
+    log.info("pruning")
+    const msgs = await Session.messages({ sessionID: input.sessionID })
+    let total = 0
+    let pruned = 0
+    const toPrune = []
+    let turns = 0
+
+    loop: for (let msgIndex = msgs.length - 1; msgIndex >= 0; msgIndex--) {
+      const msg = msgs[msgIndex]
+      if (msg.info.role === "user") turns++
+      if (turns < 2) continue
+      if (msg.info.role === "assistant" && msg.info.summary) break loop
+      for (let partIndex = msg.parts.length - 1; partIndex >= 0; partIndex--) {
+        const part = msg.parts[partIndex]
+        if (part.type === "tool")
+          if (part.state.status === "completed") {
+            if (PRUNE_PROTECTED_TOOLS.includes(part.tool)) continue
+
+            if (part.state.time.compacted) break loop
+            const estimate = Token.estimate(part.state.output)
+            total += estimate
+            if (total > PRUNE_PROTECT) {
+              pruned += estimate
+              toPrune.push(part)
+            }
+          }
+      }
+    }
+    log.info("found", { pruned, total })
+    if (pruned > PRUNE_MINIMUM) {
+      for (const part of toPrune) {
+        if (part.state.status === "completed") {
+          part.state.time.compacted = Date.now()
+          await Session.updatePart(part)
+        }
+      }
+      log.info("pruned", { count: toPrune.length })
+    }
+  }
+
+  export async function process(input: {
+    parentID: string
+    messages: MessageV2.WithParts[]
+    sessionID: string
+    abort: AbortSignal
+    auto: boolean
+  }) {
+    const userMessage = input.messages.findLast((m) => m.info.id === input.parentID)!.info as MessageV2.User
+    const agent = await Agent.get("compaction")
+    const model = agent.model
+      ? await Provider.getModel(agent.model.providerID, agent.model.modelID)
+      : await Provider.getModel(userMessage.model.providerID, userMessage.model.modelID)
+    const msg = (await Session.updateMessage({
+      id: Identifier.ascending("message"),
+      role: "assistant",
+      parentID: input.parentID,
+      sessionID: input.sessionID,
+      mode: "compaction",
+      agent: "compaction",
+      summary: true,
+      path: {
+        cwd: Instance.directory,
+        root: Instance.worktree,
+      },
+      cost: 0,
+      tokens: {
+        output: 0,
+        input: 0,
+        reasoning: 0,
+        cache: { read: 0, write: 0 },
+      },
+      modelID: model.id,
+      providerID: model.providerID,
+      time: {
+        created: Date.now(),
+      },
+    })) as MessageV2.Assistant
+    const processor = SessionProcessor.create({
+      assistantMessage: msg,
+      sessionID: input.sessionID,
+      model,
+      abort: input.abort,
+    })
+    // Allow plugins to inject context or replace compaction prompt
+    const compacting = await Plugin.trigger(
+      "experimental.session.compacting",
+      { sessionID: input.sessionID },
+      { context: [], prompt: undefined },
+    )
+    const defaultPrompt =
+      "Provide a detailed prompt for continuing our conversation above. Focus on information that would be helpful for continuing the conversation, including what we did, what we're doing, which files we're working on, and what we're going to do next considering new session will not have access to our conversation."
+    const promptText = compacting.prompt ?? [defaultPrompt, ...compacting.context].join("\n\n")
+    const result = await processor.process({
+      user: userMessage,
+      agent,
+      abort: input.abort,
+      sessionID: input.sessionID,
+      tools: {},
+      system: [],
+      messages: [
+        ...MessageV2.toModelMessages(input.messages, model),
+        {
+          role: "user",
+          content: [
+            {
+              type: "text",
+              text: promptText,
+            },
+          ],
+        },
+      ],
+      model,
+    })
+
+    if (result === "continue" && input.auto) {
+      const continueMsg = await Session.updateMessage({
+        id: Identifier.ascending("message"),
+        role: "user",
+        sessionID: input.sessionID,
+        time: {
+          created: Date.now(),
+        },
+        agent: userMessage.agent,
+        model: userMessage.model,
+      })
+      await Session.updatePart({
+        id: Identifier.ascending("part"),
+        messageID: continueMsg.id,
+        sessionID: input.sessionID,
+        type: "text",
+        synthetic: true,
+        text: "Continue if you have next steps",
+        time: {
+          start: Date.now(),
+          end: Date.now(),
+        },
+      })
+    }
+    if (processor.message.error) return "stop"
+    Bus.publish(Event.Compacted, { sessionID: input.sessionID })
+    return "continue"
+  }
+
+  export const create = fn(
+    z.object({
+      sessionID: Identifier.schema("session"),
+      agent: z.string(),
+      model: z.object({
+        providerID: z.string(),
+        modelID: z.string(),
+      }),
+      auto: z.boolean(),
+    }),
+    async (input) => {
+      const msg = await Session.updateMessage({
+        id: Identifier.ascending("message"),
+        role: "user",
+        model: input.model,
+        sessionID: input.sessionID,
+        agent: input.agent,
+        time: {
+          created: Date.now(),
+        },
+      })
+      await Session.updatePart({
+        id: Identifier.ascending("part"),
+        messageID: msg.id,
+        sessionID: msg.sessionID,
+        type: "compaction",
+        auto: input.auto,
+      })
+    },
+  )
+}

package/src/session/fallback.ts

@@ -0,0 +1,246 @@
+import { Provider } from "../provider/provider"
+import { Log } from "../util/log"
+
+export namespace SessionFallback {
+  const log = Log.create({ service: "session.fallback" })
+
+  export interface RateLimitInfo {
+    providerID: string
+    resetAt: number // timestamp when limit resets
+    reason: string
+  }
+
+  export interface ProviderModel {
+    providerID: string
+    modelID: string
+  }
+
+  export interface ModelCapabilities {
+    toolcall?: boolean
+    attachment?: boolean
+    reasoning?: boolean
+  }
+
+  // In-memory state tracking rate-limited providers
+  const rateLimited = new Map<string, RateLimitInfo>()
+
+  /**
+   * Parse reset time from various header formats
+   * Returns timestamp in milliseconds when the rate limit resets
+   */
+  export function parseResetTime(headers?: Record<string, string>): number | null {
+    if (!headers) return null
+
+    // Check x-ratelimit-reset (Unix timestamp in seconds)
+    const xRateLimitReset = headers["x-ratelimit-reset"]
+    if (xRateLimitReset) {
+      const timestamp = Number.parseInt(xRateLimitReset, 10)
+      if (!Number.isNaN(timestamp)) {
+        // If it's a reasonable Unix timestamp (after year 2020)
+        if (timestamp > 1577836800) {
+          return timestamp * 1000 // Convert seconds to ms
+        }
+      }
+    }
+
+    // Check x-ratelimit-reset-requests (seconds until reset)
+    const xRateLimitResetRequests = headers["x-ratelimit-reset-requests"]
+    if (xRateLimitResetRequests) {
+      // Parse formats like "1s", "2m30s", "1h"
+      const match = xRateLimitResetRequests.match(/(?:(\d+)h)?(?:(\d+)m)?(?:(\d+(?:\.\d+)?)s)?/)
+      if (match) {
+        const hours = Number.parseInt(match[1] || "0", 10)
+        const minutes = Number.parseInt(match[2] || "0", 10)
+        const seconds = Number.parseFloat(match[3] || "0")
+        const totalMs = (hours * 3600 + minutes * 60 + seconds) * 1000
+        if (totalMs > 0) {
+          return Date.now() + totalMs
+        }
+      }
+    }
+
+    // Check retry-after-ms (milliseconds)
+    const retryAfterMs = headers["retry-after-ms"]
+    if (retryAfterMs) {
+      const ms = Number.parseFloat(retryAfterMs)
+      if (!Number.isNaN(ms) && ms > 0) {
+        return Date.now() + ms
+      }
+    }
+
+    // Check retry-after (seconds or HTTP-date)
+    const retryAfter = headers["retry-after"]
+    if (retryAfter) {
+      // Try as seconds
+      const seconds = Number.parseFloat(retryAfter)
+      if (!Number.isNaN(seconds) && seconds > 0) {
+        return Date.now() + seconds * 1000
+      }
+      // Try as HTTP-date
+      const parsed = Date.parse(retryAfter)
+      if (!Number.isNaN(parsed) && parsed > Date.now()) {
+        return parsed
+      }
+    }
+
+    return null
+  }
+
+  /**
+   * Mark a provider as rate-limited
+   */
+  export function markRateLimited(
+    providerID: string,
+    reason: string,
+    headers?: Record<string, string>,
+  ): void {
+    const resetAt = parseResetTime(headers) ?? Date.now() + 60_000 // Default: 1 minute
+
+    rateLimited.set(providerID, {
+      providerID,
+      resetAt,
+      reason,
+    })
+
+    log.info("Provider marked as rate-limited", {
+      providerID,
+      reason,
+      resetAt: new Date(resetAt).toISOString(),
+      waitMs: resetAt - Date.now(),
+    })
+  }
+
+  /**
+   * Check if a provider is currently rate-limited
+   */
+  export function isRateLimited(providerID: string): boolean {
+    const info = rateLimited.get(providerID)
+    if (!info) return false
+
+    // Check if rate limit has expired
+    if (Date.now() >= info.resetAt) {
+      rateLimited.delete(providerID)
+      log.info("Rate limit expired", { providerID })
+      return false
+    }
+
+    return true
+  }
+
+  /**
+   * Clear rate limit status for a provider
+   */
+  export function clearRateLimit(providerID: string): void {
+    if (rateLimited.delete(providerID)) {
+      log.info("Cleared rate limit", { providerID })
+    }
+  }
+
+  /**
+   * Clear all expired rate limits
+   */
+  export function clearExpiredLimits(): void {
+    const now = Date.now()
+    for (const [providerID, info] of rateLimited) {
+      if (now >= info.resetAt) {
+        rateLimited.delete(providerID)
+        log.info("Cleared expired rate limit", { providerID })
+      }
+    }
+  }
+
+  /**
+   * Get all currently rate-limited providers
+   */
+  export function getRateLimitedProviders(): RateLimitInfo[] {
+    clearExpiredLimits()
+    return Array.from(rateLimited.values())
+  }
+
+  /**
+   * Get earliest reset time across all rate-limited providers
+   * Returns null if no providers are rate-limited
+   */
+  export function getEarliestResetTime(): number | null {
+    clearExpiredLimits()
+
+    if (rateLimited.size === 0) return null
+
+    let earliest = Infinity
+    for (const info of rateLimited.values()) {
+      if (info.resetAt < earliest) {
+        earliest = info.resetAt
+      }
+    }
+
+    return earliest === Infinity ? null : earliest
+  }
+
+  /**
+   * Find the next available provider/model that isn't rate-limited
+   * and has the required capabilities
+   */
+  export async function getNextAvailable(
+    currentProviderID: string,
+    capabilities?: ModelCapabilities,
+  ): Promise<ProviderModel | null> {
+    clearExpiredLimits()
+
+    const providers = await Provider.list()
+
+    for (const [providerID, provider] of Object.entries(providers)) {
+      // Skip current provider
+      if (providerID === currentProviderID) continue
+
+      // Skip rate-limited providers
+      if (isRateLimited(providerID)) continue
+
+      // Find a model with required capabilities
+      for (const [modelID, model] of Object.entries(provider.models)) {
+        // Check capabilities if specified
+        if (capabilities) {
+          if (capabilities.toolcall && !model.capabilities.toolcall) continue
+          if (capabilities.attachment && !model.capabilities.attachment) continue
+          if (capabilities.reasoning && !model.capabilities.reasoning) continue
+        }
+
+        log.info("Found alternative provider", {
+          from: currentProviderID,
+          to: providerID,
+          model: modelID,
+        })
+
+        return { providerID, modelID }
+      }
+    }
+
+    log.info("No alternative providers available", {
+      currentProviderID,
+      rateLimited: Array.from(rateLimited.keys()),
+    })
+
+    return null
+  }
+
+  /**
+   * Check if all configured providers are rate-limited
+   */
+  export async function allProvidersRateLimited(): Promise<boolean> {
+    clearExpiredLimits()
+
+    const providers = await Provider.list()
+    const providerIDs = Object.keys(providers)
+
+    if (providerIDs.length === 0) return false
+
+    return providerIDs.every((id) => isRateLimited(id))
+  }
+
+  /**
+   * Reset all rate limit tracking (useful for new sessions)
+   */
+  export function reset(): void {
+    rateLimited.clear()
+    log.info("Reset all rate limit tracking")
+  }
+}