@link-assistant/agent 0.0.8

package/src/session/agent.js

@@ -0,0 +1,204 @@
+// Permalink: https://github.com/sst/opencode/blob/main/packages/opencode/src/session/prompt.ts
+// Permalink: https://github.com/sst/opencode/blob/main/packages/opencode/src/session/index.ts
+// Permalink: https://github.com/sst/opencode/blob/main/packages/opencode/src/provider/provider.ts
+
+import { ToolRegistry } from '../tool/registry.ts'
+
+export class Agent {
+  constructor() {
+    // Generate IDs in the same format as opencode
+    const randomId = Math.random().toString(36).substring(2, 15)
+    this.sessionID = `ses_${Date.now().toString(36)}${randomId}`
+    this.messageID = `msg_${Date.now().toString(36)}${randomId}`
+    this.partCounter = 0
+  }
+
+  generatePartId() {
+    return `prt_${Date.now().toString(36)}${Math.random().toString(36).substring(2, 15)}`
+  }
+
+  async process(request) {
+    const message = request.message || "hi"
+    const sessionID = this.sessionID
+
+    // Generate snapshot hash (mock)
+    const snapshot = Math.random().toString(16).substring(2, 42)
+
+    // Emit step_start like opencode
+    this.emitEvent('step_start', {
+      part: {
+        id: this.generatePartId(),
+        sessionID,
+        messageID: this.messageID,
+        type: 'step-start',
+        snapshot
+      }
+    })
+
+    // Check if this is a tool request
+    if (request.tools && request.tools.length > 0) {
+      // Handle tool execution
+      const toolsList = await ToolRegistry.tools('', '')
+      const toolsMap = Object.fromEntries(toolsList.map(t => [t.id, t]))
+      for (const tool of request.tools) {
+        const toolFn = toolsMap[tool.name]
+        if (toolFn) {
+          try {
+            const startTime = Date.now()
+            const callID = `call_${Math.floor(Math.random() * 100000000)}`
+
+            // Create OpenCode-compatible context
+            const ctx = {
+              sessionID,
+              messageID: this.messageID,
+              agent: 'default',
+              callID,
+              abort: new AbortController().signal,
+              metadata: (data) => {
+                // Handle metadata updates during execution
+              }
+            }
+
+            const result = await toolFn.execute(tool.params, ctx)
+            const endTime = Date.now()
+
+            // Emit tool_use event
+            this.emitEvent('tool_use', {
+              part: {
+                id: this.generatePartId(),
+                sessionID,
+                messageID: this.messageID,
+                type: 'tool',
+                callID,
+                tool: tool.name,
+                state: {
+                  status: 'completed',
+                  input: tool.params,
+                  output: result.output,
+                  title: result.title || `${tool.name} ${JSON.stringify(tool.params)}`,
+                  metadata: result.metadata || {
+                    output: result.output,
+                    exit: result.exitCode || 0,
+                    ...(tool.params.description && { description: tool.params.description })
+                  },
+                  time: {
+                    start: startTime,
+                    end: endTime
+                  }
+                }
+              }
+            })
+          } catch (error) {
+            const errorTime = Date.now()
+            const callID = `call_${Math.floor(Math.random() * 100000000)}`
+
+            // Log full error to stderr for debugging
+            console.error('Tool execution error:', error)
+
+            // Emit tool_use event with error
+            this.emitEvent('tool_use', {
+              part: {
+                id: this.generatePartId(),
+                sessionID,
+                messageID: this.messageID,
+                type: 'tool',
+                callID,
+                tool: tool.name,
+                state: {
+                  status: 'error',
+                  input: tool.params,
+                  error: error.message || String(error),
+                  time: {
+                    start: errorTime,
+                    end: errorTime
+                  }
+                }
+              }
+            })
+          }
+        }
+      }
+
+      // Emit step_finish for tool requests
+      this.emitEvent('step_finish', {
+        part: {
+          id: this.generatePartId(),
+          sessionID,
+          messageID: this.messageID,
+          type: 'step-finish',
+          reason: 'stop',
+          snapshot,
+          cost: 0,
+          tokens: {
+            input: 1273,
+            output: 2,
+            reasoning: 173,
+            cache: { read: 9536, write: 0 }
+          }
+        }
+      })
+
+      return {
+        sessionID,
+        timestamp: Date.now()
+      }
+    }
+
+    // Regular message processing
+    // Simulate processing delay
+    await new Promise(resolve => setTimeout(resolve, 100))
+
+    // Emit text response like opencode
+    const responseText = message === "hi" ? "Hi!" : `You said: "${message}"`
+    this.emitEvent('text', {
+      part: {
+        id: this.generatePartId(),
+        sessionID,
+        messageID: this.messageID,
+        type: 'text',
+        text: responseText,
+        time: {
+          start: Date.now(),
+          end: Date.now()
+        }
+      }
+    })
+
+    // Emit step_finish with cost and tokens like opencode
+    this.emitEvent('step_finish', {
+      part: {
+        id: this.generatePartId(),
+        sessionID,
+        messageID: this.messageID,
+        type: 'step-finish',
+        reason: 'stop',
+        snapshot,
+        cost: 0,
+        tokens: {
+          input: 1273,
+          output: 2,
+          reasoning: 173,
+          cache: { read: 9536, write: 0 }
+        }
+      }
+    })
+
+    return {
+      sessionID,
+      timestamp: Date.now()
+    }
+  }
+
+  emitEvent(type, data) {
+    const event = {
+      type,
+      timestamp: Date.now(),
+      sessionID: this.sessionID,
+      ...data
+    }
+    // Pretty-print JSON for human readability, compact for programmatic use
+    // Use AGENT_CLI_COMPACT=1 for compact output (tests, automation)
+    const compact = process.env.AGENT_CLI_COMPACT === '1'
+    console.log(compact ? JSON.stringify(event) : JSON.stringify(event, null, 2))
+  }
+}

package/src/session/compaction.ts

@@ -0,0 +1,249 @@
+import { streamText, wrapLanguageModel, type ModelMessage } from "ai"
+import { Session } from "."
+import { Identifier } from "../id/id"
+import { Instance } from "../project/instance"
+import { Provider } from "../provider/provider"
+import { MessageV2 } from "./message-v2"
+import { SystemPrompt } from "./system"
+import { Bus } from "../bus"
+import z from "zod"
+import type { ModelsDev } from "../provider/models"
+import { SessionPrompt } from "./prompt"
+import { Flag } from "../flag/flag"
+import { Token } from "../util/token"
+import { Log } from "../util/log"
+import { ProviderTransform } from "../provider/transform"
+import { SessionProcessor } from "./processor"
+import { fn } from "../util/fn"
+
+export namespace SessionCompaction {
+  const log = Log.create({ service: "session.compaction" })
+
+  export const Event = {
+    Compacted: Bus.event(
+      "session.compacted",
+      z.object({
+        sessionID: z.string(),
+      }),
+    ),
+  }
+
+  export function isOverflow(input: { tokens: MessageV2.Assistant["tokens"]; model: ModelsDev.Model }) {
+    if (Flag.OPENCODE_DISABLE_AUTOCOMPACT) 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 = context - output
+    return count > usable
+  }
+
+  export const PRUNE_MINIMUM = 20_000
+  export const PRUNE_PROTECT = 40_000
+
+  // 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 }) {
+    if (Flag.OPENCODE_DISABLE_PRUNE) 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 (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
+    model: {
+      providerID: string
+      modelID: string
+    }
+    abort: AbortSignal
+  }) {
+    const model = await Provider.getModel(input.model.providerID, input.model.modelID)
+    const system = [...SystemPrompt.summarize(model.providerID)]
+    const msg = (await Session.updateMessage({
+      id: Identifier.ascending("message"),
+      role: "assistant",
+      parentID: input.parentID,
+      sessionID: input.sessionID,
+      mode: "build",
+      summary: true,
+      path: {
+        cwd: Instance.directory,
+        root: Instance.worktree,
+      },
+      cost: 0,
+      tokens: {
+        output: 0,
+        input: 0,
+        reasoning: 0,
+        cache: { read: 0, write: 0 },
+      },
+      modelID: input.model.modelID,
+      providerID: model.providerID,
+      time: {
+        created: Date.now(),
+      },
+    })) as MessageV2.Assistant
+    const processor = SessionProcessor.create({
+      assistantMessage: msg,
+      sessionID: input.sessionID,
+      providerID: input.model.providerID,
+      model: model.info,
+      abort: input.abort,
+    })
+    const result = await processor.process(() =>
+      streamText({
+        onError(error) {
+          log.error("stream error", {
+            error,
+          })
+        },
+        // set to 0, we handle loop
+        maxRetries: 0,
+        providerOptions: ProviderTransform.providerOptions(model.npm, model.providerID, {
+          ...ProviderTransform.options(model.providerID, model.modelID, model.npm ?? "", input.sessionID),
+          ...model.info.options,
+        }),
+        headers: model.info.headers,
+        abortSignal: input.abort,
+        tools: model.info.tool_call ? {} : undefined,
+        messages: [
+          ...system.map(
+            (x): ModelMessage => ({
+              role: "system",
+              content: x,
+            }),
+          ),
+          ...MessageV2.toModelMessage(
+            input.messages.filter((m) => {
+              if (m.info.role !== "assistant" || m.info.error === undefined) {
+                return true
+              }
+              if (
+                MessageV2.AbortedError.isInstance(m.info.error) &&
+                m.parts.some((part) => part.type !== "step-start" && part.type !== "reasoning")
+              ) {
+                return true
+              }
+
+              return false
+            }),
+          ),
+          {
+            role: "user",
+            content: [
+              {
+                type: "text",
+                text: "Provide a detailed but concise summary of 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.",
+              },
+            ],
+          },
+        ],
+        model: wrapLanguageModel({
+          model: model.language,
+          middleware: [
+            {
+              async transformParams(args) {
+                if (args.type === "stream") {
+                  // @ts-expect-error
+                  args.params.prompt = ProviderTransform.message(args.params.prompt, model.providerID, model.modelID)
+                }
+                return args.params
+              },
+            },
+          ],
+        }),
+      }),
+    )
+    if (result === "continue") {
+      const continueMsg = await Session.updateMessage({
+        id: Identifier.ascending("message"),
+        role: "user",
+        sessionID: input.sessionID,
+        time: {
+          created: Date.now(),
+        },
+        agent: "build",
+        model: input.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"
+    return "continue"
+  }
+
+  export const create = fn(
+    z.object({
+      sessionID: Identifier.schema("session"),
+      model: z.object({
+        providerID: z.string(),
+        modelID: z.string(),
+      }),
+    }),
+    async (input) => {
+      const msg = await Session.updateMessage({
+        id: Identifier.ascending("message"),
+        role: "user",
+        model: input.model,
+        sessionID: input.sessionID,
+        agent: "build",
+        time: {
+          created: Date.now(),
+        },
+      })
+      await Session.updatePart({
+        id: Identifier.ascending("part"),
+        messageID: msg.id,
+        sessionID: msg.sessionID,
+        type: "compaction",
+      })
+    },
+  )
+}