feat: add ACP agent variants for Claude, Codex, Copilot, and Amp (#387)
This commit is contained in:
@@ -213,6 +213,16 @@ func (a *lifecycleAdapter) RestartAgentProcess(ctx context.Context, agentExecuti
|
||||
return a.mgr.RestartAgentProcess(ctx, agentExecutionID)
|
||||
}
|
||||
|
||||
// ResetAgentContext resets the agent's context using the fastest available strategy.
|
||||
func (a *lifecycleAdapter) ResetAgentContext(ctx context.Context, agentExecutionID string) error {
|
||||
return a.mgr.ResetAgentContext(ctx, agentExecutionID)
|
||||
}
|
||||
|
||||
// SetSessionModelBySessionID attempts an in-place model switch via ACP session/set_model.
|
||||
func (a *lifecycleAdapter) SetSessionModelBySessionID(ctx context.Context, sessionID, modelID string) error {
|
||||
return a.mgr.SetSessionModelBySessionID(ctx, sessionID, modelID)
|
||||
}
|
||||
|
||||
// RespondToPermissionBySessionID sends a response to a permission request for a session
|
||||
func (a *lifecycleAdapter) RespondToPermissionBySessionID(ctx context.Context, sessionID, pendingID, optionID string, cancelled bool) error {
|
||||
return a.mgr.RespondToPermissionBySessionID(sessionID, pendingID, optionID, cancelled)
|
||||
@@ -373,7 +383,7 @@ type messageCreatorAdapter struct {
|
||||
logger *logger.Logger
|
||||
|
||||
// sessionModelCache caches the resolved model per session to avoid repeated DB lookups.
|
||||
// The model doesn't change within a session, so caching is safe.
|
||||
// Invalidated via InvalidateModelCache when the model changes (e.g., model switch).
|
||||
sessionModelMu sync.RWMutex
|
||||
sessionModelCache map[string]string
|
||||
}
|
||||
@@ -407,6 +417,14 @@ func (a *messageCreatorAdapter) getSessionModel(ctx context.Context, sessionID s
|
||||
return model
|
||||
}
|
||||
|
||||
// InvalidateModelCache clears the cached model for a session so the next message
|
||||
// re-reads it from the DB. Called after model switches.
|
||||
func (a *messageCreatorAdapter) InvalidateModelCache(sessionID string) {
|
||||
a.sessionModelMu.Lock()
|
||||
delete(a.sessionModelCache, sessionID)
|
||||
a.sessionModelMu.Unlock()
|
||||
}
|
||||
|
||||
// CreateAgentMessage creates a message with author_type="agent"
|
||||
func (a *messageCreatorAdapter) CreateAgentMessage(ctx context.Context, taskID, content, agentSessionID, turnID string) error {
|
||||
var metadata map[string]interface{}
|
||||
|
||||
@@ -63,6 +63,8 @@ func buildSessionDataProvider(taskRepo *sqliterepo.Repository, lifecycleMgr *lif
|
||||
result = appendLiveGitStatusMessage(ctx, taskRepo, lifecycleMgr, sessionID, session, result, log)
|
||||
result = appendContextWindowMessage(sessionID, session, result)
|
||||
result = appendAvailableCommandsMessage(sessionID, session, lifecycleMgr, result)
|
||||
result = appendSessionModeMessage(sessionID, session, lifecycleMgr, result)
|
||||
result = appendSessionModelsMessage(sessionID, session, lifecycleMgr, result)
|
||||
return result, nil
|
||||
}
|
||||
}
|
||||
@@ -254,6 +256,49 @@ func appendAvailableCommandsMessage(sessionID string, session *models.TaskSessio
|
||||
return result
|
||||
}
|
||||
|
||||
// appendSessionModeMessage adds session mode state notification to result if cached.
|
||||
func appendSessionModeMessage(sessionID string, session *models.TaskSession, lifecycleMgr *lifecycle.Manager, result []*ws.Message) []*ws.Message {
|
||||
if lifecycleMgr == nil {
|
||||
return result
|
||||
}
|
||||
modeState := lifecycleMgr.GetModeStateForSession(sessionID)
|
||||
if modeState == nil || (modeState.CurrentModeID == "" && len(modeState.AvailableModes) == 0) {
|
||||
return result
|
||||
}
|
||||
notification, err := ws.NewNotification(ws.ActionSessionModeChanged, lifecycle.SessionModeEventPayload{
|
||||
TaskID: session.TaskID,
|
||||
SessionID: sessionID,
|
||||
CurrentModeID: modeState.CurrentModeID,
|
||||
AvailableModes: modeState.AvailableModes,
|
||||
})
|
||||
if err == nil {
|
||||
result = append(result, notification)
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// appendSessionModelsMessage adds session models state notification to result if cached.
|
||||
func appendSessionModelsMessage(sessionID string, session *models.TaskSession, lifecycleMgr *lifecycle.Manager, result []*ws.Message) []*ws.Message {
|
||||
if lifecycleMgr == nil {
|
||||
return result
|
||||
}
|
||||
modelState := lifecycleMgr.GetModelStateForSession(sessionID)
|
||||
if modelState == nil || (modelState.CurrentModelID == "" && len(modelState.Models) == 0) {
|
||||
return result
|
||||
}
|
||||
notification, err := ws.NewNotification(ws.ActionSessionModelsUpdated, lifecycle.SessionModelsEventPayload{
|
||||
TaskID: session.TaskID,
|
||||
SessionID: sessionID,
|
||||
CurrentModelID: modelState.CurrentModelID,
|
||||
Models: modelState.Models,
|
||||
ConfigOptions: modelState.ConfigOptions,
|
||||
})
|
||||
if err == nil {
|
||||
result = append(result, notification)
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// newMessageAddedHandler returns an event bus handler that broadcasts message.added events
|
||||
// to WebSocket subscribers.
|
||||
func newMessageAddedHandler(gateway *gateways.Gateway, log *logger.Logger) func(context.Context, *bus.Event) error {
|
||||
|
||||
@@ -0,0 +1,90 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
|
||||
acp "github.com/coder/acp-go-sdk"
|
||||
)
|
||||
|
||||
// sessionUpdater abstracts the ACP connection methods used by the emitter.
|
||||
// The real acp.AgentSideConnection satisfies this; tests provide a mock.
|
||||
type sessionUpdater interface {
|
||||
SessionUpdate(ctx context.Context, n acp.SessionNotification) error
|
||||
RequestPermission(ctx context.Context, p acp.RequestPermissionRequest) (acp.RequestPermissionResponse, error)
|
||||
}
|
||||
|
||||
// emitter wraps an ACP connection and session ID to provide
|
||||
// convenient methods for streaming agent updates.
|
||||
type emitter struct {
|
||||
ctx context.Context
|
||||
conn sessionUpdater
|
||||
sid acp.SessionId
|
||||
}
|
||||
|
||||
// text sends an agent text message update.
|
||||
func (e *emitter) text(msg string) {
|
||||
_ = e.conn.SessionUpdate(e.ctx, acp.SessionNotification{
|
||||
SessionId: e.sid,
|
||||
Update: acp.UpdateAgentMessageText(msg),
|
||||
})
|
||||
}
|
||||
|
||||
// thought sends an agent thinking/reasoning update.
|
||||
func (e *emitter) thought(msg string) {
|
||||
_ = e.conn.SessionUpdate(e.ctx, acp.SessionNotification{
|
||||
SessionId: e.sid,
|
||||
Update: acp.UpdateAgentThoughtText(msg),
|
||||
})
|
||||
}
|
||||
|
||||
// startTool announces a new tool call.
|
||||
func (e *emitter) startTool(id acp.ToolCallId, title string, kind acp.ToolKind, input any, locs ...acp.ToolCallLocation) {
|
||||
opts := []acp.ToolCallStartOpt{
|
||||
acp.WithStartKind(kind),
|
||||
acp.WithStartStatus(acp.ToolCallStatusPending),
|
||||
acp.WithStartRawInput(input),
|
||||
}
|
||||
if len(locs) > 0 {
|
||||
opts = append(opts, acp.WithStartLocations(locs))
|
||||
}
|
||||
_ = e.conn.SessionUpdate(e.ctx, acp.SessionNotification{
|
||||
SessionId: e.sid,
|
||||
Update: acp.StartToolCall(id, title, opts...),
|
||||
})
|
||||
}
|
||||
|
||||
// completeTool marks a tool call as completed with output.
|
||||
func (e *emitter) completeTool(id acp.ToolCallId, output any) {
|
||||
_ = e.conn.SessionUpdate(e.ctx, acp.SessionNotification{
|
||||
SessionId: e.sid,
|
||||
Update: acp.UpdateToolCall(id,
|
||||
acp.WithUpdateStatus(acp.ToolCallStatusCompleted),
|
||||
acp.WithUpdateRawOutput(output),
|
||||
),
|
||||
})
|
||||
}
|
||||
|
||||
// requestPermission asks the client for permission to proceed with a tool call.
|
||||
// Returns true if permission was granted, false otherwise.
|
||||
func (e *emitter) requestPermission(toolCallID acp.ToolCallId, title string, kind acp.ToolKind, input any) bool {
|
||||
resp, err := e.conn.RequestPermission(e.ctx, acp.RequestPermissionRequest{
|
||||
SessionId: e.sid,
|
||||
ToolCall: acp.RequestPermissionToolCall{
|
||||
ToolCallId: toolCallID,
|
||||
Title: acp.Ptr(title),
|
||||
Kind: acp.Ptr(kind),
|
||||
Status: acp.Ptr(acp.ToolCallStatusPending),
|
||||
RawInput: input,
|
||||
},
|
||||
Options: []acp.PermissionOption{
|
||||
{Kind: acp.PermissionOptionKindAllowOnce, Name: "Allow", OptionId: "allow"},
|
||||
{Kind: acp.PermissionOptionKindRejectOnce, Name: "Reject", OptionId: "reject"},
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
_, _ = fmt.Fprintf(logOutput, "mock-agent: permission request failed: %v\n", err)
|
||||
return false
|
||||
}
|
||||
return resp.Outcome.Selected != nil && string(resp.Outcome.Selected.OptionId) == "allow"
|
||||
}
|
||||
@@ -1,8 +1,6 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"math/rand"
|
||||
"os"
|
||||
@@ -45,129 +43,68 @@ func stripKandevSystem(prompt string) string {
|
||||
return strings.TrimSpace(prompt[idx+len(endTag):])
|
||||
}
|
||||
|
||||
// handleUserPrompt routes a user prompt to the appropriate sequence generator.
|
||||
func handleUserPrompt(enc *json.Encoder, scanner *bufio.Scanner, prompt, model string) {
|
||||
// handlePrompt routes a user prompt to the appropriate sequence generator.
|
||||
func handlePrompt(e *emitter, prompt, model string) {
|
||||
prompt = strings.TrimSpace(prompt)
|
||||
|
||||
// Extract the user-facing content for command routing.
|
||||
// The backend wraps prompts with <kandev-system>...</kandev-system> context;
|
||||
// routing should match the user's actual command regardless of that wrapper.
|
||||
// The full prompt (including any kandev-system content) is kept available via
|
||||
// the outer variable so future scenarios can inspect it if needed.
|
||||
cmd := stripKandevSystem(prompt)
|
||||
|
||||
// Emit system message at the start of every turn
|
||||
emitSystemMessage(enc)
|
||||
|
||||
// Script mode: each line is a command (e2e:message, e2e:mcp:*, etc.)
|
||||
if isScriptMode(cmd) {
|
||||
executeScript(enc, prompt, cmd)
|
||||
emitResult(enc, false, "")
|
||||
executeScript(e, prompt, cmd)
|
||||
return
|
||||
}
|
||||
|
||||
// Some commands emit their own result; track whether we need the default one.
|
||||
customResult := false
|
||||
|
||||
switch {
|
||||
case strings.EqualFold(cmd, "all") || strings.EqualFold(cmd, "/all"):
|
||||
emitAllTypes(enc, scanner, model)
|
||||
emitAllTypes(e, model)
|
||||
case strings.EqualFold(cmd, "/error"):
|
||||
emitError(enc, model)
|
||||
customResult = true
|
||||
emitError(e, model)
|
||||
case strings.EqualFold(cmd, "/slow") || strings.HasPrefix(strings.ToLower(cmd), "/slow "):
|
||||
emitSlowResponse(enc, scanner, cmd, model)
|
||||
emitSlowResponse(e, cmd, model)
|
||||
case strings.EqualFold(cmd, "/thinking"):
|
||||
emitThinkingSequence(enc, model)
|
||||
emitThinkingSequence(e, model)
|
||||
case strings.HasPrefix(cmd, "/tool:"):
|
||||
toolName := strings.TrimPrefix(cmd, "/tool:")
|
||||
emitSpecificTool(enc, scanner, strings.TrimSpace(toolName), model)
|
||||
emitSpecificTool(e, strings.TrimSpace(toolName), model)
|
||||
case strings.HasPrefix(cmd, "/subagent"):
|
||||
emitSubagentSequence(enc, scanner, model)
|
||||
emitSubagentSequence(e, model)
|
||||
case strings.HasPrefix(cmd, "/e2e:"):
|
||||
rest := strings.TrimPrefix(cmd, "/e2e:")
|
||||
scenarioName, _, _ := strings.Cut(strings.TrimSpace(rest), " ")
|
||||
emitPredefinedScenario(enc, scanner, scenarioName)
|
||||
// e2e:error emits its own result
|
||||
if strings.TrimSpace(scenarioName) == "error" {
|
||||
customResult = true
|
||||
}
|
||||
emitPredefinedScenario(e, scenarioName)
|
||||
case strings.EqualFold(cmd, "/crash"):
|
||||
emitCrash(enc, model)
|
||||
return // process exits, no result needed
|
||||
emitCrash(e, model)
|
||||
case strings.HasPrefix(cmd, "/todo"):
|
||||
emitTodoSequence(enc, model)
|
||||
emitTodoSequence(e, model)
|
||||
case strings.EqualFold(cmd, "/mermaid"):
|
||||
emitMermaidSequence(enc, model)
|
||||
emitMermaidSequence(e, model)
|
||||
default:
|
||||
emitRandomResponse(enc, scanner, cmd, model)
|
||||
}
|
||||
|
||||
if !customResult {
|
||||
emitResult(enc, false, "")
|
||||
emitRandomResponse(e, cmd, model)
|
||||
}
|
||||
}
|
||||
|
||||
// emitSystemMessage writes the system message to stdout.
|
||||
func emitSystemMessage(enc *json.Encoder) {
|
||||
_ = enc.Encode(SystemMsg{
|
||||
Type: TypeSystem,
|
||||
SessionID: sessionID,
|
||||
SessionStatus: "active",
|
||||
})
|
||||
}
|
||||
|
||||
// emitResult writes the final result message to stdout.
|
||||
func emitResult(enc *json.Encoder, isError bool, errText string) {
|
||||
var resultJSON json.RawMessage
|
||||
if isError {
|
||||
resultJSON, _ = json.Marshal(errText)
|
||||
} else {
|
||||
resultJSON, _ = json.Marshal(ResultData{
|
||||
Text: "Mock agent completed successfully.",
|
||||
SessionID: sessionID,
|
||||
})
|
||||
}
|
||||
|
||||
_ = enc.Encode(ResultMsg{
|
||||
Type: TypeResult,
|
||||
Result: resultJSON,
|
||||
CostUSD: 0.0042,
|
||||
DurationMS: 1500,
|
||||
DurationAPIMS: 1200,
|
||||
IsError: isError,
|
||||
NumTurns: 1,
|
||||
TotalInputTokens: 1500,
|
||||
TotalOutputTokens: 500,
|
||||
ModelUsage: map[string]ModelUsageStats{
|
||||
"mock-default": {ContextWindow: 200000},
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
// emitError emits an error result.
|
||||
func emitError(enc *json.Encoder, model string) {
|
||||
// emitError emits an error message.
|
||||
func emitError(e *emitter, model string) {
|
||||
randomDelay(model)
|
||||
emitTextBlock(enc, "Simulating an error condition...", "")
|
||||
e.text("Simulating an error condition...")
|
||||
randomDelay(model)
|
||||
emitResult(enc, true, "Mock error: something went wrong during processing")
|
||||
// Return without emitting the normal result (handler skips the final emitResult
|
||||
// because we already emitted one). We handle this by making the caller check.
|
||||
e.text("Mock error: something went wrong during processing")
|
||||
}
|
||||
|
||||
// emitCrash simulates an agent crash by exiting with code 1 after emitting
|
||||
// some output. Useful for testing recovery flows.
|
||||
func emitCrash(enc *json.Encoder, model string) {
|
||||
func emitCrash(e *emitter, model string) {
|
||||
randomDelay(model)
|
||||
emitTextBlock(enc, "Processing your request...", "")
|
||||
e.text("Processing your request...")
|
||||
randomDelay(model)
|
||||
fmt.Fprintln(os.Stderr, "mock-agent: simulating crash (exit 1)")
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
// emitSlowResponse generates a response with configurable total duration.
|
||||
// Accepts "/slow" (defaults to 5s) or "/slow <duration>" (e.g. "/slow 60s", "/slow 2m").
|
||||
func emitSlowResponse(enc *json.Encoder, _ *bufio.Scanner, prompt, model string) {
|
||||
func emitSlowResponse(e *emitter, prompt, model string) {
|
||||
totalDuration := 5 * time.Second
|
||||
parts := strings.Fields(prompt)
|
||||
if len(parts) >= 2 {
|
||||
@@ -176,38 +113,37 @@ func emitSlowResponse(enc *json.Encoder, _ *bufio.Scanner, prompt, model string)
|
||||
}
|
||||
}
|
||||
|
||||
// Divide total duration into steps
|
||||
steps := 5
|
||||
stepDelay := totalDuration / time.Duration(steps)
|
||||
|
||||
emitThinking(enc, model)
|
||||
emitThinking(e, model)
|
||||
time.Sleep(stepDelay)
|
||||
|
||||
emitTextBlock(enc, fmt.Sprintf("Running slow response (%s total)...", totalDuration), "")
|
||||
e.text(fmt.Sprintf("Running slow response (%s total)...", totalDuration))
|
||||
time.Sleep(stepDelay)
|
||||
|
||||
emitReadFile(enc, model)
|
||||
emitReadFile(e, model)
|
||||
time.Sleep(stepDelay)
|
||||
|
||||
emitCodeSearch(enc, model)
|
||||
emitCodeSearch(e, model)
|
||||
time.Sleep(stepDelay)
|
||||
|
||||
emitTextBlock(enc, fmt.Sprintf("Slow response complete after %s.", totalDuration), "")
|
||||
e.text(fmt.Sprintf("Slow response complete after %s.", totalDuration))
|
||||
time.Sleep(stepDelay)
|
||||
}
|
||||
|
||||
// emitRandomResponse generates a random mix of 2-5 events.
|
||||
func emitRandomResponse(enc *json.Encoder, _ *bufio.Scanner, prompt, model string) {
|
||||
func emitRandomResponse(e *emitter, prompt, model string) {
|
||||
generators := []func(){
|
||||
func() { emitThinking(enc, model) },
|
||||
func() { emitTextBlock(enc, "I'll help you with that. Let me look into it.", "") },
|
||||
func() { emitReadFile(enc, model) },
|
||||
func() { emitCodeSearch(enc, model) },
|
||||
func() { emitWebFetch(enc, model) },
|
||||
func() { emitThinking(e, model) },
|
||||
func() { e.text("I'll help you with that. Let me look into it.") },
|
||||
func() { emitReadFile(e, model) },
|
||||
func() { emitCodeSearch(e, model) },
|
||||
func() { emitWebFetch(e, model) },
|
||||
}
|
||||
|
||||
// Always start with thinking
|
||||
emitThinking(enc, model)
|
||||
emitThinking(e, model)
|
||||
randomDelay(model)
|
||||
|
||||
// Pick 1-4 more random events
|
||||
@@ -219,34 +155,34 @@ func emitRandomResponse(enc *json.Encoder, _ *bufio.Scanner, prompt, model strin
|
||||
}
|
||||
|
||||
// End with a text summary
|
||||
emitTextBlock(enc, "I've completed the analysis of your request: \""+prompt+"\". Everything looks good!", "")
|
||||
e.text("I've completed the analysis of your request: \"" + prompt + "\". Everything looks good!")
|
||||
}
|
||||
|
||||
// emitAllTypes emits one of every message type.
|
||||
func emitAllTypes(enc *json.Encoder, scanner *bufio.Scanner, model string) {
|
||||
emitThinking(enc, model)
|
||||
func emitAllTypes(e *emitter, model string) {
|
||||
emitThinking(e, model)
|
||||
randomDelay(model)
|
||||
emitTextBlock(enc, "Starting comprehensive demonstration of all message types...", "")
|
||||
e.text("Starting comprehensive demonstration of all message types...")
|
||||
randomDelay(model)
|
||||
emitReadFile(enc, model)
|
||||
emitReadFile(e, model)
|
||||
randomDelay(model)
|
||||
emitEditFile(enc, scanner, model)
|
||||
emitEditFile(e, model)
|
||||
randomDelay(model)
|
||||
emitShellExec(enc, scanner, model)
|
||||
emitShellExec(e, model)
|
||||
randomDelay(model)
|
||||
emitCodeSearch(enc, model)
|
||||
emitCodeSearch(e, model)
|
||||
randomDelay(model)
|
||||
emitSubagent(enc, scanner, model)
|
||||
emitSubagent(e, model)
|
||||
randomDelay(model)
|
||||
emitTodo(enc, model)
|
||||
emitTodo(e, model)
|
||||
randomDelay(model)
|
||||
emitWebFetch(enc, model)
|
||||
emitWebFetch(e, model)
|
||||
randomDelay(model)
|
||||
emitTextBlock(enc, "All message types demonstrated successfully!", "")
|
||||
e.text("All message types demonstrated successfully!")
|
||||
}
|
||||
|
||||
// emitThinkingSequence emits extended thinking/reasoning blocks.
|
||||
func emitThinkingSequence(enc *json.Encoder, model string) {
|
||||
func emitThinkingSequence(e *emitter, model string) {
|
||||
thoughts := []string{
|
||||
"Let me analyze this problem step by step...",
|
||||
"First, I need to consider the architecture and how the components interact.",
|
||||
@@ -257,49 +193,49 @@ func emitThinkingSequence(enc *json.Encoder, model string) {
|
||||
|
||||
for _, thought := range thoughts {
|
||||
randomDelay(model)
|
||||
emitThinkingBlock(enc, thought, "")
|
||||
e.thought(thought)
|
||||
}
|
||||
|
||||
randomDelay(model)
|
||||
emitTextBlock(enc, "After careful reasoning, here is my analysis:\n\n1. The architecture is sound\n2. Error handling covers edge cases\n3. The implementation follows Go best practices", "")
|
||||
e.text("After careful reasoning, here is my analysis:\n\n1. The architecture is sound\n2. Error handling covers edge cases\n3. The implementation follows Go best practices")
|
||||
}
|
||||
|
||||
// emitSpecificTool emits a single specific tool call.
|
||||
func emitSpecificTool(enc *json.Encoder, scanner *bufio.Scanner, toolName, model string) {
|
||||
func emitSpecificTool(e *emitter, toolName, model string) {
|
||||
switch strings.ToLower(toolName) {
|
||||
case "read":
|
||||
emitReadFile(enc, model)
|
||||
emitReadFile(e, model)
|
||||
case "edit":
|
||||
emitEditFile(enc, scanner, model)
|
||||
emitEditFile(e, model)
|
||||
case "exec", "bash":
|
||||
emitShellExec(enc, scanner, model)
|
||||
emitShellExec(e, model)
|
||||
case "search", "grep":
|
||||
emitCodeSearch(enc, model)
|
||||
emitCodeSearch(e, model)
|
||||
case "webfetch", "web":
|
||||
emitWebFetch(enc, model)
|
||||
emitWebFetch(e, model)
|
||||
default:
|
||||
emitTextBlock(enc, "Unknown tool: "+toolName+". Available: read, edit, exec, search, webfetch", "")
|
||||
e.text("Unknown tool: " + toolName + ". Available: read, edit, exec, search, webfetch")
|
||||
}
|
||||
}
|
||||
|
||||
// emitTodoSequence emits a todo management sequence.
|
||||
func emitTodoSequence(enc *json.Encoder, model string) {
|
||||
emitThinking(enc, model)
|
||||
func emitTodoSequence(e *emitter, model string) {
|
||||
emitThinking(e, model)
|
||||
randomDelay(model)
|
||||
emitTextBlock(enc, "I'll create a task list for this work.", "")
|
||||
e.text("I'll create a task list for this work.")
|
||||
randomDelay(model)
|
||||
emitTodo(enc, model)
|
||||
emitTodo(e, model)
|
||||
randomDelay(model)
|
||||
emitTextBlock(enc, "Task list has been updated.", "")
|
||||
e.text("Task list has been updated.")
|
||||
}
|
||||
|
||||
// emitSubagentSequence emits a subagent Task sequence.
|
||||
func emitSubagentSequence(enc *json.Encoder, scanner *bufio.Scanner, model string) {
|
||||
emitThinking(enc, model)
|
||||
func emitSubagentSequence(e *emitter, model string) {
|
||||
emitThinking(e, model)
|
||||
randomDelay(model)
|
||||
emitTextBlock(enc, "I'll delegate this to a subagent for parallel processing.", "")
|
||||
e.text("I'll delegate this to a subagent for parallel processing.")
|
||||
randomDelay(model)
|
||||
emitSubagent(enc, scanner, model)
|
||||
emitSubagent(e, model)
|
||||
randomDelay(model)
|
||||
emitTextBlock(enc, "Subagent task completed successfully.", "")
|
||||
e.text("Subagent task completed successfully.")
|
||||
}
|
||||
|
||||
@@ -1,21 +1,23 @@
|
||||
// Package main implements a mock agent binary that speaks the claude-code
|
||||
// stream-json protocol over stdin/stdout. It generates simulated responses
|
||||
// for rapid feature testing and e2e web app tests.
|
||||
// Package main implements a mock agent binary that speaks the ACP
|
||||
// (Agent Client Protocol) over stdin/stdout. It generates simulated
|
||||
// responses for rapid feature testing and e2e web app tests.
|
||||
package main
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"slices"
|
||||
"strings"
|
||||
"sync"
|
||||
|
||||
acp "github.com/coder/acp-go-sdk"
|
||||
)
|
||||
|
||||
// sessionID is a unique identifier for this mock-agent process instance.
|
||||
// Each session spawns its own process, so using PID ensures uniqueness
|
||||
// across parallel sessions.
|
||||
var sessionID = fmt.Sprintf("mock-session-%d", os.Getpid())
|
||||
// logOutput is the writer for log messages (stderr). Tests can override this.
|
||||
var logOutput io.Writer = os.Stderr
|
||||
|
||||
// mcpServerDef describes an MCP server endpoint parsed from --mcp-config.
|
||||
type mcpServerDef struct {
|
||||
@@ -26,18 +28,20 @@ type mcpServerDef struct {
|
||||
// mcpServers holds MCP server definitions from --mcp-config.
|
||||
var mcpServers map[string]mcpServerDef
|
||||
|
||||
// mockAgent implements the acp.Agent interface for the mock agent.
|
||||
type mockAgent struct {
|
||||
conn *acp.AgentSideConnection
|
||||
model string
|
||||
sessions map[acp.SessionId]bool
|
||||
mu sync.Mutex
|
||||
}
|
||||
|
||||
func main() {
|
||||
model := parseModelFlag()
|
||||
|
||||
// Override sessionID when resuming a previous session.
|
||||
resumeID := parseResumeFlag()
|
||||
if resumeID != "" {
|
||||
sessionID = resumeID
|
||||
fmt.Fprintf(os.Stderr, "mock-agent[%d]: resuming session %s\n", os.Getpid(), resumeID)
|
||||
}
|
||||
|
||||
// TUI mode: simple terminal UI for passthrough/PTY testing
|
||||
if parseTUIFlag() {
|
||||
resumeID := parseResumeFlag()
|
||||
resumed := resumeID != "" || parseContinueFlag()
|
||||
runTUI(model, parsePromptFlag(), resumed)
|
||||
return
|
||||
@@ -46,41 +50,85 @@ func main() {
|
||||
mcpServers = parseMCPConfigFlag()
|
||||
defer closeMCPClients()
|
||||
|
||||
scanner := bufio.NewScanner(os.Stdin)
|
||||
buf := make([]byte, 0, 64*1024)
|
||||
scanner.Buffer(buf, 10*1024*1024)
|
||||
|
||||
enc := json.NewEncoder(os.Stdout)
|
||||
|
||||
for scanner.Scan() {
|
||||
line := scanner.Bytes()
|
||||
if len(line) == 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
var msg IncomingMessage
|
||||
if err := json.Unmarshal(line, &msg); err != nil {
|
||||
fmt.Fprintf(os.Stderr, "mock-agent[%d]: unmarshal error: %v (line=%s)\n", os.Getpid(), err, string(line[:min(200, len(line))]))
|
||||
continue
|
||||
}
|
||||
|
||||
switch msg.Type {
|
||||
case TypeControlRequest:
|
||||
fmt.Fprintf(os.Stderr, "mock-agent[%d]: control_request (request_id=%s)\n", os.Getpid(), msg.RequestID)
|
||||
handleControlRequest(enc, msg)
|
||||
case TypeUser:
|
||||
if msg.Message != nil {
|
||||
handleUserPrompt(enc, scanner, msg.Message.Content, model)
|
||||
}
|
||||
}
|
||||
ag := &mockAgent{
|
||||
model: model,
|
||||
sessions: make(map[acp.SessionId]bool),
|
||||
}
|
||||
asc := acp.NewAgentSideConnection(ag, os.Stdout, os.Stdin)
|
||||
ag.conn = asc
|
||||
|
||||
if err := scanner.Err(); err != nil {
|
||||
fmt.Fprintf(os.Stderr, "mock-agent: scanner error: %v\n", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
<-asc.Done()
|
||||
}
|
||||
|
||||
// Initialize handles the ACP initialize request, returning agent capabilities.
|
||||
func (a *mockAgent) Initialize(_ context.Context, _ acp.InitializeRequest) (acp.InitializeResponse, error) {
|
||||
return acp.InitializeResponse{
|
||||
ProtocolVersion: acp.ProtocolVersionNumber,
|
||||
AgentCapabilities: acp.AgentCapabilities{
|
||||
LoadSession: true,
|
||||
McpCapabilities: acp.McpCapabilities{Sse: true},
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
// NewSession creates a new conversation session.
|
||||
// MCP servers from the ACP request are registered so callMCPTool can use them.
|
||||
func (a *mockAgent) NewSession(_ context.Context, req acp.NewSessionRequest) (acp.NewSessionResponse, error) {
|
||||
sid := acp.SessionId(fmt.Sprintf("mock-session-%d", os.Getpid()))
|
||||
a.mu.Lock()
|
||||
a.sessions[sid] = true
|
||||
a.mu.Unlock()
|
||||
|
||||
// Register MCP servers from the ACP session request (SSE servers).
|
||||
// This bridges ACP protocol MCP config to the mock agent's MCP client.
|
||||
registerACPMcpServers(req.McpServers)
|
||||
|
||||
return acp.NewSessionResponse{SessionId: sid}, nil
|
||||
}
|
||||
|
||||
// LoadSession restores a previous session for resume.
|
||||
func (a *mockAgent) LoadSession(_ context.Context, req acp.LoadSessionRequest) (acp.LoadSessionResponse, error) {
|
||||
a.mu.Lock()
|
||||
a.sessions[req.SessionId] = true
|
||||
a.mu.Unlock()
|
||||
_, _ = fmt.Fprintf(logOutput, "mock-agent[%d]: resumed session %s\n", os.Getpid(), req.SessionId)
|
||||
return acp.LoadSessionResponse{}, nil
|
||||
}
|
||||
|
||||
// Prompt processes a user message and streams responses via SessionUpdate.
|
||||
func (a *mockAgent) Prompt(ctx context.Context, req acp.PromptRequest) (acp.PromptResponse, error) {
|
||||
prompt := extractPromptText(req.Prompt)
|
||||
e := &emitter{ctx: ctx, conn: a.conn, sid: req.SessionId}
|
||||
handlePrompt(e, prompt, a.model)
|
||||
return acp.PromptResponse{StopReason: acp.StopReasonEndTurn}, nil
|
||||
}
|
||||
|
||||
// Cancel handles session cancellation.
|
||||
func (a *mockAgent) Cancel(_ context.Context, _ acp.CancelNotification) error { return nil }
|
||||
|
||||
// Authenticate handles auth requests (no-op for mock).
|
||||
func (a *mockAgent) Authenticate(_ context.Context, _ acp.AuthenticateRequest) (acp.AuthenticateResponse, error) {
|
||||
return acp.AuthenticateResponse{}, nil
|
||||
}
|
||||
|
||||
// SetSessionMode handles mode changes (no-op for mock).
|
||||
func (a *mockAgent) SetSessionMode(_ context.Context, _ acp.SetSessionModeRequest) (acp.SetSessionModeResponse, error) {
|
||||
return acp.SetSessionModeResponse{}, nil
|
||||
}
|
||||
|
||||
// extractPromptText concatenates text content blocks from the prompt.
|
||||
func extractPromptText(blocks []acp.ContentBlock) string {
|
||||
var parts []string
|
||||
for _, b := range blocks {
|
||||
if b.Text != nil {
|
||||
parts = append(parts, b.Text.Text)
|
||||
}
|
||||
}
|
||||
return strings.Join(parts, "\n")
|
||||
}
|
||||
|
||||
// --- Flag parsing (unchanged) ---
|
||||
|
||||
// parseModelFlag extracts --model value from command line args.
|
||||
func parseModelFlag() string {
|
||||
return parseModelFromArgs(os.Args)
|
||||
@@ -137,7 +185,7 @@ func parseMCPConfigFlag() map[string]mcpServerDef {
|
||||
}
|
||||
var payload mcpConfigPayload
|
||||
if err := json.Unmarshal([]byte(raw), &payload); err != nil {
|
||||
fmt.Fprintf(os.Stderr, "mock-agent: failed to parse --mcp-config: %v\n", err)
|
||||
_, _ = fmt.Fprintf(logOutput, "mock-agent: failed to parse --mcp-config: %v\n", err)
|
||||
return nil
|
||||
}
|
||||
return payload.MCPServers
|
||||
@@ -155,45 +203,3 @@ func parseMCPConfigFromArgs(args []string) string {
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// handleControlRequest responds to control requests from the backend.
|
||||
func handleControlRequest(enc *json.Encoder, msg IncomingMessage) {
|
||||
// We only handle the initialize request from the backend
|
||||
if msg.RequestID != "" {
|
||||
resp := ControlResponseMsg{
|
||||
Type: TypeControlResponse,
|
||||
Response: ControlResponseBody{
|
||||
Subtype: "success",
|
||||
RequestID: msg.RequestID,
|
||||
Response: &InitializeResponse{
|
||||
Commands: []Command{
|
||||
{Name: "all", Description: "Demo all message types"},
|
||||
{Name: "error", Description: "Simulate an error result"},
|
||||
{Name: "slow", Description: "Random response with slow delays", ArgumentHint: "<duration e.g. 5s, 30s, 2m>"},
|
||||
{Name: "thinking", Description: "Extended thinking/reasoning blocks"},
|
||||
{Name: "tool:read", Description: "Single file read"},
|
||||
{Name: "tool:edit", Description: "Single file edit (with permission)"},
|
||||
{Name: "tool:exec", Description: "Single shell command (with permission)"},
|
||||
{Name: "tool:search", Description: "Single code search"},
|
||||
{Name: "tool:webfetch", Description: "Single web fetch"},
|
||||
{Name: "subagent", Description: "Subagent Task with nested child messages"},
|
||||
{Name: "todo", Description: "Todo management sequence"},
|
||||
{Name: "mermaid", Description: "Rich markdown with mermaid diagrams"},
|
||||
{Name: "e2e:simple-message", Description: "E2E: text only, fixed timing"},
|
||||
{Name: "e2e:read-and-edit", Description: "E2E: read + edit + text"},
|
||||
{Name: "e2e:permission-flow", Description: "E2E: tool requiring permission"},
|
||||
{Name: "e2e:error", Description: "E2E: error result"},
|
||||
{Name: "e2e:subagent", Description: "E2E: subagent with child messages"},
|
||||
{Name: "e2e:all-tools", Description: "E2E: one of each tool type"},
|
||||
{Name: "e2e:multi-turn", Description: "E2E: minimal multi-turn response"},
|
||||
{Name: "e2e:clarification", Description: "E2E: ask clarification question via MCP (happy path)"},
|
||||
{Name: "e2e:clarification-timeout", Description: "E2E: ask clarification with 5s timeout (fallback path)"},
|
||||
{Name: "e2e:*", Description: "E2E: scripted commands (e2e:message, e2e:mcp:*, etc.)"},
|
||||
},
|
||||
Agents: []string{"Bash", "Read", "Edit", "Grep", "Glob", "Task"},
|
||||
},
|
||||
},
|
||||
}
|
||||
_ = enc.Encode(resp)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,6 +6,7 @@ import (
|
||||
"strings"
|
||||
"sync"
|
||||
|
||||
acp "github.com/coder/acp-go-sdk"
|
||||
mcpclient "github.com/mark3labs/mcp-go/client"
|
||||
"github.com/mark3labs/mcp-go/mcp"
|
||||
)
|
||||
@@ -94,6 +95,20 @@ func extractMCPResultText(result *mcp.CallToolResult) string {
|
||||
return strings.Join(parts, "\n")
|
||||
}
|
||||
|
||||
// registerACPMcpServers adds SSE MCP servers from an ACP NewSessionRequest
|
||||
// to the global mcpServers map so callMCPTool can reach them.
|
||||
func registerACPMcpServers(servers []acp.McpServer) {
|
||||
for _, s := range servers {
|
||||
if s.Sse != nil && s.Sse.Name != "" && s.Sse.Url != "" {
|
||||
if mcpServers == nil {
|
||||
mcpServers = make(map[string]mcpServerDef)
|
||||
}
|
||||
mcpServers[s.Sse.Name] = mcpServerDef{URL: s.Sse.Url, Type: "sse"}
|
||||
_, _ = fmt.Fprintf(logOutput, "mock-agent: registered ACP MCP server %s at %s\n", s.Sse.Name, s.Sse.Url)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// closeMCPClients closes all open MCP clients (called on shutdown).
|
||||
func closeMCPClients() {
|
||||
mcpClientsMu.Lock()
|
||||
|
||||
@@ -1,48 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
)
|
||||
|
||||
// requestPermission sends a control_request for tool permission and waits for the response.
|
||||
// Returns true if permission was granted, false if denied.
|
||||
func requestPermission(enc *json.Encoder, scanner *bufio.Scanner, toolName, toolUseID string, input map[string]any) bool {
|
||||
requestID := fmt.Sprintf("mock-perm-%s-%s", toolName, toolUseID)
|
||||
|
||||
// Emit control_request to stdout
|
||||
_ = enc.Encode(ControlRequestMsg{
|
||||
Type: TypeControlRequest,
|
||||
RequestID: requestID,
|
||||
Request: ControlRequestBody{
|
||||
Subtype: "can_use_tool",
|
||||
ToolName: toolName,
|
||||
Input: input,
|
||||
ToolUseID: toolUseID,
|
||||
},
|
||||
})
|
||||
|
||||
// Read stdin for control_response
|
||||
for scanner.Scan() {
|
||||
line := scanner.Bytes()
|
||||
if len(line) == 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
var msg IncomingMessage
|
||||
if err := json.Unmarshal(line, &msg); err != nil {
|
||||
continue
|
||||
}
|
||||
|
||||
if msg.Type == TypeControlResponse && msg.Response != nil {
|
||||
if msg.Response.Result != nil {
|
||||
return msg.Response.Result.Behavior == "allow"
|
||||
}
|
||||
// Error response means denied
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
@@ -1,86 +1,56 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os"
|
||||
"os/exec"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
acp "github.com/coder/acp-go-sdk"
|
||||
)
|
||||
|
||||
// Predefined e2e test scenarios with fixed timing for deterministic test assertions.
|
||||
|
||||
// scenarioRegistry maps scenario names to their handler functions.
|
||||
var scenarioRegistry = map[string]func(e *emitter){
|
||||
"simple-message": scenarioSimpleMessage,
|
||||
"read-and-edit": scenarioReadAndEdit,
|
||||
"permission-flow": scenarioPermissionFlow,
|
||||
"error": scenarioError,
|
||||
"subagent": scenarioSubagent,
|
||||
"all-tools": scenarioAllTools,
|
||||
"multi-turn": scenarioMultiTurn,
|
||||
"diff-expansion-setup": scenarioDiffExpansionSetup,
|
||||
"diff-update-setup": scenarioDiffUpdateSetup,
|
||||
"diff-update-modify": scenarioDiffUpdateModify,
|
||||
"untracked-file-setup": scenarioUntrackedFileSetup,
|
||||
"untracked-file-modify": scenarioUntrackedFileModify,
|
||||
"clarification": scenarioClarification,
|
||||
"clarification-timeout": scenarioClarificationTimeout,
|
||||
}
|
||||
|
||||
// emitPredefinedScenario dispatches to a named e2e scenario.
|
||||
func emitPredefinedScenario(enc *json.Encoder, scanner *bufio.Scanner, name string) {
|
||||
switch name {
|
||||
case "simple-message":
|
||||
scenarioSimpleMessage(enc)
|
||||
case "read-and-edit":
|
||||
scenarioReadAndEdit(enc, scanner)
|
||||
case "permission-flow":
|
||||
scenarioPermissionFlow(enc, scanner)
|
||||
case "error":
|
||||
scenarioError(enc)
|
||||
case "subagent":
|
||||
scenarioSubagent(enc, scanner)
|
||||
case "all-tools":
|
||||
scenarioAllTools(enc, scanner)
|
||||
case "multi-turn":
|
||||
scenarioMultiTurn(enc)
|
||||
case "diff-expansion-setup":
|
||||
scenarioDiffExpansionSetup(enc)
|
||||
case "diff-update-setup":
|
||||
scenarioDiffUpdateSetup(enc)
|
||||
case "diff-update-modify":
|
||||
scenarioDiffUpdateModify(enc)
|
||||
case "untracked-file-setup":
|
||||
scenarioUntrackedFileSetup(enc)
|
||||
case "untracked-file-modify":
|
||||
scenarioUntrackedFileModify(enc)
|
||||
case "clarification":
|
||||
scenarioClarification(enc)
|
||||
case "clarification-timeout":
|
||||
scenarioClarificationTimeout(enc)
|
||||
default:
|
||||
emitTextBlock(enc, "Unknown e2e scenario: "+name+". Available: simple-message, read-and-edit, permission-flow, error, subagent, all-tools, multi-turn, diff-expansion-setup, diff-update-setup, diff-update-modify, untracked-file-setup, untracked-file-modify, clarification, clarification-timeout", "")
|
||||
func emitPredefinedScenario(e *emitter, name string) {
|
||||
if fn, ok := scenarioRegistry[name]; ok {
|
||||
fn(e)
|
||||
} else {
|
||||
e.text("Unknown e2e scenario: " + name + ". Available: simple-message, read-and-edit, permission-flow, error, subagent, all-tools, multi-turn, diff-expansion-setup, diff-update-setup, diff-update-modify, untracked-file-setup, untracked-file-modify, clarification, clarification-timeout")
|
||||
}
|
||||
}
|
||||
|
||||
// scenarioSimpleMessage: text only with fixed 100ms delays.
|
||||
func scenarioSimpleMessage(enc *json.Encoder) {
|
||||
func scenarioSimpleMessage(e *emitter) {
|
||||
fixedDelay(100)
|
||||
_ = enc.Encode(AssistantMsg{
|
||||
Type: TypeAssistant,
|
||||
Message: AssistantBody{
|
||||
Role: "assistant",
|
||||
Content: []ContentBlock{
|
||||
{Type: BlockThinking, Thinking: "Processing the request..."},
|
||||
},
|
||||
Model: "mock-default",
|
||||
Usage: defaultUsage(),
|
||||
},
|
||||
})
|
||||
e.thought("Processing the request...")
|
||||
|
||||
fixedDelay(100)
|
||||
_ = enc.Encode(AssistantMsg{
|
||||
Type: TypeAssistant,
|
||||
Message: AssistantBody{
|
||||
Role: "assistant",
|
||||
Content: []ContentBlock{
|
||||
{Type: BlockText, Text: "This is a simple mock response for e2e testing."},
|
||||
},
|
||||
Model: "mock-default",
|
||||
StopReason: "end_turn",
|
||||
Usage: defaultUsage(),
|
||||
},
|
||||
})
|
||||
e.text("This is a simple mock response for e2e testing.")
|
||||
}
|
||||
|
||||
// scenarioReadAndEdit: read -> edit -> text with fixed delays, using real files.
|
||||
func scenarioReadAndEdit(enc *json.Encoder, scanner *bufio.Scanner) {
|
||||
func scenarioReadAndEdit(e *emitter) {
|
||||
f := randomFile()
|
||||
snippet := readFileSnippet(f.absPath, 20)
|
||||
oldStr, newStr := pickEditableFragment(f.absPath)
|
||||
@@ -88,29 +58,11 @@ func scenarioReadAndEdit(enc *json.Encoder, scanner *bufio.Scanner) {
|
||||
|
||||
// Read file
|
||||
readID := nextToolID()
|
||||
_ = enc.Encode(AssistantMsg{
|
||||
Type: TypeAssistant,
|
||||
Message: AssistantBody{
|
||||
Role: "assistant",
|
||||
Content: []ContentBlock{
|
||||
{Type: BlockToolUse, ID: readID, Name: ToolRead, Input: map[string]any{"file_path": f.absPath}},
|
||||
},
|
||||
Model: "mock-default",
|
||||
StopReason: "tool_use",
|
||||
Usage: defaultUsage(),
|
||||
},
|
||||
})
|
||||
|
||||
e.startTool(readID, "Read "+f.relPath, acp.ToolKindRead,
|
||||
map[string]any{"file_path": f.absPath},
|
||||
acp.ToolCallLocation{Path: f.absPath})
|
||||
fixedDelay(50)
|
||||
_ = enc.Encode(UserMsg{
|
||||
Type: TypeUser,
|
||||
Message: UserMsgBody{
|
||||
Role: "user",
|
||||
Content: []ContentBlock{
|
||||
{Type: BlockToolResult, ToolUseID: readID, Content: snippet},
|
||||
},
|
||||
},
|
||||
})
|
||||
e.completeTool(readID, map[string]any{"content": snippet})
|
||||
|
||||
fixedDelay(50)
|
||||
|
||||
@@ -121,42 +73,25 @@ func scenarioReadAndEdit(enc *json.Encoder, scanner *bufio.Scanner) {
|
||||
"old_string": oldStr,
|
||||
"new_string": newStr,
|
||||
}
|
||||
_ = enc.Encode(AssistantMsg{
|
||||
Type: TypeAssistant,
|
||||
Message: AssistantBody{
|
||||
Role: "assistant",
|
||||
Content: []ContentBlock{
|
||||
{Type: BlockToolUse, ID: editID, Name: ToolEdit, Input: editInput},
|
||||
},
|
||||
Model: "mock-default",
|
||||
StopReason: "tool_use",
|
||||
Usage: defaultUsage(),
|
||||
},
|
||||
})
|
||||
e.startTool(editID, "Edit "+f.relPath, acp.ToolKindEdit, editInput,
|
||||
acp.ToolCallLocation{Path: f.absPath})
|
||||
|
||||
allowed := requestPermission(enc, scanner, ToolEdit, editID, editInput)
|
||||
allowed := e.requestPermission(editID, "Edit "+f.relPath, acp.ToolKindEdit, editInput)
|
||||
|
||||
fixedDelay(50)
|
||||
if allowed {
|
||||
_ = enc.Encode(UserMsg{
|
||||
Type: TypeUser,
|
||||
Message: UserMsgBody{
|
||||
Role: "user",
|
||||
Content: []ContentBlock{
|
||||
{Type: BlockToolResult, ToolUseID: editID, Content: "File edited successfully: " + f.absPath},
|
||||
},
|
||||
},
|
||||
})
|
||||
e.completeTool(editID, map[string]any{"result": "File edited successfully: " + f.absPath})
|
||||
} else {
|
||||
emitTextBlock(enc, "Edit was denied.", "")
|
||||
e.completeTool(editID, map[string]any{"result": "Edit was denied"})
|
||||
e.text("Edit was denied.")
|
||||
}
|
||||
|
||||
fixedDelay(50)
|
||||
emitTextBlock(enc, "Read and edit scenario complete.", "")
|
||||
e.text("Read and edit scenario complete.")
|
||||
}
|
||||
|
||||
// scenarioPermissionFlow: tool requiring permission with fixed delays.
|
||||
func scenarioPermissionFlow(enc *json.Encoder, scanner *bufio.Scanner) {
|
||||
func scenarioPermissionFlow(e *emitter) {
|
||||
fixedDelay(50)
|
||||
|
||||
bashID := nextToolID()
|
||||
@@ -165,90 +100,51 @@ func scenarioPermissionFlow(enc *json.Encoder, scanner *bufio.Scanner) {
|
||||
"description": "Test permission flow",
|
||||
}
|
||||
|
||||
_ = enc.Encode(AssistantMsg{
|
||||
Type: TypeAssistant,
|
||||
Message: AssistantBody{
|
||||
Role: "assistant",
|
||||
Content: []ContentBlock{
|
||||
{Type: BlockToolUse, ID: bashID, Name: ToolBash, Input: bashInput},
|
||||
},
|
||||
Model: "mock-default",
|
||||
StopReason: "tool_use",
|
||||
Usage: defaultUsage(),
|
||||
},
|
||||
})
|
||||
e.startTool(bashID, "Test permissions", acp.ToolKindExecute, bashInput)
|
||||
|
||||
allowed := requestPermission(enc, scanner, ToolBash, bashID, bashInput)
|
||||
allowed := e.requestPermission(bashID, "Test permissions", acp.ToolKindExecute, bashInput)
|
||||
|
||||
fixedDelay(50)
|
||||
if allowed {
|
||||
_ = enc.Encode(UserMsg{
|
||||
Type: TypeUser,
|
||||
Message: UserMsgBody{
|
||||
Role: "user",
|
||||
Content: []ContentBlock{
|
||||
{Type: BlockToolResult, ToolUseID: bashID, Content: "testing permissions"},
|
||||
},
|
||||
},
|
||||
})
|
||||
emitTextBlock(enc, "Permission was granted and command executed.", "")
|
||||
e.completeTool(bashID, map[string]any{"output": "testing permissions"})
|
||||
e.text("Permission was granted and command executed.")
|
||||
} else {
|
||||
emitTextBlock(enc, "Permission was denied.", "")
|
||||
e.completeTool(bashID, map[string]any{"output": "Permission denied"})
|
||||
e.text("Permission was denied.")
|
||||
}
|
||||
}
|
||||
|
||||
// scenarioError: error result with fixed delays.
|
||||
func scenarioError(enc *json.Encoder) {
|
||||
func scenarioError(e *emitter) {
|
||||
fixedDelay(100)
|
||||
emitTextBlock(enc, "About to encounter an error...", "")
|
||||
e.text("About to encounter an error...")
|
||||
fixedDelay(100)
|
||||
emitResult(enc, true, "E2E test error: simulated failure")
|
||||
e.text("E2E test error: simulated failure")
|
||||
}
|
||||
|
||||
// scenarioSubagent: subagent with child messages and fixed delays.
|
||||
func scenarioSubagent(enc *json.Encoder, scanner *bufio.Scanner) {
|
||||
func scenarioSubagent(e *emitter) {
|
||||
taskToolID := nextToolID()
|
||||
fixedDelay(50)
|
||||
|
||||
_ = enc.Encode(AssistantMsg{
|
||||
Type: TypeAssistant,
|
||||
Message: AssistantBody{
|
||||
Role: "assistant",
|
||||
Content: []ContentBlock{
|
||||
{Type: BlockToolUse, ID: taskToolID, Name: ToolTask, Input: map[string]any{
|
||||
"description": "E2E subagent test",
|
||||
"prompt": "Run e2e subagent scenario",
|
||||
}},
|
||||
},
|
||||
Model: "mock-default",
|
||||
StopReason: "tool_use",
|
||||
Usage: defaultUsage(),
|
||||
},
|
||||
})
|
||||
e.startTool(taskToolID, "E2E subagent test", acp.ToolKindOther,
|
||||
map[string]any{
|
||||
"description": "E2E subagent test",
|
||||
"prompt": "Run e2e subagent scenario",
|
||||
})
|
||||
|
||||
fixedDelay(50)
|
||||
_ = enc.Encode(SystemMsg{Type: TypeSystem, SessionID: sessionID, SessionStatus: "active"})
|
||||
e.text("Subagent working on the task...")
|
||||
|
||||
fixedDelay(50)
|
||||
emitTextBlock(enc, "Subagent working on the task...", taskToolID)
|
||||
e.completeTool(taskToolID, map[string]any{"result": "E2E subagent completed"})
|
||||
|
||||
fixedDelay(50)
|
||||
_ = enc.Encode(UserMsg{
|
||||
Type: TypeUser,
|
||||
Message: UserMsgBody{
|
||||
Role: "user",
|
||||
Content: []ContentBlock{
|
||||
{Type: BlockToolResult, ToolUseID: taskToolID, Content: "E2E subagent completed"},
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
fixedDelay(50)
|
||||
emitTextBlock(enc, "Subagent scenario complete.", "")
|
||||
e.text("Subagent scenario complete.")
|
||||
}
|
||||
|
||||
// scenarioAllTools: one of each tool type with fixed delays, using real files.
|
||||
func scenarioAllTools(enc *json.Encoder, scanner *bufio.Scanner) {
|
||||
func scenarioAllTools(e *emitter) {
|
||||
used := map[string]bool{}
|
||||
readFile := randomFile()
|
||||
used[readFile.absPath] = true
|
||||
@@ -257,131 +153,97 @@ func scenarioAllTools(enc *json.Encoder, scanner *bufio.Scanner) {
|
||||
editFile := randomFileExcluding(used)
|
||||
|
||||
fixedDelay(50)
|
||||
emitThinkingBlock(enc, "Running all tools...", "")
|
||||
e.thought("Running all tools...")
|
||||
|
||||
scenarioAllToolsReadGrep(enc, readFile, grepFile)
|
||||
scenarioAllToolsEditBash(enc, scanner, editFile)
|
||||
scenarioAllToolsReadGrep(e, readFile, grepFile)
|
||||
scenarioAllToolsEditBash(e, editFile)
|
||||
|
||||
// WebFetch
|
||||
fixedDelay(50)
|
||||
webID := nextToolID()
|
||||
_ = enc.Encode(AssistantMsg{
|
||||
Type: TypeAssistant,
|
||||
Message: AssistantBody{
|
||||
Role: "assistant",
|
||||
Content: []ContentBlock{{Type: BlockToolUse, ID: webID, Name: ToolWebFetch, Input: map[string]any{"url": "https://example.com", "prompt": "Summarize"}}},
|
||||
Model: "mock-default", StopReason: "tool_use", Usage: defaultUsage(),
|
||||
},
|
||||
})
|
||||
e.startTool(webID, "Fetch example.com", acp.ToolKindFetch,
|
||||
map[string]any{"url": "https://example.com", "prompt": "Summarize"})
|
||||
fixedDelay(50)
|
||||
_ = enc.Encode(UserMsg{Type: TypeUser, Message: UserMsgBody{Role: "user", Content: []ContentBlock{{Type: BlockToolResult, ToolUseID: webID, Content: "Example page content"}}}})
|
||||
e.completeTool(webID, map[string]any{"content": "Example page content"})
|
||||
|
||||
fixedDelay(50)
|
||||
emitTextBlock(enc, "All tools scenario complete.", "")
|
||||
e.text("All tools scenario complete.")
|
||||
}
|
||||
|
||||
func scenarioAllToolsReadGrep(enc *json.Encoder, readFile, grepFile fileInfo) {
|
||||
func scenarioAllToolsReadGrep(e *emitter, readFile, grepFile fileInfo) {
|
||||
// Read
|
||||
fixedDelay(50)
|
||||
readID := nextToolID()
|
||||
snippet := readFileSnippet(readFile.absPath, 20)
|
||||
_ = enc.Encode(AssistantMsg{
|
||||
Type: TypeAssistant,
|
||||
Message: AssistantBody{
|
||||
Role: "assistant",
|
||||
Content: []ContentBlock{{Type: BlockToolUse, ID: readID, Name: ToolRead, Input: map[string]any{"file_path": readFile.absPath}}},
|
||||
Model: "mock-default", StopReason: "tool_use", Usage: defaultUsage(),
|
||||
},
|
||||
})
|
||||
e.startTool(readID, "Read "+readFile.relPath, acp.ToolKindRead,
|
||||
map[string]any{"file_path": readFile.absPath},
|
||||
acp.ToolCallLocation{Path: readFile.absPath})
|
||||
fixedDelay(50)
|
||||
_ = enc.Encode(UserMsg{Type: TypeUser, Message: UserMsgBody{Role: "user", Content: []ContentBlock{{Type: BlockToolResult, ToolUseID: readID, Content: snippet}}}})
|
||||
e.completeTool(readID, map[string]any{"content": snippet})
|
||||
|
||||
// Grep
|
||||
fixedDelay(50)
|
||||
grepID := nextToolID()
|
||||
_ = enc.Encode(AssistantMsg{
|
||||
Type: TypeAssistant,
|
||||
Message: AssistantBody{
|
||||
Role: "assistant",
|
||||
Content: []ContentBlock{{Type: BlockToolUse, ID: grepID, Name: ToolGrep, Input: map[string]any{"pattern": "func ", "path": grepFile.absPath}}},
|
||||
Model: "mock-default", StopReason: "tool_use", Usage: defaultUsage(),
|
||||
},
|
||||
})
|
||||
e.startTool(grepID, "Search for \"func \"", acp.ToolKindSearch,
|
||||
map[string]any{"pattern": "func ", "path": grepFile.absPath})
|
||||
fixedDelay(50)
|
||||
paths := randomFilePaths(3)
|
||||
var grepResults []string
|
||||
for i, p := range paths {
|
||||
grepResults = append(grepResults, fmt.Sprintf("%s:%d: func found here", p, (i+1)*10))
|
||||
}
|
||||
_ = enc.Encode(UserMsg{Type: TypeUser, Message: UserMsgBody{Role: "user", Content: []ContentBlock{{Type: BlockToolResult, ToolUseID: grepID, Content: strings.Join(grepResults, "\n")}}}})
|
||||
e.completeTool(grepID, map[string]any{"matches": strings.Join(grepResults, "\n")})
|
||||
}
|
||||
|
||||
func scenarioAllToolsEditBash(enc *json.Encoder, scanner *bufio.Scanner, editFile fileInfo) {
|
||||
func scenarioAllToolsEditBash(e *emitter, editFile fileInfo) {
|
||||
// Edit (with permission)
|
||||
fixedDelay(50)
|
||||
editID := nextToolID()
|
||||
oldStr, newStr := pickEditableFragment(editFile.absPath)
|
||||
editInput := map[string]any{"file_path": editFile.absPath, "old_string": oldStr, "new_string": newStr}
|
||||
_ = enc.Encode(AssistantMsg{
|
||||
Type: TypeAssistant,
|
||||
Message: AssistantBody{
|
||||
Role: "assistant",
|
||||
Content: []ContentBlock{{Type: BlockToolUse, ID: editID, Name: ToolEdit, Input: editInput}},
|
||||
Model: "mock-default", StopReason: "tool_use", Usage: defaultUsage(),
|
||||
},
|
||||
})
|
||||
allowed := requestPermission(enc, scanner, ToolEdit, editID, editInput)
|
||||
e.startTool(editID, "Edit "+editFile.relPath, acp.ToolKindEdit, editInput,
|
||||
acp.ToolCallLocation{Path: editFile.absPath})
|
||||
allowed := e.requestPermission(editID, "Edit "+editFile.relPath, acp.ToolKindEdit, editInput)
|
||||
fixedDelay(50)
|
||||
if allowed {
|
||||
_ = enc.Encode(UserMsg{Type: TypeUser, Message: UserMsgBody{Role: "user", Content: []ContentBlock{{Type: BlockToolResult, ToolUseID: editID, Content: "File edited successfully: " + editFile.absPath}}}})
|
||||
e.completeTool(editID, map[string]any{"result": "File edited successfully: " + editFile.absPath})
|
||||
} else {
|
||||
emitTextBlock(enc, "Edit denied.", "")
|
||||
e.completeTool(editID, map[string]any{"result": "Edit denied"})
|
||||
e.text("Edit denied.")
|
||||
}
|
||||
|
||||
// Bash (with permission)
|
||||
fixedDelay(50)
|
||||
bashID := nextToolID()
|
||||
bashInput := map[string]any{"command": "echo done", "description": "Print done"}
|
||||
_ = enc.Encode(AssistantMsg{
|
||||
Type: TypeAssistant,
|
||||
Message: AssistantBody{
|
||||
Role: "assistant",
|
||||
Content: []ContentBlock{{Type: BlockToolUse, ID: bashID, Name: ToolBash, Input: bashInput}},
|
||||
Model: "mock-default", StopReason: "tool_use", Usage: defaultUsage(),
|
||||
},
|
||||
})
|
||||
allowed = requestPermission(enc, scanner, ToolBash, bashID, bashInput)
|
||||
e.startTool(bashID, "Print done", acp.ToolKindExecute, bashInput)
|
||||
allowed = e.requestPermission(bashID, "Print done", acp.ToolKindExecute, bashInput)
|
||||
fixedDelay(50)
|
||||
if allowed {
|
||||
_ = enc.Encode(UserMsg{Type: TypeUser, Message: UserMsgBody{Role: "user", Content: []ContentBlock{{Type: BlockToolResult, ToolUseID: bashID, Content: "done"}}}})
|
||||
e.completeTool(bashID, map[string]any{"output": "done"})
|
||||
} else {
|
||||
emitTextBlock(enc, "Bash denied.", "")
|
||||
e.completeTool(bashID, map[string]any{"output": "Permission denied"})
|
||||
e.text("Bash denied.")
|
||||
}
|
||||
}
|
||||
|
||||
// scenarioMultiTurn: minimal response for multi-turn test.
|
||||
func scenarioMultiTurn(enc *json.Encoder) {
|
||||
func scenarioMultiTurn(e *emitter) {
|
||||
fixedDelay(50)
|
||||
emitTextBlock(enc, "Multi-turn response ready. Send another message to continue.", "")
|
||||
e.text("Multi-turn response ready. Send another message to continue.")
|
||||
}
|
||||
|
||||
// scenarioDiffExpansionSetup: creates a committed file and then modifies it,
|
||||
// leaving an uncommitted diff that the UI can display with expansion enabled.
|
||||
//
|
||||
// Uses 200 lines with hunks at lines 50 (mid-top) and 150 (mid-bottom), so the
|
||||
// diff viewer collapses ~90 lines between hunks and ~45 lines at each end.
|
||||
// This gives three separate expand handles for the e2e test to interact with.
|
||||
func scenarioDiffExpansionSetup(enc *json.Encoder) {
|
||||
func scenarioDiffExpansionSetup(e *emitter) {
|
||||
fixedDelay(50)
|
||||
|
||||
wd, err := os.Getwd()
|
||||
if err != nil {
|
||||
emitTextBlock(enc, "diff-expansion-setup: getwd failed: "+err.Error(), "")
|
||||
e.text("diff-expansion-setup: getwd failed: " + err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
// Build a 200-line file with distinct content per line so assertions can
|
||||
// target specific line text after expanding collapsed regions.
|
||||
const totalLines = 200
|
||||
originalLines := make([]string, totalLines)
|
||||
for i := 0; i < totalLines; i++ {
|
||||
@@ -391,58 +253,28 @@ func scenarioDiffExpansionSetup(enc *json.Encoder) {
|
||||
|
||||
filePath := "expansion_test.go"
|
||||
if err := os.WriteFile(filePath, []byte(original), 0o644); err != nil {
|
||||
emitTextBlock(enc, "diff-expansion-setup: write failed: "+err.Error(), "")
|
||||
e.text("diff-expansion-setup: write failed: " + err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
gitEnv := append(os.Environ(),
|
||||
"GIT_AUTHOR_NAME=Mock Agent",
|
||||
"GIT_AUTHOR_EMAIL=mock@test.local",
|
||||
"GIT_COMMITTER_NAME=Mock Agent",
|
||||
"GIT_COMMITTER_EMAIL=mock@test.local",
|
||||
)
|
||||
|
||||
runGitCmd := func(args ...string) error {
|
||||
cmd := exec.Command("git", append([]string{
|
||||
"-c", "commit.gpgsign=false",
|
||||
"-c", "tag.gpgsign=false",
|
||||
}, args...)...)
|
||||
cmd.Dir = wd
|
||||
cmd.Env = gitEnv
|
||||
out, cmdErr := cmd.CombinedOutput()
|
||||
if cmdErr != nil {
|
||||
fmt.Fprintf(os.Stderr, "mock-agent: git %v failed: %v\nOutput: %s\n", args, cmdErr, out)
|
||||
}
|
||||
return cmdErr
|
||||
}
|
||||
|
||||
// Clean up from any previous test run so the add+commit is never a no-op.
|
||||
// git rm --force removes the file from both the index and worktree;
|
||||
// the commit records the deletion. Errors are ignored (file may not exist).
|
||||
runGitCmd := makeGitRunner(wd)
|
||||
_ = runGitCmd("rm", "--force", filePath)
|
||||
_ = runGitCmd("commit", "-m", "cleanup expansion_test.go")
|
||||
|
||||
// Re-write the original content (git rm deleted it from the worktree).
|
||||
if err := os.WriteFile(filePath, []byte(original), 0o644); err != nil {
|
||||
emitTextBlock(enc, "diff-expansion-setup: re-write failed: "+err.Error(), "")
|
||||
e.text("diff-expansion-setup: re-write failed: " + err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
if err := runGitCmd("add", filePath); err != nil {
|
||||
emitTextBlock(enc, "diff-expansion-setup: git add failed", "")
|
||||
e.text("diff-expansion-setup: git add failed")
|
||||
return
|
||||
}
|
||||
if err := runGitCmd("commit", "-m", "add expansion_test.go for e2e diff expansion test"); err != nil {
|
||||
emitTextBlock(enc, "diff-expansion-setup: git commit failed", "")
|
||||
e.text("diff-expansion-setup: git commit failed")
|
||||
return
|
||||
}
|
||||
|
||||
// Modify line 50 (mid-top, index 49) and line 150 (mid-bottom, index 149).
|
||||
// With 3 lines of context per hunk, the diff collapses:
|
||||
// - lines 1-46 (~46 lines) above the first hunk
|
||||
// - lines 54-146 (~93 lines) between the two hunks
|
||||
// - lines 154-200 (~47 lines) below the second hunk
|
||||
// Each collapsed region gets its own expand handle in the diff viewer.
|
||||
modifiedLines := make([]string, totalLines)
|
||||
copy(modifiedLines, originalLines)
|
||||
modifiedLines[49] = "func modified_mid_top() { /* HUNK_TOP - modified line 50 */ }"
|
||||
@@ -450,141 +282,107 @@ func scenarioDiffExpansionSetup(enc *json.Encoder) {
|
||||
modified := strings.Join(modifiedLines, "\n") + "\n"
|
||||
|
||||
if err := os.WriteFile(filePath, []byte(modified), 0o644); err != nil {
|
||||
emitTextBlock(enc, "diff-expansion-setup: write modified failed: "+err.Error(), "")
|
||||
e.text("diff-expansion-setup: write modified failed: " + err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
fixedDelay(100)
|
||||
emitTextBlock(enc, "diff-expansion-setup complete: expansion_test.go has two-hunk uncommitted diff (lines 50 and 150 of 200).", "")
|
||||
e.text("diff-expansion-setup complete: expansion_test.go has two-hunk uncommitted diff (lines 50 and 150 of 200).")
|
||||
}
|
||||
|
||||
// scenarioDiffUpdateSetup creates a simple file, commits it, then modifies it
|
||||
// to leave an uncommitted diff. This is the first step of the diff-update test.
|
||||
// The file content is simple so assertions can verify exact diff content.
|
||||
func scenarioDiffUpdateSetup(enc *json.Encoder) {
|
||||
// scenarioDiffUpdateSetup creates a simple file, commits it, then modifies it.
|
||||
func scenarioDiffUpdateSetup(e *emitter) {
|
||||
fixedDelay(50)
|
||||
|
||||
wd, err := os.Getwd()
|
||||
if err != nil {
|
||||
emitTextBlock(enc, "diff-update-setup: getwd failed: "+err.Error(), "")
|
||||
e.text("diff-update-setup: getwd failed: " + err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
filePath := "diff_update_test.txt"
|
||||
originalContent := "line 1: original\nline 2: unchanged\nline 3: original\n"
|
||||
|
||||
// Write original content
|
||||
if err := os.WriteFile(filePath, []byte(originalContent), 0o644); err != nil {
|
||||
emitTextBlock(enc, "diff-update-setup: write failed: "+err.Error(), "")
|
||||
e.text("diff-update-setup: write failed: " + err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
gitEnv := append(os.Environ(),
|
||||
"GIT_AUTHOR_NAME=Mock Agent",
|
||||
"GIT_AUTHOR_EMAIL=mock@test.local",
|
||||
"GIT_COMMITTER_NAME=Mock Agent",
|
||||
"GIT_COMMITTER_EMAIL=mock@test.local",
|
||||
)
|
||||
|
||||
runGitCmd := func(args ...string) error {
|
||||
cmd := exec.Command("git", append([]string{
|
||||
"-c", "commit.gpgsign=false",
|
||||
"-c", "tag.gpgsign=false",
|
||||
}, args...)...)
|
||||
cmd.Dir = wd
|
||||
cmd.Env = gitEnv
|
||||
out, cmdErr := cmd.CombinedOutput()
|
||||
if cmdErr != nil {
|
||||
fmt.Fprintf(os.Stderr, "mock-agent: git %v failed: %v\nOutput: %s\n", args, cmdErr, out)
|
||||
}
|
||||
return cmdErr
|
||||
}
|
||||
|
||||
// Clean up from any previous test run
|
||||
runGitCmd := makeGitRunner(wd)
|
||||
_ = runGitCmd("rm", "--force", filePath)
|
||||
_ = runGitCmd("commit", "-m", "cleanup diff_update_test.txt")
|
||||
|
||||
// Re-write and commit original content
|
||||
if err := os.WriteFile(filePath, []byte(originalContent), 0o644); err != nil {
|
||||
emitTextBlock(enc, "diff-update-setup: re-write failed: "+err.Error(), "")
|
||||
e.text("diff-update-setup: re-write failed: " + err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
if err := runGitCmd("add", filePath); err != nil {
|
||||
emitTextBlock(enc, "diff-update-setup: git add failed", "")
|
||||
e.text("diff-update-setup: git add failed")
|
||||
return
|
||||
}
|
||||
if err := runGitCmd("commit", "-m", "add diff_update_test.txt"); err != nil {
|
||||
emitTextBlock(enc, "diff-update-setup: git commit failed", "")
|
||||
e.text("diff-update-setup: git commit failed")
|
||||
return
|
||||
}
|
||||
|
||||
// Modify the file to create an uncommitted diff
|
||||
modifiedContent := "line 1: FIRST_MODIFICATION\nline 2: unchanged\nline 3: original\n"
|
||||
if err := os.WriteFile(filePath, []byte(modifiedContent), 0o644); err != nil {
|
||||
emitTextBlock(enc, "diff-update-setup: write modified failed: "+err.Error(), "")
|
||||
e.text("diff-update-setup: write modified failed: " + err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
fixedDelay(100)
|
||||
emitTextBlock(enc, "diff-update-setup complete: diff_update_test.txt has FIRST_MODIFICATION", "")
|
||||
e.text("diff-update-setup complete: diff_update_test.txt has FIRST_MODIFICATION")
|
||||
}
|
||||
|
||||
// scenarioDiffUpdateModify modifies the diff_update_test.txt file again,
|
||||
// changing the diff content. This tests that the UI updates the diff display
|
||||
// when files change after the initial diff was shown.
|
||||
func scenarioDiffUpdateModify(enc *json.Encoder) {
|
||||
// scenarioDiffUpdateModify modifies the diff_update_test.txt file again.
|
||||
func scenarioDiffUpdateModify(e *emitter) {
|
||||
fixedDelay(50)
|
||||
|
||||
filePath := "diff_update_test.txt"
|
||||
|
||||
// Modify the file again with different content
|
||||
modifiedContent := "line 1: SECOND_MODIFICATION\nline 2: unchanged\nline 3: ALSO_CHANGED\n"
|
||||
if err := os.WriteFile(filePath, []byte(modifiedContent), 0o644); err != nil {
|
||||
emitTextBlock(enc, "diff-update-modify: write failed: "+err.Error(), "")
|
||||
e.text("diff-update-modify: write failed: " + err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
fixedDelay(100)
|
||||
emitTextBlock(enc, "diff-update-modify complete: diff_update_test.txt now has SECOND_MODIFICATION", "")
|
||||
e.text("diff-update-modify complete: diff_update_test.txt now has SECOND_MODIFICATION")
|
||||
}
|
||||
|
||||
// scenarioUntrackedFileSetup creates a new untracked file (not staged, not committed).
|
||||
// This tests that the UI shows diffs for untracked files.
|
||||
func scenarioUntrackedFileSetup(enc *json.Encoder) {
|
||||
// scenarioUntrackedFileSetup creates a new untracked file.
|
||||
func scenarioUntrackedFileSetup(e *emitter) {
|
||||
fixedDelay(50)
|
||||
|
||||
filePath := "untracked_test.txt"
|
||||
content := "line 1: INITIAL_CONTENT\nline 2: some text\n"
|
||||
|
||||
// Remove any existing file first
|
||||
_ = os.Remove(filePath)
|
||||
|
||||
// Write new untracked file
|
||||
if err := os.WriteFile(filePath, []byte(content), 0o644); err != nil {
|
||||
emitTextBlock(enc, "untracked-file-setup: write failed: "+err.Error(), "")
|
||||
e.text("untracked-file-setup: write failed: " + err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
fixedDelay(100)
|
||||
emitTextBlock(enc, "untracked-file-setup complete: untracked_test.txt has INITIAL_CONTENT", "")
|
||||
e.text("untracked-file-setup complete: untracked_test.txt has INITIAL_CONTENT")
|
||||
}
|
||||
|
||||
// scenarioUntrackedFileModify modifies the untracked file created by untracked-file-setup.
|
||||
// This tests that the UI updates the diff when an untracked file is modified.
|
||||
func scenarioUntrackedFileModify(enc *json.Encoder) {
|
||||
// scenarioUntrackedFileModify modifies the untracked file.
|
||||
func scenarioUntrackedFileModify(e *emitter) {
|
||||
fixedDelay(50)
|
||||
|
||||
filePath := "untracked_test.txt"
|
||||
content := "line 1: MODIFIED_CONTENT\nline 2: some text\nline 3: NEW_LINE\n"
|
||||
|
||||
if err := os.WriteFile(filePath, []byte(content), 0o644); err != nil {
|
||||
emitTextBlock(enc, "untracked-file-modify: write failed: "+err.Error(), "")
|
||||
e.text("untracked-file-modify: write failed: " + err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
fixedDelay(100)
|
||||
emitTextBlock(enc, "untracked-file-modify complete: untracked_test.txt now has MODIFIED_CONTENT", "")
|
||||
e.text("untracked-file-modify complete: untracked_test.txt now has MODIFIED_CONTENT")
|
||||
}
|
||||
|
||||
// clarificationQuestionArgs returns the MCP arguments for the clarification question.
|
||||
@@ -600,41 +398,67 @@ func clarificationQuestionArgs() map[string]any {
|
||||
}
|
||||
|
||||
// scenarioClarification: happy path — ask a question via MCP and wait for the answer.
|
||||
func scenarioClarification(enc *json.Encoder) {
|
||||
func scenarioClarification(e *emitter) {
|
||||
fixedDelay(100)
|
||||
emitTextBlock(enc, "Let me ask you a question about the project setup.", "")
|
||||
e.text("Let me ask you a question about the project setup.")
|
||||
|
||||
result, err := callMCPTool("kandev", "ask_user_question", clarificationQuestionArgs())
|
||||
if err != nil {
|
||||
emitTextBlock(enc, fmt.Sprintf("Question failed: %s", err), "")
|
||||
e.text(fmt.Sprintf("Question failed: %s", err))
|
||||
return
|
||||
}
|
||||
|
||||
fixedDelay(50)
|
||||
emitTextBlock(enc, fmt.Sprintf("You answered: %s", result), "")
|
||||
e.text(fmt.Sprintf("You answered: %s", result))
|
||||
}
|
||||
|
||||
// scenarioClarificationTimeout: ask a question with a short timeout, then continue.
|
||||
// The MCP call times out after 5s so the agent's turn completes. The user can still
|
||||
// answer later, which triggers the event fallback path (new turn).
|
||||
func scenarioClarificationTimeout(enc *json.Encoder) {
|
||||
func scenarioClarificationTimeout(e *emitter) {
|
||||
fixedDelay(100)
|
||||
emitTextBlock(enc, "Let me ask you a question about the project setup.", "")
|
||||
e.text("Let me ask you a question about the project setup.")
|
||||
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
ctx, cancel := contextWithTimeout(5)
|
||||
defer cancel()
|
||||
|
||||
result, err := callMCPToolCtx(ctx, "kandev", "ask_user_question", clarificationQuestionArgs())
|
||||
if err != nil {
|
||||
fixedDelay(50)
|
||||
if ctx.Err() != nil {
|
||||
emitTextBlock(enc, "Question timed out, continuing without answer.", "")
|
||||
e.text("Question timed out, continuing without answer.")
|
||||
} else {
|
||||
emitTextBlock(enc, fmt.Sprintf("Question failed: %s", err), "")
|
||||
e.text(fmt.Sprintf("Question failed: %s", err))
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
fixedDelay(50)
|
||||
emitTextBlock(enc, fmt.Sprintf("You answered: %s", result), "")
|
||||
e.text(fmt.Sprintf("You answered: %s", result))
|
||||
}
|
||||
|
||||
// makeGitRunner returns a function that runs git commands in the given directory.
|
||||
func makeGitRunner(wd string) func(args ...string) error {
|
||||
gitEnv := append(os.Environ(),
|
||||
"GIT_AUTHOR_NAME=Mock Agent",
|
||||
"GIT_AUTHOR_EMAIL=mock@test.local",
|
||||
"GIT_COMMITTER_NAME=Mock Agent",
|
||||
"GIT_COMMITTER_EMAIL=mock@test.local",
|
||||
)
|
||||
return func(args ...string) error {
|
||||
cmd := exec.Command("git", append([]string{
|
||||
"-c", "commit.gpgsign=false",
|
||||
"-c", "tag.gpgsign=false",
|
||||
}, args...)...)
|
||||
cmd.Dir = wd
|
||||
cmd.Env = gitEnv
|
||||
out, cmdErr := cmd.CombinedOutput()
|
||||
if cmdErr != nil {
|
||||
_, _ = fmt.Fprintf(logOutput, "mock-agent: git %v failed: %v\nOutput: %s\n", args, cmdErr, out)
|
||||
}
|
||||
return cmdErr
|
||||
}
|
||||
}
|
||||
|
||||
// contextWithTimeout creates a context with timeout in seconds.
|
||||
func contextWithTimeout(seconds int) (context.Context, context.CancelFunc) {
|
||||
return context.WithTimeout(context.Background(), time.Duration(seconds)*time.Second)
|
||||
}
|
||||
|
||||
@@ -7,6 +7,8 @@ import (
|
||||
"regexp"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
acp "github.com/coder/acp-go-sdk"
|
||||
)
|
||||
|
||||
// isScriptMode returns true if the command starts with "e2e:" prefix
|
||||
@@ -16,50 +18,50 @@ func isScriptMode(cmd string) bool {
|
||||
}
|
||||
|
||||
// executeScript processes a multi-line script command.
|
||||
func executeScript(enc *json.Encoder, fullPrompt, cmd string) {
|
||||
func executeScript(e *emitter, fullPrompt, cmd string) {
|
||||
lines := strings.Split(cmd, "\n")
|
||||
for _, line := range lines {
|
||||
line = strings.TrimSpace(line)
|
||||
if line == "" || strings.HasPrefix(line, "#") {
|
||||
continue
|
||||
}
|
||||
executeCommand(enc, fullPrompt, line)
|
||||
executeCommand(e, fullPrompt, line)
|
||||
}
|
||||
}
|
||||
|
||||
// executeCommand dispatches a single script command line.
|
||||
func executeCommand(enc *json.Encoder, fullPrompt, line string) {
|
||||
func executeCommand(e *emitter, fullPrompt, line string) {
|
||||
switch {
|
||||
case strings.HasPrefix(line, "e2e:message("):
|
||||
text := extractStringArg(line, "e2e:message(")
|
||||
emitTextBlock(enc, text, "")
|
||||
e.text(text)
|
||||
|
||||
case strings.HasPrefix(line, "e2e:thinking("):
|
||||
text := extractStringArg(line, "e2e:thinking(")
|
||||
emitThinkingBlock(enc, text, "")
|
||||
e.thought(text)
|
||||
|
||||
case strings.HasPrefix(line, "e2e:delay("):
|
||||
ms := extractIntArg(line, "e2e:delay(")
|
||||
fixedDelay(ms)
|
||||
|
||||
case strings.HasPrefix(line, "e2e:mcp:"):
|
||||
executeMCPCommand(enc, fullPrompt, line)
|
||||
executeMCPCommand(e, fullPrompt, line)
|
||||
|
||||
case strings.HasPrefix(line, "e2e:tool_use("):
|
||||
executeSimulatedToolUse(enc, line)
|
||||
executeSimulatedToolUse(e, line)
|
||||
|
||||
case strings.HasPrefix(line, "e2e:tool_result("):
|
||||
executeSimulatedToolResult(enc, line)
|
||||
executeSimulatedToolResult(e, line)
|
||||
}
|
||||
}
|
||||
|
||||
// executeMCPCommand parses and executes: e2e:mcp:<server>:<tool>(<json_args>)
|
||||
func executeMCPCommand(enc *json.Encoder, fullPrompt, line string) {
|
||||
func executeMCPCommand(e *emitter, fullPrompt, line string) {
|
||||
rest := strings.TrimPrefix(line, "e2e:mcp:")
|
||||
|
||||
colonIdx := strings.Index(rest, ":")
|
||||
if colonIdx < 0 {
|
||||
emitTextBlock(enc, "Script error: invalid MCP command: "+line, "")
|
||||
e.text("Script error: invalid MCP command: " + line)
|
||||
return
|
||||
}
|
||||
server := rest[:colonIdx]
|
||||
@@ -67,41 +69,40 @@ func executeMCPCommand(enc *json.Encoder, fullPrompt, line string) {
|
||||
|
||||
parenIdx := strings.Index(remainder, "(")
|
||||
if parenIdx < 0 {
|
||||
emitTextBlock(enc, "Script error: missing args in MCP command: "+line, "")
|
||||
e.text("Script error: missing args in MCP command: " + line)
|
||||
return
|
||||
}
|
||||
toolName := remainder[:parenIdx]
|
||||
closeIdx := strings.LastIndex(remainder, ")")
|
||||
if closeIdx <= parenIdx {
|
||||
emitTextBlock(enc, "Script error: missing closing paren in MCP command: "+line, "")
|
||||
e.text("Script error: missing closing paren in MCP command: " + line)
|
||||
return
|
||||
}
|
||||
argsStr := remainder[parenIdx+1 : closeIdx]
|
||||
|
||||
var args map[string]any
|
||||
if err := json.Unmarshal([]byte(argsStr), &args); err != nil {
|
||||
emitTextBlock(enc, fmt.Sprintf("Script error: bad MCP args JSON: %v", err), "")
|
||||
e.text(fmt.Sprintf("Script error: bad MCP args JSON: %v", err))
|
||||
return
|
||||
}
|
||||
|
||||
substituteContextPlaceholders(args, fullPrompt)
|
||||
|
||||
toolID := nextToolID()
|
||||
state.lastToolID = toolID
|
||||
emitToolUseBlock(enc, toolID, toolName, args)
|
||||
e.startTool(toolID, toolName, acp.ToolKindOther, args)
|
||||
|
||||
result, err := callMCPTool(server, toolName, args)
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "mock-agent: MCP call %s/%s failed: %v\n", server, toolName, err)
|
||||
emitToolResultBlock(enc, toolID, "MCP error: "+err.Error(), true)
|
||||
e.completeTool(toolID, map[string]any{"error": "MCP error: " + err.Error()})
|
||||
} else {
|
||||
emitToolResultBlock(enc, toolID, result, false)
|
||||
e.completeTool(toolID, map[string]any{"result": result})
|
||||
}
|
||||
}
|
||||
|
||||
// executeSimulatedToolUse emits a simulated tool_use block (no real execution).
|
||||
// executeSimulatedToolUse emits a simulated tool call start (no real execution).
|
||||
// Format: e2e:tool_use("name", {"key":"value"})
|
||||
func executeSimulatedToolUse(enc *json.Encoder, line string) {
|
||||
func executeSimulatedToolUse(e *emitter, line string) {
|
||||
inner := extractParenContent(line, "e2e:tool_use(")
|
||||
name, rest := extractFirstStringArg(inner)
|
||||
|
||||
@@ -111,21 +112,20 @@ func executeSimulatedToolUse(enc *json.Encoder, line string) {
|
||||
rest = strings.TrimPrefix(rest, ",")
|
||||
rest = strings.TrimSpace(rest)
|
||||
if err := json.Unmarshal([]byte(rest), &input); err != nil {
|
||||
emitTextBlock(enc, fmt.Sprintf("Script error: bad tool_use input JSON: %v", err), "")
|
||||
e.text(fmt.Sprintf("Script error: bad tool_use input JSON: %v", err))
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
toolID := nextToolID()
|
||||
state.lastToolID = toolID
|
||||
emitToolUseBlock(enc, toolID, name, input)
|
||||
e.startTool(toolID, name, acp.ToolKindOther, input)
|
||||
}
|
||||
|
||||
// executeSimulatedToolResult emits a tool_result for the last tool_use.
|
||||
// executeSimulatedToolResult emits a tool completion for the last tool_use.
|
||||
// Format: e2e:tool_result("content")
|
||||
func executeSimulatedToolResult(enc *json.Encoder, line string) {
|
||||
func executeSimulatedToolResult(e *emitter, line string) {
|
||||
content := extractStringArg(line, "e2e:tool_result(")
|
||||
emitToolResultBlock(enc, state.lastToolID, content, false)
|
||||
e.completeTool(acp.ToolCallId(state.lastToolID), map[string]any{"result": content})
|
||||
}
|
||||
|
||||
// --- Argument parsing helpers ---
|
||||
@@ -166,7 +166,6 @@ func extractFirstStringArg(s string) (string, string) {
|
||||
if len(s) == 0 || s[0] != '"' {
|
||||
return s, ""
|
||||
}
|
||||
// Find closing quote (handling escaped quotes)
|
||||
for i := 1; i < len(s); i++ {
|
||||
if s[i] == '\\' {
|
||||
i++ // skip escaped char
|
||||
|
||||
@@ -1,11 +1,12 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"context"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
|
||||
acp "github.com/coder/acp-go-sdk"
|
||||
"github.com/mark3labs/mcp-go/mcp"
|
||||
)
|
||||
|
||||
@@ -39,48 +40,13 @@ func TestExtractStringArg(t *testing.T) {
|
||||
prefix string
|
||||
want string
|
||||
}{
|
||||
{
|
||||
name: "simple string",
|
||||
line: `e2e:message("hello world")`,
|
||||
prefix: "e2e:message(",
|
||||
want: "hello world",
|
||||
},
|
||||
{
|
||||
name: "string with escaped quotes",
|
||||
line: `e2e:message("say \"hi\"")`,
|
||||
prefix: "e2e:message(",
|
||||
want: `say "hi"`,
|
||||
},
|
||||
{
|
||||
name: "string with newline escape",
|
||||
line: `e2e:message("line1\nline2")`,
|
||||
prefix: "e2e:message(",
|
||||
want: "line1\nline2",
|
||||
},
|
||||
{
|
||||
name: "string with tab escape",
|
||||
line: `e2e:message("col1\tcol2")`,
|
||||
prefix: "e2e:message(",
|
||||
want: "col1\tcol2",
|
||||
},
|
||||
{
|
||||
name: "string with escaped backslash",
|
||||
line: `e2e:message("path\\file")`,
|
||||
prefix: "e2e:message(",
|
||||
want: `path\file`,
|
||||
},
|
||||
{
|
||||
name: "thinking command",
|
||||
line: `e2e:thinking("deep thought")`,
|
||||
prefix: "e2e:thinking(",
|
||||
want: "deep thought",
|
||||
},
|
||||
{
|
||||
name: "tool_result command",
|
||||
line: `e2e:tool_result("success")`,
|
||||
prefix: "e2e:tool_result(",
|
||||
want: "success",
|
||||
},
|
||||
{"simple string", `e2e:message("hello world")`, "e2e:message(", "hello world"},
|
||||
{"escaped quotes", `e2e:message("say \"hi\"")`, "e2e:message(", `say "hi"`},
|
||||
{"newline escape", `e2e:message("line1\nline2")`, "e2e:message(", "line1\nline2"},
|
||||
{"tab escape", `e2e:message("col1\tcol2")`, "e2e:message(", "col1\tcol2"},
|
||||
{"escaped backslash", `e2e:message("path\\file")`, "e2e:message(", `path\file`},
|
||||
{"thinking command", `e2e:thinking("deep thought")`, "e2e:thinking(", "deep thought"},
|
||||
{"tool_result command", `e2e:tool_result("success")`, "e2e:tool_result(", "success"},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
@@ -121,18 +87,8 @@ func TestExtractParenContent(t *testing.T) {
|
||||
prefix string
|
||||
want string
|
||||
}{
|
||||
{
|
||||
name: "simple content",
|
||||
line: `e2e:tool_use("Read", {"path":"/tmp"})`,
|
||||
prefix: "e2e:tool_use(",
|
||||
want: `"Read", {"path":"/tmp"}`,
|
||||
},
|
||||
{
|
||||
name: "no trailing paren",
|
||||
line: `e2e:tool_use("Read"`,
|
||||
prefix: "e2e:tool_use(",
|
||||
want: `"Read"`,
|
||||
},
|
||||
{"simple content", `e2e:tool_use("Read", {"path":"/tmp"})`, "e2e:tool_use(", `"Read", {"path":"/tmp"}`},
|
||||
{"no trailing paren", `e2e:tool_use("Read"`, "e2e:tool_use(", `"Read"`},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
@@ -151,36 +107,11 @@ func TestExtractFirstStringArg(t *testing.T) {
|
||||
wantVal string
|
||||
wantRest string
|
||||
}{
|
||||
{
|
||||
name: "simple string",
|
||||
input: `"hello", rest`,
|
||||
wantVal: "hello",
|
||||
wantRest: ", rest",
|
||||
},
|
||||
{
|
||||
name: "string with escaped quote",
|
||||
input: `"say \"hi\"", more`,
|
||||
wantVal: `say "hi"`,
|
||||
wantRest: ", more",
|
||||
},
|
||||
{
|
||||
name: "just a string",
|
||||
input: `"only"`,
|
||||
wantVal: "only",
|
||||
wantRest: "",
|
||||
},
|
||||
{
|
||||
name: "empty input",
|
||||
input: "",
|
||||
wantVal: "",
|
||||
wantRest: "",
|
||||
},
|
||||
{
|
||||
name: "non-quoted input",
|
||||
input: "bare",
|
||||
wantVal: "bare",
|
||||
wantRest: "",
|
||||
},
|
||||
{"simple string", `"hello", rest`, "hello", ", rest"},
|
||||
{"string with escaped quote", `"say \"hi\"", more`, `say "hi"`, ", more"},
|
||||
{"just a string", `"only"`, "only", ""},
|
||||
{"empty input", "", "", ""},
|
||||
{"non-quoted input", "bare", "bare", ""},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
@@ -289,21 +220,9 @@ func TestExtractRegexMatch(t *testing.T) {
|
||||
input string
|
||||
want string
|
||||
}{
|
||||
{
|
||||
name: "task ID found",
|
||||
input: "Kandev Task ID: abc-123",
|
||||
want: "abc-123",
|
||||
},
|
||||
{
|
||||
name: "task ID with extra whitespace",
|
||||
input: "Kandev Task ID: def-456",
|
||||
want: "def-456",
|
||||
},
|
||||
{
|
||||
name: "no match",
|
||||
input: "no task id here",
|
||||
want: "",
|
||||
},
|
||||
{"task ID found", "Kandev Task ID: abc-123", "abc-123"},
|
||||
{"task ID with extra whitespace", "Kandev Task ID: def-456", "def-456"},
|
||||
{"no match", "no task id here", ""},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
@@ -315,153 +234,251 @@ func TestExtractRegexMatch(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
// TestExecuteScriptMessage verifies e2e:message emits an assistant text block.
|
||||
func TestExecuteScriptMessage(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
enc := json.NewEncoder(&buf)
|
||||
// --- Mock sessionUpdater for testing ---
|
||||
|
||||
// Reset global state
|
||||
resetState()
|
||||
|
||||
executeScript(enc, "", `e2e:message("hello from script")`)
|
||||
|
||||
msgs := decodeJSONLines(t, buf.Bytes())
|
||||
if len(msgs) != 1 {
|
||||
t.Fatalf("expected 1 message, got %d", len(msgs))
|
||||
}
|
||||
assertMsgType(t, msgs[0], TypeAssistant)
|
||||
assertContentText(t, msgs[0], "hello from script")
|
||||
// recordedUpdate stores a captured ACP session notification.
|
||||
type recordedUpdate struct {
|
||||
notification acp.SessionNotification
|
||||
}
|
||||
|
||||
// TestExecuteScriptThinking verifies e2e:thinking emits a thinking block.
|
||||
func TestExecuteScriptThinking(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
enc := json.NewEncoder(&buf)
|
||||
// mockUpdater implements sessionUpdater for tests, collecting all updates.
|
||||
type mockUpdater struct {
|
||||
mu sync.Mutex
|
||||
updates []recordedUpdate
|
||||
}
|
||||
|
||||
executeScript(enc, "", `e2e:thinking("deep thought")`)
|
||||
func (m *mockUpdater) SessionUpdate(_ context.Context, n acp.SessionNotification) error {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
m.updates = append(m.updates, recordedUpdate{notification: n})
|
||||
return nil
|
||||
}
|
||||
|
||||
msgs := decodeJSONLines(t, buf.Bytes())
|
||||
if len(msgs) != 1 {
|
||||
t.Fatalf("expected 1 message, got %d", len(msgs))
|
||||
func (m *mockUpdater) RequestPermission(_ context.Context, _ acp.RequestPermissionRequest) (acp.RequestPermissionResponse, error) {
|
||||
return acp.RequestPermissionResponse{
|
||||
Outcome: acp.RequestPermissionOutcome{
|
||||
Selected: &acp.RequestPermissionOutcomeSelected{OptionId: "allow"},
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (m *mockUpdater) getUpdates() []recordedUpdate {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
return append([]recordedUpdate{}, m.updates...)
|
||||
}
|
||||
|
||||
func newTestEmitter() (*emitter, *mockUpdater) {
|
||||
mock := &mockUpdater{}
|
||||
e := &emitter{
|
||||
ctx: context.Background(),
|
||||
conn: mock,
|
||||
sid: "test-session",
|
||||
}
|
||||
return e, mock
|
||||
}
|
||||
|
||||
// --- Update assertion helpers ---
|
||||
|
||||
func isTextUpdate(u recordedUpdate) bool {
|
||||
return u.notification.Update.AgentMessageChunk != nil
|
||||
}
|
||||
|
||||
func isThoughtUpdate(u recordedUpdate) bool {
|
||||
return u.notification.Update.AgentThoughtChunk != nil
|
||||
}
|
||||
|
||||
func isToolCallUpdate(u recordedUpdate) bool {
|
||||
return u.notification.Update.ToolCall != nil
|
||||
}
|
||||
|
||||
func isToolCallCompleteUpdate(u recordedUpdate) bool {
|
||||
return u.notification.Update.ToolCallUpdate != nil
|
||||
}
|
||||
|
||||
func getTextContent(u recordedUpdate) string {
|
||||
if u.notification.Update.AgentMessageChunk == nil {
|
||||
return ""
|
||||
}
|
||||
if u.notification.Update.AgentMessageChunk.Content.Text == nil {
|
||||
return ""
|
||||
}
|
||||
return u.notification.Update.AgentMessageChunk.Content.Text.Text
|
||||
}
|
||||
|
||||
func getThoughtContent(u recordedUpdate) string {
|
||||
if u.notification.Update.AgentThoughtChunk == nil {
|
||||
return ""
|
||||
}
|
||||
if u.notification.Update.AgentThoughtChunk.Content.Text == nil {
|
||||
return ""
|
||||
}
|
||||
return u.notification.Update.AgentThoughtChunk.Content.Text.Text
|
||||
}
|
||||
|
||||
func getToolCallTitle(u recordedUpdate) string {
|
||||
if u.notification.Update.ToolCall == nil {
|
||||
return ""
|
||||
}
|
||||
return u.notification.Update.ToolCall.Title
|
||||
}
|
||||
|
||||
func getToolCallID(u recordedUpdate) acp.ToolCallId {
|
||||
if u.notification.Update.ToolCall != nil {
|
||||
return u.notification.Update.ToolCall.ToolCallId
|
||||
}
|
||||
if u.notification.Update.ToolCallUpdate != nil {
|
||||
return u.notification.Update.ToolCallUpdate.ToolCallId
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// --- Script execution tests ---
|
||||
|
||||
// TestExecuteScriptMessage verifies e2e:message emits an agent text update.
|
||||
func TestExecuteScriptMessage(t *testing.T) {
|
||||
e, mock := newTestEmitter()
|
||||
resetState()
|
||||
|
||||
executeScript(e, "", `e2e:message("hello from script")`)
|
||||
|
||||
updates := mock.getUpdates()
|
||||
if len(updates) != 1 {
|
||||
t.Fatalf("expected 1 update, got %d", len(updates))
|
||||
}
|
||||
if !isTextUpdate(updates[0]) {
|
||||
t.Fatal("expected text update")
|
||||
}
|
||||
if got := getTextContent(updates[0]); got != "hello from script" {
|
||||
t.Errorf("text = %q, want %q", got, "hello from script")
|
||||
}
|
||||
}
|
||||
|
||||
// TestExecuteScriptThinking verifies e2e:thinking emits a thought update.
|
||||
func TestExecuteScriptThinking(t *testing.T) {
|
||||
e, mock := newTestEmitter()
|
||||
resetState()
|
||||
|
||||
executeScript(e, "", `e2e:thinking("deep thought")`)
|
||||
|
||||
updates := mock.getUpdates()
|
||||
if len(updates) != 1 {
|
||||
t.Fatalf("expected 1 update, got %d", len(updates))
|
||||
}
|
||||
if !isThoughtUpdate(updates[0]) {
|
||||
t.Fatal("expected thought update")
|
||||
}
|
||||
if got := getThoughtContent(updates[0]); got != "deep thought" {
|
||||
t.Errorf("thought = %q, want %q", got, "deep thought")
|
||||
}
|
||||
assertMsgType(t, msgs[0], TypeAssistant)
|
||||
assertContentThinking(t, msgs[0], "deep thought")
|
||||
}
|
||||
|
||||
// TestExecuteScriptMultiLine verifies multiple commands are processed sequentially.
|
||||
func TestExecuteScriptMultiLine(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
enc := json.NewEncoder(&buf)
|
||||
e, mock := newTestEmitter()
|
||||
resetState()
|
||||
|
||||
script := "e2e:thinking(\"step 1\")\ne2e:message(\"step 2\")\ne2e:message(\"step 3\")"
|
||||
executeScript(enc, "", script)
|
||||
executeScript(e, "", script)
|
||||
|
||||
msgs := decodeJSONLines(t, buf.Bytes())
|
||||
if len(msgs) != 3 {
|
||||
t.Fatalf("expected 3 messages, got %d", len(msgs))
|
||||
updates := mock.getUpdates()
|
||||
if len(updates) != 3 {
|
||||
t.Fatalf("expected 3 updates, got %d", len(updates))
|
||||
}
|
||||
if got := getThoughtContent(updates[0]); got != "step 1" {
|
||||
t.Errorf("thought = %q, want %q", got, "step 1")
|
||||
}
|
||||
if got := getTextContent(updates[1]); got != "step 2" {
|
||||
t.Errorf("text = %q, want %q", got, "step 2")
|
||||
}
|
||||
if got := getTextContent(updates[2]); got != "step 3" {
|
||||
t.Errorf("text = %q, want %q", got, "step 3")
|
||||
}
|
||||
assertContentThinking(t, msgs[0], "step 1")
|
||||
assertContentText(t, msgs[1], "step 2")
|
||||
assertContentText(t, msgs[2], "step 3")
|
||||
}
|
||||
|
||||
// TestExecuteScriptSkipsEmptyAndComments verifies blank lines and comments are skipped.
|
||||
func TestExecuteScriptSkipsEmptyAndComments(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
enc := json.NewEncoder(&buf)
|
||||
e, mock := newTestEmitter()
|
||||
resetState()
|
||||
|
||||
script := "e2e:message(\"one\")\n\n# this is a comment\n \ne2e:message(\"two\")"
|
||||
executeScript(enc, "", script)
|
||||
executeScript(e, "", script)
|
||||
|
||||
msgs := decodeJSONLines(t, buf.Bytes())
|
||||
if len(msgs) != 2 {
|
||||
t.Fatalf("expected 2 messages, got %d", len(msgs))
|
||||
updates := mock.getUpdates()
|
||||
if len(updates) != 2 {
|
||||
t.Fatalf("expected 2 updates, got %d", len(updates))
|
||||
}
|
||||
if got := getTextContent(updates[0]); got != "one" {
|
||||
t.Errorf("text = %q, want %q", got, "one")
|
||||
}
|
||||
if got := getTextContent(updates[1]); got != "two" {
|
||||
t.Errorf("text = %q, want %q", got, "two")
|
||||
}
|
||||
assertContentText(t, msgs[0], "one")
|
||||
assertContentText(t, msgs[1], "two")
|
||||
}
|
||||
|
||||
// TestExecuteScriptToolUse verifies e2e:tool_use emits a tool_use block.
|
||||
// TestExecuteScriptToolUse verifies e2e:tool_use emits a tool_call update.
|
||||
func TestExecuteScriptToolUse(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
enc := json.NewEncoder(&buf)
|
||||
e, mock := newTestEmitter()
|
||||
resetState()
|
||||
|
||||
executeScript(enc, "", `e2e:tool_use("Read", {"file_path":"/tmp/test.go"})`)
|
||||
executeScript(e, "", `e2e:tool_use("Read", {"file_path":"/tmp/test.go"})`)
|
||||
|
||||
msgs := decodeJSONLines(t, buf.Bytes())
|
||||
if len(msgs) != 1 {
|
||||
t.Fatalf("expected 1 message, got %d", len(msgs))
|
||||
updates := mock.getUpdates()
|
||||
if len(updates) != 1 {
|
||||
t.Fatalf("expected 1 update, got %d", len(updates))
|
||||
}
|
||||
assertMsgType(t, msgs[0], TypeAssistant)
|
||||
content := getFirstContent(t, msgs[0])
|
||||
if content["type"] != BlockToolUse {
|
||||
t.Errorf("content type = %q, want %q", content["type"], BlockToolUse)
|
||||
if !isToolCallUpdate(updates[0]) {
|
||||
t.Fatal("expected tool_call update")
|
||||
}
|
||||
if content["name"] != "Read" {
|
||||
t.Errorf("tool name = %q, want %q", content["name"], "Read")
|
||||
}
|
||||
input, ok := content["input"].(map[string]any)
|
||||
if !ok {
|
||||
t.Fatal("input is not a map")
|
||||
}
|
||||
if input["file_path"] != "/tmp/test.go" {
|
||||
t.Errorf("file_path = %q, want %q", input["file_path"], "/tmp/test.go")
|
||||
if got := getToolCallTitle(updates[0]); got != "Read" {
|
||||
t.Errorf("title = %q, want %q", got, "Read")
|
||||
}
|
||||
}
|
||||
|
||||
// TestExecuteScriptToolUseAndResult verifies tool_use + tool_result pair.
|
||||
func TestExecuteScriptToolUseAndResult(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
enc := json.NewEncoder(&buf)
|
||||
e, mock := newTestEmitter()
|
||||
resetState()
|
||||
|
||||
script := "e2e:tool_use(\"Read\", {\"file_path\":\"/tmp/f.go\"})\ne2e:tool_result(\"file contents here\")"
|
||||
executeScript(enc, "", script)
|
||||
executeScript(e, "", script)
|
||||
|
||||
msgs := decodeJSONLines(t, buf.Bytes())
|
||||
if len(msgs) != 2 {
|
||||
t.Fatalf("expected 2 messages, got %d", len(msgs))
|
||||
updates := mock.getUpdates()
|
||||
if len(updates) != 2 {
|
||||
t.Fatalf("expected 2 updates, got %d", len(updates))
|
||||
}
|
||||
|
||||
// First: tool_use
|
||||
toolUseContent := getFirstContent(t, msgs[0])
|
||||
toolID := toolUseContent["id"].(string)
|
||||
// First: tool_call start
|
||||
if !isToolCallUpdate(updates[0]) {
|
||||
t.Fatal("expected tool_call update")
|
||||
}
|
||||
toolID := getToolCallID(updates[0])
|
||||
if toolID == "" {
|
||||
t.Fatal("tool_use should have an id")
|
||||
t.Fatal("tool_call should have an id")
|
||||
}
|
||||
|
||||
// Second: tool_result referencing same ID
|
||||
assertMsgType(t, msgs[1], TypeUser)
|
||||
resultContent := getFirstContent(t, msgs[1])
|
||||
if resultContent["type"] != BlockToolResult {
|
||||
t.Errorf("result type = %q, want %q", resultContent["type"], BlockToolResult)
|
||||
// Second: tool_call_update (completion) referencing same ID
|
||||
if !isToolCallCompleteUpdate(updates[1]) {
|
||||
t.Fatal("expected tool_call_update")
|
||||
}
|
||||
if resultContent["tool_use_id"] != toolID {
|
||||
t.Errorf("tool_use_id = %q, want %q", resultContent["tool_use_id"], toolID)
|
||||
}
|
||||
if resultContent["content"] != "file contents here" {
|
||||
t.Errorf("content = %q, want %q", resultContent["content"], "file contents here")
|
||||
if got := getToolCallID(updates[1]); got != toolID {
|
||||
t.Errorf("tool_call_update id = %q, want %q", got, toolID)
|
||||
}
|
||||
}
|
||||
|
||||
// TestExecuteScriptToolUseNoInput verifies tool_use with no input arg.
|
||||
func TestExecuteScriptToolUseNoInput(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
enc := json.NewEncoder(&buf)
|
||||
e, mock := newTestEmitter()
|
||||
resetState()
|
||||
|
||||
executeScript(enc, "", `e2e:tool_use("Glob")`)
|
||||
executeScript(e, "", `e2e:tool_use("Glob")`)
|
||||
|
||||
msgs := decodeJSONLines(t, buf.Bytes())
|
||||
if len(msgs) != 1 {
|
||||
t.Fatalf("expected 1 message, got %d", len(msgs))
|
||||
updates := mock.getUpdates()
|
||||
if len(updates) != 1 {
|
||||
t.Fatalf("expected 1 update, got %d", len(updates))
|
||||
}
|
||||
content := getFirstContent(t, msgs[0])
|
||||
if content["name"] != "Glob" {
|
||||
t.Errorf("tool name = %q, want %q", content["name"], "Glob")
|
||||
if got := getToolCallTitle(updates[0]); got != "Glob" {
|
||||
t.Errorf("title = %q, want %q", got, "Glob")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -471,31 +488,11 @@ func TestParseMCPConfigFromArgs(t *testing.T) {
|
||||
args []string
|
||||
want string
|
||||
}{
|
||||
{
|
||||
name: "no flag",
|
||||
args: []string{"mock-agent"},
|
||||
want: "",
|
||||
},
|
||||
{
|
||||
name: "separate flag and value",
|
||||
args: []string{"mock-agent", "--mcp-config", `{"mcpServers":{"kandev":{"url":"http://localhost:10005/sse"}}}`},
|
||||
want: `{"mcpServers":{"kandev":{"url":"http://localhost:10005/sse"}}}`,
|
||||
},
|
||||
{
|
||||
name: "equals syntax",
|
||||
args: []string{"mock-agent", `--mcp-config={"mcpServers":{}}`},
|
||||
want: `{"mcpServers":{}}`,
|
||||
},
|
||||
{
|
||||
name: "with other flags",
|
||||
args: []string{"mock-agent", "--model", "fast", "--mcp-config", `{"mcpServers":{}}`},
|
||||
want: `{"mcpServers":{}}`,
|
||||
},
|
||||
{
|
||||
name: "dangling flag",
|
||||
args: []string{"mock-agent", "--mcp-config"},
|
||||
want: "",
|
||||
},
|
||||
{"no flag", []string{"mock-agent"}, ""},
|
||||
{"separate flag and value", []string{"mock-agent", "--mcp-config", `{"mcpServers":{"kandev":{"url":"http://localhost:10005/sse"}}}`}, `{"mcpServers":{"kandev":{"url":"http://localhost:10005/sse"}}}`},
|
||||
{"equals syntax", []string{"mock-agent", `--mcp-config={"mcpServers":{}}`}, `{"mcpServers":{}}`},
|
||||
{"with other flags", []string{"mock-agent", "--model", "fast", "--mcp-config", `{"mcpServers":{}}`}, `{"mcpServers":{}}`},
|
||||
{"dangling flag", []string{"mock-agent", "--mcp-config"}, ""},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
@@ -547,86 +544,20 @@ func TestExtractMCPResultText(t *testing.T) {
|
||||
|
||||
// TestExecuteScriptToolUseBadJSON verifies that malformed JSON emits a script error.
|
||||
func TestExecuteScriptToolUseBadJSON(t *testing.T) {
|
||||
var buf bytes.Buffer
|
||||
enc := json.NewEncoder(&buf)
|
||||
e, mock := newTestEmitter()
|
||||
resetState()
|
||||
|
||||
executeScript(enc, "", `e2e:tool_use("Read", {bad json})`)
|
||||
executeScript(e, "", `e2e:tool_use("Read", {bad json})`)
|
||||
|
||||
msgs := decodeJSONLines(t, buf.Bytes())
|
||||
if len(msgs) != 1 {
|
||||
t.Fatalf("expected 1 message (error), got %d", len(msgs))
|
||||
updates := mock.getUpdates()
|
||||
if len(updates) != 1 {
|
||||
t.Fatalf("expected 1 update (error), got %d", len(updates))
|
||||
}
|
||||
assertMsgType(t, msgs[0], TypeAssistant)
|
||||
content := getFirstContent(t, msgs[0])
|
||||
text, _ := content["text"].(string)
|
||||
if !isTextUpdate(updates[0]) {
|
||||
t.Fatal("expected text update for error")
|
||||
}
|
||||
text := getTextContent(updates[0])
|
||||
if !strings.Contains(text, "Script error") {
|
||||
t.Errorf("expected script error message, got %q", text)
|
||||
}
|
||||
}
|
||||
|
||||
// --- Test helpers ---
|
||||
|
||||
// decodeJSONLines splits output into JSON-decoded maps.
|
||||
func decodeJSONLines(t *testing.T, data []byte) []map[string]any {
|
||||
t.Helper()
|
||||
var results []map[string]any
|
||||
dec := json.NewDecoder(bytes.NewReader(data))
|
||||
for dec.More() {
|
||||
var m map[string]any
|
||||
if err := dec.Decode(&m); err != nil {
|
||||
t.Fatalf("failed to decode JSON: %v", err)
|
||||
}
|
||||
results = append(results, m)
|
||||
}
|
||||
return results
|
||||
}
|
||||
|
||||
func assertMsgType(t *testing.T, msg map[string]any, wantType string) {
|
||||
t.Helper()
|
||||
if msg["type"] != wantType {
|
||||
t.Errorf("message type = %q, want %q", msg["type"], wantType)
|
||||
}
|
||||
}
|
||||
|
||||
func getFirstContent(t *testing.T, msg map[string]any) map[string]any {
|
||||
t.Helper()
|
||||
message, ok := msg["message"].(map[string]any)
|
||||
if !ok {
|
||||
t.Fatal("message field is not a map")
|
||||
}
|
||||
contentArr, ok := message["content"].([]any)
|
||||
if !ok || len(contentArr) == 0 {
|
||||
t.Fatal("content is not an array or is empty")
|
||||
}
|
||||
block, ok := contentArr[0].(map[string]any)
|
||||
if !ok {
|
||||
t.Fatal("first content block is not a map")
|
||||
}
|
||||
return block
|
||||
}
|
||||
|
||||
func assertContentText(t *testing.T, msg map[string]any, wantText string) {
|
||||
t.Helper()
|
||||
content := getFirstContent(t, msg)
|
||||
if content["type"] != BlockText {
|
||||
t.Errorf("content type = %q, want %q", content["type"], BlockText)
|
||||
}
|
||||
// emitTextBlock appends a trailing newline to match real agent streaming behavior;
|
||||
// allow the expected text with or without the trailing newline.
|
||||
got, _ := content["text"].(string)
|
||||
if got != wantText && got != wantText+"\n" {
|
||||
t.Errorf("text = %q, want %q (or with trailing newline)", got, wantText)
|
||||
}
|
||||
}
|
||||
|
||||
func assertContentThinking(t *testing.T, msg map[string]any, wantThought string) {
|
||||
t.Helper()
|
||||
content := getFirstContent(t, msg)
|
||||
if content["type"] != BlockThinking {
|
||||
t.Errorf("content type = %q, want %q", content["type"], BlockThinking)
|
||||
}
|
||||
if content["thinking"] != wantThought {
|
||||
t.Errorf("thinking = %q, want %q", content["thinking"], wantThought)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,10 +1,10 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
acp "github.com/coder/acp-go-sdk"
|
||||
)
|
||||
|
||||
// scriptState holds mutable state shared across script commands and sequence emitters.
|
||||
@@ -21,111 +21,38 @@ func resetState() {
|
||||
state = &scriptState{}
|
||||
}
|
||||
|
||||
func nextToolID() string {
|
||||
func nextToolID() acp.ToolCallId {
|
||||
state.toolCallCounter++
|
||||
return fmt.Sprintf("mock_tool_%04d", state.toolCallCounter)
|
||||
}
|
||||
|
||||
func defaultUsage() *Usage {
|
||||
return &Usage{
|
||||
InputTokens: 1200,
|
||||
OutputTokens: 350,
|
||||
}
|
||||
id := fmt.Sprintf("mock_tool_%04d", state.toolCallCounter)
|
||||
state.lastToolID = id
|
||||
return acp.ToolCallId(id)
|
||||
}
|
||||
|
||||
// --- Atomic emitters ---
|
||||
|
||||
// emitThinking emits an assistant message with a thinking block.
|
||||
func emitThinking(enc *json.Encoder, model string) {
|
||||
// emitThinking emits a thinking block with random delay.
|
||||
func emitThinking(e *emitter, model string) {
|
||||
randomDelay(model)
|
||||
emitThinkingBlock(enc, "Analyzing the request and considering the best approach...", "")
|
||||
e.thought("Analyzing the request and considering the best approach...")
|
||||
}
|
||||
|
||||
// emitThinkingBlock emits an assistant message with a thinking content block.
|
||||
func emitThinkingBlock(enc *json.Encoder, thought, parentToolUseID string) {
|
||||
_ = enc.Encode(AssistantMsg{
|
||||
Type: TypeAssistant,
|
||||
ParentToolUseID: parentToolUseID,
|
||||
Message: AssistantBody{
|
||||
Role: "assistant",
|
||||
Content: []ContentBlock{
|
||||
{Type: BlockThinking, Thinking: thought},
|
||||
},
|
||||
Model: "mock-default",
|
||||
Usage: defaultUsage(),
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
// emitTextBlock emits an assistant message with a text content block.
|
||||
// Text always ends with a newline to match real agent streaming behavior,
|
||||
// which allows the lifecycle manager's message buffer to flush immediately
|
||||
// and publish "message_streaming" events for activity detection.
|
||||
func emitTextBlock(enc *json.Encoder, text, parentToolUseID string) {
|
||||
if !strings.HasSuffix(text, "\n") {
|
||||
text += "\n"
|
||||
}
|
||||
_ = enc.Encode(AssistantMsg{
|
||||
Type: TypeAssistant,
|
||||
ParentToolUseID: parentToolUseID,
|
||||
Message: AssistantBody{
|
||||
Role: "assistant",
|
||||
Content: []ContentBlock{
|
||||
{Type: BlockText, Text: text},
|
||||
},
|
||||
Model: "mock-default",
|
||||
StopReason: "end_turn",
|
||||
Usage: defaultUsage(),
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
// emitReadFile emits a Read tool_use followed by a tool_result using a real workspace file.
|
||||
func emitReadFile(enc *json.Encoder, model string) {
|
||||
// emitReadFile emits a Read tool call using a real workspace file.
|
||||
func emitReadFile(e *emitter, model string) {
|
||||
toolID := nextToolID()
|
||||
f := randomFile()
|
||||
snippet := readFileSnippet(f.absPath, 30)
|
||||
randomDelay(model)
|
||||
|
||||
_ = enc.Encode(AssistantMsg{
|
||||
Type: TypeAssistant,
|
||||
Message: AssistantBody{
|
||||
Role: "assistant",
|
||||
Content: []ContentBlock{
|
||||
{
|
||||
Type: BlockToolUse,
|
||||
ID: toolID,
|
||||
Name: ToolRead,
|
||||
Input: map[string]any{
|
||||
"file_path": f.absPath,
|
||||
},
|
||||
},
|
||||
},
|
||||
Model: "mock-default",
|
||||
StopReason: "tool_use",
|
||||
Usage: defaultUsage(),
|
||||
},
|
||||
})
|
||||
e.startTool(toolID, "Read "+f.relPath, acp.ToolKindRead,
|
||||
map[string]any{"file_path": f.absPath},
|
||||
acp.ToolCallLocation{Path: f.absPath})
|
||||
|
||||
randomDelay(model)
|
||||
|
||||
_ = enc.Encode(UserMsg{
|
||||
Type: TypeUser,
|
||||
Message: UserMsgBody{
|
||||
Role: "user",
|
||||
Content: []ContentBlock{
|
||||
{
|
||||
Type: BlockToolResult,
|
||||
ToolUseID: toolID,
|
||||
Content: snippet,
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
e.completeTool(toolID, map[string]any{"content": snippet})
|
||||
}
|
||||
|
||||
// emitEditFile emits an Edit tool_use with a real file and real content fragment.
|
||||
func emitEditFile(enc *json.Encoder, scanner *bufio.Scanner, model string) {
|
||||
// emitEditFile emits an Edit tool call with permission request.
|
||||
func emitEditFile(e *emitter, model string) {
|
||||
toolID := nextToolID()
|
||||
f := randomFile()
|
||||
oldStr, newStr := pickEditableFragment(f.absPath)
|
||||
@@ -137,47 +64,19 @@ func emitEditFile(enc *json.Encoder, scanner *bufio.Scanner, model string) {
|
||||
"new_string": newStr,
|
||||
}
|
||||
|
||||
_ = enc.Encode(AssistantMsg{
|
||||
Type: TypeAssistant,
|
||||
Message: AssistantBody{
|
||||
Role: "assistant",
|
||||
Content: []ContentBlock{
|
||||
{
|
||||
Type: BlockToolUse,
|
||||
ID: toolID,
|
||||
Name: ToolEdit,
|
||||
Input: input,
|
||||
},
|
||||
},
|
||||
Model: "mock-default",
|
||||
StopReason: "tool_use",
|
||||
Usage: defaultUsage(),
|
||||
},
|
||||
})
|
||||
e.startTool(toolID, "Edit "+f.relPath, acp.ToolKindEdit, input,
|
||||
acp.ToolCallLocation{Path: f.absPath})
|
||||
|
||||
allowed := requestPermission(enc, scanner, ToolEdit, toolID, input)
|
||||
|
||||
if allowed {
|
||||
_ = enc.Encode(UserMsg{
|
||||
Type: TypeUser,
|
||||
Message: UserMsgBody{
|
||||
Role: "user",
|
||||
Content: []ContentBlock{
|
||||
{
|
||||
Type: BlockToolResult,
|
||||
ToolUseID: toolID,
|
||||
Content: "File edited successfully: " + f.absPath,
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
if e.requestPermission(toolID, "Edit "+f.relPath, acp.ToolKindEdit, input) {
|
||||
e.completeTool(toolID, map[string]any{"result": "File edited successfully: " + f.absPath})
|
||||
} else {
|
||||
emitTextBlock(enc, "Permission denied for Edit, skipping.", "")
|
||||
e.completeTool(toolID, map[string]any{"result": "Permission denied for Edit"})
|
||||
e.text("Permission denied for Edit, skipping.")
|
||||
}
|
||||
}
|
||||
|
||||
// emitShellExec emits a Bash tool_use with permission request, then tool_result.
|
||||
func emitShellExec(enc *json.Encoder, scanner *bufio.Scanner, model string) {
|
||||
// emitShellExec emits a Bash tool call with permission request.
|
||||
func emitShellExec(e *emitter, model string) {
|
||||
toolID := nextToolID()
|
||||
randomDelay(model)
|
||||
|
||||
@@ -186,47 +85,18 @@ func emitShellExec(enc *json.Encoder, scanner *bufio.Scanner, model string) {
|
||||
"description": "Run all tests",
|
||||
}
|
||||
|
||||
_ = enc.Encode(AssistantMsg{
|
||||
Type: TypeAssistant,
|
||||
Message: AssistantBody{
|
||||
Role: "assistant",
|
||||
Content: []ContentBlock{
|
||||
{
|
||||
Type: BlockToolUse,
|
||||
ID: toolID,
|
||||
Name: ToolBash,
|
||||
Input: input,
|
||||
},
|
||||
},
|
||||
Model: "mock-default",
|
||||
StopReason: "tool_use",
|
||||
Usage: defaultUsage(),
|
||||
},
|
||||
})
|
||||
e.startTool(toolID, "Run tests", acp.ToolKindExecute, input)
|
||||
|
||||
allowed := requestPermission(enc, scanner, ToolBash, toolID, input)
|
||||
|
||||
if allowed {
|
||||
_ = enc.Encode(UserMsg{
|
||||
Type: TypeUser,
|
||||
Message: UserMsgBody{
|
||||
Role: "user",
|
||||
Content: []ContentBlock{
|
||||
{
|
||||
Type: BlockToolResult,
|
||||
ToolUseID: toolID,
|
||||
Content: "ok \tgithub.com/example/project\t0.042s\nPASS",
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
if e.requestPermission(toolID, "Run tests", acp.ToolKindExecute, input) {
|
||||
e.completeTool(toolID, map[string]any{"output": "ok \tgithub.com/example/project\t0.042s\nPASS"})
|
||||
} else {
|
||||
emitTextBlock(enc, "Permission denied for Bash, skipping.", "")
|
||||
e.completeTool(toolID, map[string]any{"output": "Permission denied"})
|
||||
e.text("Permission denied for Bash, skipping.")
|
||||
}
|
||||
}
|
||||
|
||||
// emitCodeSearch emits a Grep tool_use using real workspace file paths.
|
||||
func emitCodeSearch(enc *json.Encoder, model string) {
|
||||
// emitCodeSearch emits a Grep tool call using real workspace file paths.
|
||||
func emitCodeSearch(e *emitter, model string) {
|
||||
toolID := nextToolID()
|
||||
randomDelay(model)
|
||||
|
||||
@@ -234,299 +104,125 @@ func emitCodeSearch(enc *json.Encoder, model string) {
|
||||
pattern := searchPatterns[state.toolCallCounter%len(searchPatterns)]
|
||||
|
||||
f := randomFile()
|
||||
_ = enc.Encode(AssistantMsg{
|
||||
Type: TypeAssistant,
|
||||
Message: AssistantBody{
|
||||
Role: "assistant",
|
||||
Content: []ContentBlock{
|
||||
{
|
||||
Type: BlockToolUse,
|
||||
ID: toolID,
|
||||
Name: ToolGrep,
|
||||
Input: map[string]any{
|
||||
"pattern": pattern,
|
||||
"path": f.absPath,
|
||||
},
|
||||
},
|
||||
},
|
||||
Model: "mock-default",
|
||||
StopReason: "tool_use",
|
||||
Usage: defaultUsage(),
|
||||
},
|
||||
})
|
||||
e.startTool(toolID, "Search for \""+pattern+"\"", acp.ToolKindSearch,
|
||||
map[string]any{"pattern": pattern, "path": f.absPath})
|
||||
|
||||
randomDelay(model)
|
||||
|
||||
// Build realistic search results using real file paths
|
||||
paths := randomFilePaths(3)
|
||||
var results []string
|
||||
for i, p := range paths {
|
||||
results = append(results, fmt.Sprintf("%s:%d:%s found here", p, (i+1)*10, strings.TrimSpace(pattern)))
|
||||
}
|
||||
|
||||
_ = enc.Encode(UserMsg{
|
||||
Type: TypeUser,
|
||||
Message: UserMsgBody{
|
||||
Role: "user",
|
||||
Content: []ContentBlock{
|
||||
{
|
||||
Type: BlockToolResult,
|
||||
ToolUseID: toolID,
|
||||
Content: strings.Join(results, "\n"),
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
e.completeTool(toolID, map[string]any{"matches": strings.Join(results, "\n")})
|
||||
}
|
||||
|
||||
// emitSubagent emits a Task tool_use with nested child messages using real files.
|
||||
func emitSubagent(enc *json.Encoder, scanner *bufio.Scanner, model string) {
|
||||
// emitSubagent emits a Task tool call with child tool calls.
|
||||
func emitSubagent(e *emitter, model string) {
|
||||
taskToolID := nextToolID()
|
||||
randomDelay(model)
|
||||
|
||||
_ = enc.Encode(AssistantMsg{
|
||||
Type: TypeAssistant,
|
||||
Message: AssistantBody{
|
||||
Role: "assistant",
|
||||
Content: []ContentBlock{
|
||||
{
|
||||
Type: BlockToolUse,
|
||||
ID: taskToolID,
|
||||
Name: ToolTask,
|
||||
Input: map[string]any{
|
||||
"description": "Explore codebase",
|
||||
"prompt": "Find all files and summarize the project structure",
|
||||
},
|
||||
},
|
||||
},
|
||||
Model: "mock-default",
|
||||
StopReason: "tool_use",
|
||||
Usage: defaultUsage(),
|
||||
},
|
||||
})
|
||||
e.startTool(taskToolID, "Explore codebase", acp.ToolKindOther,
|
||||
map[string]any{
|
||||
"description": "Explore codebase",
|
||||
"prompt": "Find all files and summarize the project structure",
|
||||
})
|
||||
|
||||
randomDelay(model)
|
||||
_ = enc.Encode(SystemMsg{Type: TypeSystem, SessionID: sessionID, SessionStatus: "active"})
|
||||
randomDelay(model)
|
||||
emitThinkingBlock(enc, "Exploring the project structure...", taskToolID)
|
||||
e.thought("Exploring the project structure...")
|
||||
randomDelay(model)
|
||||
|
||||
paths := randomFilePaths(5)
|
||||
emitTextBlock(enc, fmt.Sprintf("Found %d files. The project structure looks well-organized.", len(paths)), taskToolID)
|
||||
e.text(fmt.Sprintf("Found %d files. The project structure looks well-organized.", len(paths)))
|
||||
randomDelay(model)
|
||||
emitSubagentChildGlob(enc, taskToolID, model, paths)
|
||||
emitSubagentCompletion(enc, taskToolID, model, paths)
|
||||
}
|
||||
|
||||
func emitSubagentChildGlob(enc *json.Encoder, taskToolID, model string, paths []string) {
|
||||
// Child glob tool call
|
||||
childToolID := nextToolID()
|
||||
_ = enc.Encode(AssistantMsg{
|
||||
Type: TypeAssistant,
|
||||
ParentToolUseID: taskToolID,
|
||||
Message: AssistantBody{
|
||||
Role: "assistant",
|
||||
Content: []ContentBlock{
|
||||
{
|
||||
Type: BlockToolUse,
|
||||
ID: childToolID,
|
||||
Name: ToolGlob,
|
||||
Input: map[string]any{"pattern": "**/*"},
|
||||
},
|
||||
},
|
||||
Model: "mock-default",
|
||||
StopReason: "tool_use",
|
||||
Usage: defaultUsage(),
|
||||
},
|
||||
})
|
||||
e.startTool(childToolID, "Glob **/*", acp.ToolKindSearch,
|
||||
map[string]any{"pattern": "**/*"})
|
||||
randomDelay(model)
|
||||
_ = enc.Encode(UserMsg{
|
||||
Type: TypeUser,
|
||||
ParentToolUseID: taskToolID,
|
||||
Message: UserMsgBody{
|
||||
Role: "user",
|
||||
Content: []ContentBlock{{Type: BlockToolResult, ToolUseID: childToolID, Content: strings.Join(paths, "\n")}},
|
||||
},
|
||||
})
|
||||
randomDelay(model)
|
||||
}
|
||||
|
||||
// emitSubagentCompletion emits the final text block and tool result for a subagent task.
|
||||
func emitSubagentCompletion(enc *json.Encoder, taskToolID, model string, paths []string) {
|
||||
emitTextBlock(enc, "Project structure analysis complete.", taskToolID)
|
||||
e.completeTool(childToolID, map[string]any{"files": strings.Join(paths, "\n")})
|
||||
randomDelay(model)
|
||||
|
||||
_ = enc.Encode(UserMsg{
|
||||
Type: TypeUser,
|
||||
Message: UserMsgBody{
|
||||
Role: "user",
|
||||
Content: []ContentBlock{
|
||||
{
|
||||
Type: BlockToolResult,
|
||||
ToolUseID: taskToolID,
|
||||
Content: fmt.Sprintf("Subagent completed: Found %d files across the project.", len(paths)),
|
||||
},
|
||||
},
|
||||
},
|
||||
e.text("Project structure analysis complete.")
|
||||
randomDelay(model)
|
||||
e.completeTool(taskToolID, map[string]any{
|
||||
"result": fmt.Sprintf("Subagent completed: Found %d files across the project.", len(paths)),
|
||||
})
|
||||
}
|
||||
|
||||
// emitTodo emits a TodoWrite tool_use followed by a tool_result.
|
||||
func emitTodo(enc *json.Encoder, model string) {
|
||||
// emitTodo emits a TodoWrite tool call.
|
||||
func emitTodo(e *emitter, model string) {
|
||||
toolID := nextToolID()
|
||||
randomDelay(model)
|
||||
|
||||
_ = enc.Encode(AssistantMsg{
|
||||
Type: TypeAssistant,
|
||||
Message: AssistantBody{
|
||||
Role: "assistant",
|
||||
Content: []ContentBlock{
|
||||
{
|
||||
Type: BlockToolUse,
|
||||
ID: toolID,
|
||||
Name: ToolTodoWrite,
|
||||
Input: map[string]any{
|
||||
"todos": []map[string]any{
|
||||
{"id": "1", "content": "Review code changes", "status": "in_progress"},
|
||||
{"id": "2", "content": "Run tests", "status": "pending"},
|
||||
{"id": "3", "content": "Update documentation", "status": "pending"},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
Model: "mock-default",
|
||||
StopReason: "tool_use",
|
||||
Usage: defaultUsage(),
|
||||
e.startTool(toolID, "Update todo list", acp.ToolKindOther, map[string]any{
|
||||
"todos": []map[string]any{
|
||||
{"id": "1", "content": "Review code changes", "status": "in_progress"},
|
||||
{"id": "2", "content": "Run tests", "status": "pending"},
|
||||
{"id": "3", "content": "Update documentation", "status": "pending"},
|
||||
},
|
||||
})
|
||||
|
||||
randomDelay(model)
|
||||
|
||||
_ = enc.Encode(UserMsg{
|
||||
Type: TypeUser,
|
||||
Message: UserMsgBody{
|
||||
Role: "user",
|
||||
Content: []ContentBlock{
|
||||
{
|
||||
Type: BlockToolResult,
|
||||
ToolUseID: toolID,
|
||||
Content: "Todo list updated: 3 items (1 in progress, 2 pending)",
|
||||
},
|
||||
},
|
||||
},
|
||||
})
|
||||
e.completeTool(toolID, map[string]any{"result": "Todo list updated: 3 items (1 in progress, 2 pending)"})
|
||||
}
|
||||
|
||||
// emitMermaidSequence emits a rich markdown message containing mermaid diagrams.
|
||||
func emitMermaidSequence(enc *json.Encoder, model string) {
|
||||
emitThinking(enc, model)
|
||||
func emitMermaidSequence(e *emitter, model string) {
|
||||
emitThinking(e, model)
|
||||
randomDelay(model)
|
||||
|
||||
emitTextBlock(enc, "Here's an overview of the system architecture with diagrams:\n\n"+
|
||||
"## System Flow\n\n"+
|
||||
"The following flowchart shows the request processing pipeline:\n\n"+
|
||||
"```mermaid\n"+
|
||||
"flowchart TD\n"+
|
||||
" A([Client Request]) --> B{Auth Check}\n"+
|
||||
" B -->|Valid| C[API Gateway]\n"+
|
||||
" B -->|Invalid| D[401 Unauthorized]\n"+
|
||||
" C --> E[Load Balancer]\n"+
|
||||
" E --> F[Service A]\n"+
|
||||
" E --> G[Service B]\n"+
|
||||
" F --> H[(Database)]\n"+
|
||||
" G --> H\n"+
|
||||
" H --> I[Response Builder]\n"+
|
||||
" I --> J([Client Response])\n"+
|
||||
"```\n\n"+
|
||||
"## Sequence Diagram\n\n"+
|
||||
"Here's how the authentication flow works between components:\n\n"+
|
||||
"```mermaid\n"+
|
||||
"sequenceDiagram\n"+
|
||||
" participant U as User\n"+
|
||||
" participant FE as Frontend\n"+
|
||||
" participant API as API Server\n"+
|
||||
" participant DB as Database\n"+
|
||||
" U->>FE: Login Request\n"+
|
||||
" FE->>API: POST /auth/login\n"+
|
||||
" API->>DB: Verify Credentials\n"+
|
||||
" DB-->>API: User Record\n"+
|
||||
" API-->>FE: JWT Token\n"+
|
||||
" FE-->>U: Redirect to Dashboard\n"+
|
||||
"```\n\n"+
|
||||
"### Key Points\n\n"+
|
||||
"- All requests go through the **API Gateway** for rate limiting\n"+
|
||||
"- Authentication uses **JWT tokens** with a 24h expiry\n"+
|
||||
"- Services communicate via `gRPC` internally\n"+
|
||||
"- Database connections use a **connection pool** (max 50)\n", "")
|
||||
e.text("Here's an overview of the system architecture with diagrams:\n\n" +
|
||||
"## System Flow\n\n" +
|
||||
"The following flowchart shows the request processing pipeline:\n\n" +
|
||||
"```mermaid\n" +
|
||||
"flowchart TD\n" +
|
||||
" A([Client Request]) --> B{Auth Check}\n" +
|
||||
" B -->|Valid| C[API Gateway]\n" +
|
||||
" B -->|Invalid| D[401 Unauthorized]\n" +
|
||||
" C --> E[Load Balancer]\n" +
|
||||
" E --> F[Service A]\n" +
|
||||
" E --> G[Service B]\n" +
|
||||
" F --> H[(Database)]\n" +
|
||||
" G --> H\n" +
|
||||
" H --> I[Response Builder]\n" +
|
||||
" I --> J([Client Response])\n" +
|
||||
"```\n\n" +
|
||||
"## Sequence Diagram\n\n" +
|
||||
"Here's how the authentication flow works between components:\n\n" +
|
||||
"```mermaid\n" +
|
||||
"sequenceDiagram\n" +
|
||||
" participant U as User\n" +
|
||||
" participant FE as Frontend\n" +
|
||||
" participant API as API Server\n" +
|
||||
" participant DB as Database\n" +
|
||||
" U->>FE: Login Request\n" +
|
||||
" FE->>API: POST /auth/login\n" +
|
||||
" API->>DB: Verify Credentials\n" +
|
||||
" DB-->>API: User Record\n" +
|
||||
" API-->>FE: JWT Token\n" +
|
||||
" FE-->>U: Redirect to Dashboard\n" +
|
||||
"```\n\n" +
|
||||
"### Key Points\n\n" +
|
||||
"- All requests go through the **API Gateway** for rate limiting\n" +
|
||||
"- Authentication uses **JWT tokens** with a 24h expiry\n" +
|
||||
"- Services communicate via `gRPC` internally\n" +
|
||||
"- Database connections use a **connection pool** (max 50)\n")
|
||||
}
|
||||
|
||||
// emitToolUseBlock emits an assistant message with a single tool_use content block.
|
||||
func emitToolUseBlock(enc *json.Encoder, toolID, toolName string, input map[string]any) {
|
||||
_ = enc.Encode(AssistantMsg{
|
||||
Type: TypeAssistant,
|
||||
Message: AssistantBody{
|
||||
Role: "assistant",
|
||||
Content: []ContentBlock{
|
||||
{Type: BlockToolUse, ID: toolID, Name: toolName, Input: input},
|
||||
},
|
||||
Model: "mock-default",
|
||||
StopReason: "tool_use",
|
||||
Usage: defaultUsage(),
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
// emitToolResultBlock emits a user message with a tool_result content block.
|
||||
func emitToolResultBlock(enc *json.Encoder, toolID, content string, isError bool) {
|
||||
_ = enc.Encode(UserMsg{
|
||||
Type: TypeUser,
|
||||
Message: UserMsgBody{
|
||||
Role: "user",
|
||||
Content: []ContentBlock{
|
||||
{Type: BlockToolResult, ToolUseID: toolID, Content: content, IsError: isError},
|
||||
},
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
// emitWebFetch emits a WebFetch tool_use followed by a tool_result.
|
||||
func emitWebFetch(enc *json.Encoder, model string) {
|
||||
// emitWebFetch emits a WebFetch tool call.
|
||||
func emitWebFetch(e *emitter, model string) {
|
||||
toolID := nextToolID()
|
||||
randomDelay(model)
|
||||
|
||||
_ = enc.Encode(AssistantMsg{
|
||||
Type: TypeAssistant,
|
||||
Message: AssistantBody{
|
||||
Role: "assistant",
|
||||
Content: []ContentBlock{
|
||||
{
|
||||
Type: BlockToolUse,
|
||||
ID: toolID,
|
||||
Name: ToolWebFetch,
|
||||
Input: map[string]any{
|
||||
"url": "https://example.com/api/docs",
|
||||
"prompt": "Extract the API endpoints and their descriptions",
|
||||
},
|
||||
},
|
||||
},
|
||||
Model: "mock-default",
|
||||
StopReason: "tool_use",
|
||||
Usage: defaultUsage(),
|
||||
},
|
||||
e.startTool(toolID, "Fetch API docs", acp.ToolKindFetch, map[string]any{
|
||||
"url": "https://example.com/api/docs",
|
||||
"prompt": "Extract the API endpoints and their descriptions",
|
||||
})
|
||||
|
||||
randomDelay(model)
|
||||
|
||||
_ = enc.Encode(UserMsg{
|
||||
Type: TypeUser,
|
||||
Message: UserMsgBody{
|
||||
Role: "user",
|
||||
Content: []ContentBlock{
|
||||
{
|
||||
Type: BlockToolResult,
|
||||
ToolUseID: toolID,
|
||||
Content: "API Documentation:\n- GET /api/v1/users - List all users\n- POST /api/v1/users - Create a new user\n- GET /api/v1/users/:id - Get user by ID\n- PUT /api/v1/users/:id - Update user\n- DELETE /api/v1/users/:id - Delete user",
|
||||
},
|
||||
},
|
||||
},
|
||||
e.completeTool(toolID, map[string]any{
|
||||
"content": "API Documentation:\n- GET /api/v1/users - List all users\n- POST /api/v1/users - Create a new user\n- GET /api/v1/users/:id - Get user by ID\n- PUT /api/v1/users/:id - Update user\n- DELETE /api/v1/users/:id - Delete user",
|
||||
})
|
||||
}
|
||||
|
||||
@@ -1,192 +0,0 @@
|
||||
package main
|
||||
|
||||
import "encoding/json"
|
||||
|
||||
// Message types
|
||||
const (
|
||||
TypeSystem = "system"
|
||||
TypeAssistant = "assistant"
|
||||
TypeUser = "user"
|
||||
TypeResult = "result"
|
||||
TypeControlRequest = "control_request"
|
||||
TypeControlResponse = "control_response"
|
||||
)
|
||||
|
||||
// Content block types
|
||||
const (
|
||||
BlockText = "text"
|
||||
BlockThinking = "thinking"
|
||||
BlockToolUse = "tool_use"
|
||||
BlockToolResult = "tool_result"
|
||||
)
|
||||
|
||||
// Tool names matching Claude Code conventions
|
||||
const (
|
||||
ToolBash = "Bash"
|
||||
ToolEdit = "Edit"
|
||||
ToolRead = "Read"
|
||||
ToolGlob = "Glob"
|
||||
ToolGrep = "Grep"
|
||||
ToolTask = "Task"
|
||||
ToolTodoWrite = "TodoWrite"
|
||||
ToolWebFetch = "WebFetch"
|
||||
)
|
||||
|
||||
// IncomingMessage is a minimal struct for parsing stdin messages.
|
||||
type IncomingMessage struct {
|
||||
Type string `json:"type"`
|
||||
RequestID string `json:"request_id,omitempty"`
|
||||
Message *IncomingBody `json:"message,omitempty"`
|
||||
Response *IncomingControl `json:"response,omitempty"`
|
||||
}
|
||||
|
||||
// IncomingBody is the message body for user messages.
|
||||
type IncomingBody struct {
|
||||
Role string `json:"role"`
|
||||
Content string `json:"content"`
|
||||
}
|
||||
|
||||
// IncomingControl is the response body for control_response messages.
|
||||
type IncomingControl struct {
|
||||
Subtype string `json:"subtype"`
|
||||
RequestID string `json:"request_id,omitempty"`
|
||||
Result *PermissionReply `json:"result,omitempty"`
|
||||
}
|
||||
|
||||
// PermissionReply is the result from a permission response.
|
||||
type PermissionReply struct {
|
||||
Behavior string `json:"behavior"`
|
||||
}
|
||||
|
||||
// --- Outgoing message types (written to stdout) ---
|
||||
|
||||
// SystemMsg is the system message emitted at the start of each turn.
|
||||
type SystemMsg struct {
|
||||
Type string `json:"type"`
|
||||
SessionID string `json:"session_id"`
|
||||
SessionStatus string `json:"session_status"`
|
||||
}
|
||||
|
||||
// AssistantMsg is an assistant message with content blocks.
|
||||
type AssistantMsg struct {
|
||||
Type string `json:"type"`
|
||||
ParentToolUseID string `json:"parent_tool_use_id,omitempty"`
|
||||
Message AssistantBody `json:"message"`
|
||||
}
|
||||
|
||||
// AssistantBody is the body of an assistant message.
|
||||
type AssistantBody struct {
|
||||
Role string `json:"role"`
|
||||
Content []ContentBlock `json:"content"`
|
||||
Model string `json:"model"`
|
||||
StopReason string `json:"stop_reason,omitempty"`
|
||||
Usage *Usage `json:"usage,omitempty"`
|
||||
}
|
||||
|
||||
// ContentBlock represents a content block in an assistant or user message.
|
||||
type ContentBlock struct {
|
||||
Type string `json:"type"`
|
||||
|
||||
// text block
|
||||
Text string `json:"text,omitempty"`
|
||||
|
||||
// thinking block
|
||||
Thinking string `json:"thinking,omitempty"`
|
||||
|
||||
// tool_use block
|
||||
ID string `json:"id,omitempty"`
|
||||
Name string `json:"name,omitempty"`
|
||||
Input map[string]any `json:"input,omitempty"`
|
||||
|
||||
// tool_result block
|
||||
ToolUseID string `json:"tool_use_id,omitempty"`
|
||||
Content string `json:"content,omitempty"`
|
||||
IsError bool `json:"is_error,omitempty"`
|
||||
}
|
||||
|
||||
// Usage contains token usage information.
|
||||
type Usage struct {
|
||||
InputTokens int64 `json:"input_tokens"`
|
||||
OutputTokens int64 `json:"output_tokens"`
|
||||
CacheCreationInputTokens int64 `json:"cache_creation_input_tokens,omitempty"`
|
||||
CacheReadInputTokens int64 `json:"cache_read_input_tokens,omitempty"`
|
||||
}
|
||||
|
||||
// UserMsg is a user message (used for tool results).
|
||||
type UserMsg struct {
|
||||
Type string `json:"type"`
|
||||
ParentToolUseID string `json:"parent_tool_use_id,omitempty"`
|
||||
Message UserMsgBody `json:"message"`
|
||||
}
|
||||
|
||||
// UserMsgBody is the body of a user message with tool results.
|
||||
type UserMsgBody struct {
|
||||
Role string `json:"role"`
|
||||
Content []ContentBlock `json:"content"`
|
||||
}
|
||||
|
||||
// ResultMsg is the final result message for a turn.
|
||||
type ResultMsg struct {
|
||||
Type string `json:"type"`
|
||||
Result json.RawMessage `json:"result"`
|
||||
CostUSD float64 `json:"cost_usd"`
|
||||
DurationMS int64 `json:"duration_ms"`
|
||||
DurationAPIMS int64 `json:"duration_api_ms"`
|
||||
IsError bool `json:"is_error"`
|
||||
NumTurns int `json:"num_turns"`
|
||||
TotalInputTokens int64 `json:"total_input_tokens"`
|
||||
TotalOutputTokens int64 `json:"total_output_tokens"`
|
||||
ModelUsage map[string]ModelUsageStats `json:"model_usage,omitempty"`
|
||||
}
|
||||
|
||||
// ModelUsageStats per-model usage statistics.
|
||||
type ModelUsageStats struct {
|
||||
ContextWindow int64 `json:"context_window"`
|
||||
}
|
||||
|
||||
// ResultData is the result object for successful completions.
|
||||
type ResultData struct {
|
||||
Text string `json:"text"`
|
||||
SessionID string `json:"session_id"`
|
||||
}
|
||||
|
||||
// ControlRequestMsg is a control request emitted to stdout (permission requests).
|
||||
type ControlRequestMsg struct {
|
||||
Type string `json:"type"`
|
||||
RequestID string `json:"request_id"`
|
||||
Request ControlRequestBody `json:"request"`
|
||||
}
|
||||
|
||||
// ControlRequestBody is the body of a control request.
|
||||
type ControlRequestBody struct {
|
||||
Subtype string `json:"subtype"`
|
||||
ToolName string `json:"tool_name,omitempty"`
|
||||
Input map[string]any `json:"input,omitempty"`
|
||||
ToolUseID string `json:"tool_use_id,omitempty"`
|
||||
}
|
||||
|
||||
// ControlResponseMsg is a control response emitted to stdout (for initialize).
|
||||
type ControlResponseMsg struct {
|
||||
Type string `json:"type"`
|
||||
Response ControlResponseBody `json:"response"`
|
||||
}
|
||||
|
||||
// ControlResponseBody is the body of a control response.
|
||||
type ControlResponseBody struct {
|
||||
Subtype string `json:"subtype"`
|
||||
RequestID string `json:"request_id"`
|
||||
Response *InitializeResponse `json:"response,omitempty"`
|
||||
}
|
||||
|
||||
// InitializeResponse is the response to an initialize control request.
|
||||
type InitializeResponse struct {
|
||||
Commands []Command `json:"commands"`
|
||||
Agents []string `json:"agents"`
|
||||
}
|
||||
|
||||
// Command is an available slash command.
|
||||
type Command struct {
|
||||
Name string `json:"name"`
|
||||
Description string `json:"description"`
|
||||
ArgumentHint string `json:"argumentHint,omitempty"`
|
||||
}
|
||||
@@ -0,0 +1,121 @@
|
||||
package agents
|
||||
|
||||
import (
|
||||
"context"
|
||||
_ "embed"
|
||||
"time"
|
||||
|
||||
"github.com/kandev/kandev/pkg/agent"
|
||||
)
|
||||
|
||||
//go:embed logos/amp_light.svg
|
||||
var ampACPLogoLight []byte
|
||||
|
||||
//go:embed logos/amp_dark.svg
|
||||
var ampACPLogoDark []byte
|
||||
|
||||
const ampACPPkg = "amp-acp"
|
||||
|
||||
var (
|
||||
_ Agent = (*AmpACP)(nil)
|
||||
_ PassthroughAgent = (*AmpACP)(nil)
|
||||
)
|
||||
|
||||
// AmpACP implements Agent for Sourcegraph Amp using the ACP protocol.
|
||||
// It runs the community amp-acp npm package which bridges Amp to ACP over
|
||||
// stdin/stdout. Used for A/B comparison against the stream-json Amp agent.
|
||||
type AmpACP struct {
|
||||
StandardPassthrough
|
||||
}
|
||||
|
||||
func NewAmpACP() *AmpACP {
|
||||
return &AmpACP{
|
||||
StandardPassthrough: StandardPassthrough{
|
||||
PermSettings: ampPermSettings,
|
||||
Cfg: PassthroughConfig{
|
||||
Supported: true,
|
||||
Label: "CLI Passthrough",
|
||||
Description: "Show terminal directly instead of chat interface",
|
||||
PassthroughCmd: NewCommand("npx", "-y", ampPkg),
|
||||
ModelFlag: NewParam("-m", "{model}"),
|
||||
IdleTimeout: 3 * time.Second,
|
||||
BufferMaxBytes: DefaultBufferMaxBytes,
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func (a *AmpACP) ID() string { return "amp-acp" }
|
||||
func (a *AmpACP) Name() string { return "Amp ACP Agent" }
|
||||
func (a *AmpACP) DisplayName() string { return "Amp (ACP)" }
|
||||
func (a *AmpACP) Description() string {
|
||||
return "Sourcegraph Amp coding agent using the ACP protocol via the community bridge."
|
||||
}
|
||||
func (a *AmpACP) Enabled() bool { return true }
|
||||
func (a *AmpACP) DisplayOrder() int { return 8 }
|
||||
|
||||
func (a *AmpACP) Logo(v LogoVariant) []byte {
|
||||
if v == LogoDark {
|
||||
return ampACPLogoDark
|
||||
}
|
||||
return ampACPLogoLight
|
||||
}
|
||||
|
||||
func (a *AmpACP) IsInstalled(ctx context.Context) (*DiscoveryResult, error) {
|
||||
install := OSPaths{
|
||||
Linux: []string{"~/.amp/bin"},
|
||||
MacOS: []string{"~/.amp/bin"},
|
||||
}
|
||||
mcp := OSPaths{
|
||||
Linux: []string{"~/.config/amp/settings.json"},
|
||||
MacOS: []string{"~/.amp/bin"},
|
||||
}
|
||||
|
||||
result, err := Detect(ctx, WithFileExists(install.Resolve()...))
|
||||
if err != nil {
|
||||
return result, err
|
||||
}
|
||||
result.SupportsMCP = true
|
||||
result.InstallationPaths = install.Expanded()
|
||||
result.MCPConfigPaths = mcp.Expanded()
|
||||
result.Capabilities = DiscoveryCapabilities{
|
||||
SupportsSessionResume: true,
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func (a *AmpACP) DefaultModel() string { return "smart" }
|
||||
|
||||
func (a *AmpACP) ListModels(ctx context.Context) (*ModelList, error) {
|
||||
return &ModelList{Models: ampStaticModels(), SupportsDynamic: false}, nil
|
||||
}
|
||||
|
||||
func (a *AmpACP) BuildCommand(opts CommandOptions) Command {
|
||||
return Cmd("npx", "-y", ampACPPkg).Build()
|
||||
}
|
||||
|
||||
func (a *AmpACP) Runtime() *RuntimeConfig {
|
||||
canRecover := true
|
||||
return &RuntimeConfig{
|
||||
Cmd: Cmd("npx", "-y", ampACPPkg).Build(),
|
||||
WorkingDir: "{workspace}",
|
||||
Env: map[string]string{},
|
||||
ResourceLimits: ResourceLimits{MemoryMB: 4096, CPUCores: 2.0, Timeout: time.Hour},
|
||||
Protocol: agent.ProtocolACP,
|
||||
SessionConfig: SessionConfig{
|
||||
NativeSessionResume: true,
|
||||
CanRecover: &canRecover,
|
||||
SessionDirTemplate: "{home}/.config/amp",
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func (a *AmpACP) RemoteAuth() *RemoteAuth { return nil }
|
||||
|
||||
func (a *AmpACP) InstallScript() string {
|
||||
return "npm install -g " + ampACPPkg
|
||||
}
|
||||
|
||||
func (a *AmpACP) PermissionSettings() map[string]PermissionSetting {
|
||||
return ampPermSettings
|
||||
}
|
||||
@@ -0,0 +1,140 @@
|
||||
package agents
|
||||
|
||||
import (
|
||||
"context"
|
||||
_ "embed"
|
||||
"time"
|
||||
|
||||
"github.com/kandev/kandev/pkg/agent"
|
||||
)
|
||||
|
||||
//go:embed logos/claude_code_light.svg
|
||||
var claudeACPLogoLight []byte
|
||||
|
||||
//go:embed logos/claude_code_dark.svg
|
||||
var claudeACPLogoDark []byte
|
||||
|
||||
const claudeACPPkg = "@zed-industries/claude-agent-acp"
|
||||
|
||||
var (
|
||||
_ Agent = (*ClaudeACP)(nil)
|
||||
_ PassthroughAgent = (*ClaudeACP)(nil)
|
||||
)
|
||||
|
||||
// ClaudeACP implements Agent for the Zed Industries claude-agent-acp package.
|
||||
// It speaks the ACP protocol (JSON-RPC 2.0 over stdin/stdout) and wraps the
|
||||
// Claude Agent SDK. Used for A/B comparison against the stream-json Claude Code agent.
|
||||
type ClaudeACP struct {
|
||||
StandardPassthrough
|
||||
}
|
||||
|
||||
func NewClaudeACP() *ClaudeACP {
|
||||
return &ClaudeACP{
|
||||
StandardPassthrough: StandardPassthrough{
|
||||
PermSettings: claudeCodePermSettings,
|
||||
Cfg: PassthroughConfig{
|
||||
Supported: true,
|
||||
Label: "CLI Passthrough",
|
||||
Description: "Show terminal directly instead of chat interface",
|
||||
PassthroughCmd: NewCommand("npx", "-y", "@anthropic-ai/claude-code", "--verbose"),
|
||||
ModelFlag: NewParam("--model", "{model}"),
|
||||
IdleTimeout: 3 * time.Second,
|
||||
BufferMaxBytes: DefaultBufferMaxBytes,
|
||||
ResumeFlag: NewParam("-c"),
|
||||
SessionResumeFlag: NewParam("--resume"),
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func (a *ClaudeACP) ID() string { return "claude-acp" }
|
||||
func (a *ClaudeACP) Name() string { return "Claude ACP Agent" }
|
||||
func (a *ClaudeACP) DisplayName() string { return "Claude (ACP)" }
|
||||
func (a *ClaudeACP) Description() string {
|
||||
return "Anthropic Claude coding agent using the ACP protocol via the Zed Industries bridge."
|
||||
}
|
||||
func (a *ClaudeACP) Enabled() bool { return true }
|
||||
func (a *ClaudeACP) DisplayOrder() int { return 2 }
|
||||
|
||||
func (a *ClaudeACP) Logo(v LogoVariant) []byte {
|
||||
if v == LogoDark {
|
||||
return claudeACPLogoDark
|
||||
}
|
||||
return claudeACPLogoLight
|
||||
}
|
||||
|
||||
func (a *ClaudeACP) IsInstalled(ctx context.Context) (*DiscoveryResult, error) {
|
||||
result, err := Detect(ctx, WithFileExists("~/.claude.json"))
|
||||
if err != nil {
|
||||
return result, err
|
||||
}
|
||||
result.SupportsMCP = true
|
||||
result.InstallationPaths = []string{expandHomePath("~/.claude.json")}
|
||||
result.Capabilities = DiscoveryCapabilities{
|
||||
SupportsSessionResume: true,
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func (a *ClaudeACP) DefaultModel() string { return "claude-sonnet-4-6" }
|
||||
|
||||
func (a *ClaudeACP) ListModels(ctx context.Context) (*ModelList, error) {
|
||||
return &ModelList{Models: claudeCodeStaticModels(), SupportsDynamic: true}, nil
|
||||
}
|
||||
|
||||
func (a *ClaudeACP) BuildCommand(opts CommandOptions) Command {
|
||||
return Cmd("npx", "-y", claudeACPPkg).Build()
|
||||
}
|
||||
|
||||
func (a *ClaudeACP) Runtime() *RuntimeConfig {
|
||||
canRecover := true
|
||||
return &RuntimeConfig{
|
||||
Image: "kandev/multi-agent",
|
||||
Tag: "latest",
|
||||
Cmd: Cmd("npx", "-y", claudeACPPkg).Build(),
|
||||
WorkingDir: "{workspace}",
|
||||
RequiredEnv: []string{}, // Auth via ANTHROPIC_API_KEY or OAuth credentials file (see RemoteAuth)
|
||||
Env: map[string]string{
|
||||
"MCP_TIMEOUT": "7200000",
|
||||
},
|
||||
Mounts: []MountTemplate{
|
||||
{Source: "{workspace}", Target: "/workspace"},
|
||||
},
|
||||
ResourceLimits: ResourceLimits{MemoryMB: 4096, CPUCores: 2.0, Timeout: time.Hour},
|
||||
Protocol: agent.ProtocolACP,
|
||||
SessionConfig: SessionConfig{
|
||||
NativeSessionResume: true,
|
||||
CanRecover: &canRecover,
|
||||
SessionDirTemplate: "{home}/.claude",
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func (a *ClaudeACP) RemoteAuth() *RemoteAuth {
|
||||
return &RemoteAuth{
|
||||
Methods: []RemoteAuthMethod{
|
||||
{
|
||||
Type: "env",
|
||||
EnvVar: "CLAUDE_CODE_OAUTH_TOKEN",
|
||||
SetupHint: "Run `claude setup-token` to generate a long-lived OAuth token",
|
||||
SetupScript: `mkdir -p "${HOME}/.claude"
|
||||
cat > "${HOME}/.claude/.credentials.json" <<CREDS
|
||||
{"claudeAiOauth":{"accessToken":"${CLAUDE_CODE_OAUTH_TOKEN}","expiresAt":4102444800000}}
|
||||
CREDS
|
||||
cat > "${HOME}/.claude.json" <<'JSON'
|
||||
{"hasCompletedOnboarding":true}
|
||||
JSON
|
||||
chmod 600 "${HOME}/.claude/.credentials.json"
|
||||
chmod 600 "${HOME}/.claude.json"`,
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func (a *ClaudeACP) InstallScript() string {
|
||||
return "npm install -g " + claudeACPPkg
|
||||
}
|
||||
|
||||
func (a *ClaudeACP) PermissionSettings() map[string]PermissionSetting {
|
||||
return claudeCodePermSettings
|
||||
}
|
||||
@@ -0,0 +1,132 @@
|
||||
package agents
|
||||
|
||||
import (
|
||||
"context"
|
||||
_ "embed"
|
||||
"time"
|
||||
|
||||
"github.com/kandev/kandev/pkg/agent"
|
||||
)
|
||||
|
||||
//go:embed logos/codex_light.svg
|
||||
var codexACPLogoLight []byte
|
||||
|
||||
//go:embed logos/codex_dark.svg
|
||||
var codexACPLogoDark []byte
|
||||
|
||||
const codexACPPkg = "@zed-industries/codex-acp"
|
||||
|
||||
var (
|
||||
_ Agent = (*CodexACP)(nil)
|
||||
_ PassthroughAgent = (*CodexACP)(nil)
|
||||
)
|
||||
|
||||
// CodexACP implements Agent for the Zed Industries codex-acp package.
|
||||
// It speaks the ACP protocol (JSON-RPC 2.0 over stdin/stdout) via a Rust binary
|
||||
// wrapping OpenAI Codex. Used for A/B comparison against the native Codex agent.
|
||||
type CodexACP struct {
|
||||
StandardPassthrough
|
||||
}
|
||||
|
||||
func NewCodexACP() *CodexACP {
|
||||
return &CodexACP{
|
||||
StandardPassthrough: StandardPassthrough{
|
||||
PermSettings: codexPermSettings,
|
||||
Cfg: PassthroughConfig{
|
||||
Supported: true,
|
||||
Label: "CLI Passthrough",
|
||||
Description: "Show terminal directly instead of chat interface",
|
||||
PassthroughCmd: NewCommand("npx", "-y", "@openai/codex", "--full-auto"),
|
||||
ModelFlag: NewParam("--model", "{model}"),
|
||||
IdleTimeout: 3 * time.Second,
|
||||
BufferMaxBytes: DefaultBufferMaxBytes,
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func (a *CodexACP) ID() string { return "codex-acp" }
|
||||
func (a *CodexACP) Name() string { return "Codex ACP Agent" }
|
||||
func (a *CodexACP) DisplayName() string { return "Codex (ACP)" }
|
||||
func (a *CodexACP) Description() string {
|
||||
return "OpenAI Codex coding agent using the ACP protocol via the Zed Industries bridge."
|
||||
}
|
||||
func (a *CodexACP) Enabled() bool { return true }
|
||||
func (a *CodexACP) DisplayOrder() int { return 3 }
|
||||
|
||||
func (a *CodexACP) Logo(v LogoVariant) []byte {
|
||||
if v == LogoDark {
|
||||
return codexACPLogoDark
|
||||
}
|
||||
return codexACPLogoLight
|
||||
}
|
||||
|
||||
func (a *CodexACP) IsInstalled(ctx context.Context) (*DiscoveryResult, error) {
|
||||
result, err := Detect(ctx, WithFileExists("~/.codex/auth.json"))
|
||||
if err != nil {
|
||||
return result, err
|
||||
}
|
||||
result.SupportsMCP = true
|
||||
result.InstallationPaths = []string{expandHomePath("~/.codex/auth.json")}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func (a *CodexACP) DefaultModel() string { return "gpt-5.3-codex" }
|
||||
|
||||
func (a *CodexACP) ListModels(ctx context.Context) (*ModelList, error) {
|
||||
return &ModelList{Models: codexStaticModels(), SupportsDynamic: false}, nil
|
||||
}
|
||||
|
||||
func (a *CodexACP) BuildCommand(opts CommandOptions) Command {
|
||||
return Cmd("npx", "-y", codexACPPkg).Build()
|
||||
}
|
||||
|
||||
func (a *CodexACP) Runtime() *RuntimeConfig {
|
||||
canRecover := true
|
||||
return &RuntimeConfig{
|
||||
Image: "kandev/multi-agent",
|
||||
Tag: "latest",
|
||||
Cmd: Cmd("npx", "-y", codexACPPkg).Build(),
|
||||
WorkingDir: "{workspace}",
|
||||
RequiredEnv: []string{"OPENAI_API_KEY"},
|
||||
Env: map[string]string{},
|
||||
Mounts: []MountTemplate{
|
||||
{Source: "{workspace}", Target: "/workspace"},
|
||||
{Source: "{home}/.codex", Target: "/root/.codex"},
|
||||
},
|
||||
ResourceLimits: ResourceLimits{MemoryMB: 4096, CPUCores: 2.0, Timeout: time.Hour},
|
||||
Protocol: agent.ProtocolACP,
|
||||
SessionConfig: SessionConfig{
|
||||
NativeSessionResume: true,
|
||||
CanRecover: &canRecover,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func (a *CodexACP) RemoteAuth() *RemoteAuth {
|
||||
return &RemoteAuth{
|
||||
Methods: []RemoteAuthMethod{
|
||||
{
|
||||
Type: "files",
|
||||
Label: "Copy auth files",
|
||||
SourceFiles: map[string][]string{
|
||||
"darwin": {".codex/auth.json", ".codex/config.toml"},
|
||||
"linux": {".codex/auth.json", ".codex/config.toml"},
|
||||
},
|
||||
TargetRelDir: ".codex",
|
||||
},
|
||||
{
|
||||
Type: "env",
|
||||
EnvVar: "OPENAI_API_KEY",
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func (a *CodexACP) InstallScript() string {
|
||||
return "npm install -g " + codexACPPkg
|
||||
}
|
||||
|
||||
func (a *CodexACP) PermissionSettings() map[string]PermissionSetting {
|
||||
return codexPermSettings
|
||||
}
|
||||
@@ -149,7 +149,7 @@ var copilotPermSettings = map[string]PermissionSetting{
|
||||
|
||||
func copilotStaticModels() []Model {
|
||||
return []Model{
|
||||
{ID: "gpt-4.1", Name: "GPT-4.1", Description: "OpenAI GPT-4.1", Provider: "openai", IsDefault: true, Source: "static"},
|
||||
{ID: "gpt-4.1", Name: "GPT-4.1", Description: "OpenAI GPT-4.1", Provider: "openai", Source: "static"},
|
||||
{ID: "claude-sonnet-4", Name: "Claude Sonnet 4", Description: "Anthropic Claude Sonnet 4", Provider: "anthropic", Source: "static"},
|
||||
{ID: "claude-sonnet-4.5", Name: "Claude Sonnet 4.5", Description: "Anthropic Claude Sonnet 4.5", Provider: "anthropic", Source: "static"},
|
||||
{ID: "claude-opus-4.5", Name: "Claude Opus 4.5", Description: "Anthropic Claude Opus 4.5", Provider: "anthropic", Source: "static"},
|
||||
@@ -161,7 +161,7 @@ func copilotStaticModels() []Model {
|
||||
{ID: "gpt-5.1", Name: "GPT-5.1", Description: "OpenAI GPT-5.1", Provider: "openai", Source: "static"},
|
||||
{ID: "gpt-5", Name: "GPT-5", Description: "OpenAI GPT-5", Provider: "openai", Source: "static"},
|
||||
{ID: "gpt-5.1-codex-mini", Name: "GPT-5.1 Codex Mini", Description: "OpenAI GPT-5.1 Codex Mini", Provider: "openai", Source: "static"},
|
||||
{ID: "gpt-5-mini", Name: "GPT-5 Mini", Description: "OpenAI GPT-5 Mini", Provider: "openai", Source: "static"},
|
||||
{ID: "gpt-5-mini", Name: "GPT-5 Mini", Description: "OpenAI GPT-5 Mini", Provider: "openai", Source: "static", IsDefault: true},
|
||||
{ID: "gemini-3-pro-preview", Name: "Gemini 3 Pro Preview", Description: "Google Gemini 3 Pro Preview", Provider: "google", Source: "static"},
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,126 @@
|
||||
package agents
|
||||
|
||||
import (
|
||||
"context"
|
||||
_ "embed"
|
||||
"time"
|
||||
|
||||
"github.com/kandev/kandev/pkg/agent"
|
||||
)
|
||||
|
||||
//go:embed logos/copilot_light.svg
|
||||
var copilotACPLogoLight []byte
|
||||
|
||||
//go:embed logos/copilot_dark.svg
|
||||
var copilotACPLogoDark []byte
|
||||
|
||||
const copilotACPPkg = "@github/copilot"
|
||||
|
||||
var (
|
||||
_ Agent = (*CopilotACP)(nil)
|
||||
_ PassthroughAgent = (*CopilotACP)(nil)
|
||||
)
|
||||
|
||||
// CopilotACP implements Agent for GitHub Copilot using ACP protocol mode.
|
||||
// It runs the same @github/copilot CLI with the --acp flag, speaking standard
|
||||
// ACP over stdin/stdout. Used for A/B comparison against the Go SDK-based Copilot agent.
|
||||
type CopilotACP struct {
|
||||
StandardPassthrough
|
||||
}
|
||||
|
||||
func NewCopilotACP() *CopilotACP {
|
||||
return &CopilotACP{
|
||||
StandardPassthrough: StandardPassthrough{
|
||||
PermSettings: copilotPermSettings,
|
||||
Cfg: PassthroughConfig{
|
||||
Supported: true,
|
||||
Label: "CLI Passthrough",
|
||||
Description: "Show terminal directly instead of chat interface",
|
||||
PassthroughCmd: NewCommand("npx", "-y", copilotACPPkg),
|
||||
ModelFlag: NewParam("--model", "{model}"),
|
||||
IdleTimeout: 3 * time.Second,
|
||||
BufferMaxBytes: DefaultBufferMaxBytes,
|
||||
ResumeFlag: NewParam("--continue"),
|
||||
SessionResumeFlag: NewParam("--resume"),
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func (a *CopilotACP) ID() string { return "copilot-acp" }
|
||||
func (a *CopilotACP) Name() string { return "Copilot ACP Agent" }
|
||||
func (a *CopilotACP) DisplayName() string { return "Copilot (ACP)" }
|
||||
func (a *CopilotACP) Description() string {
|
||||
return "GitHub Copilot coding agent using the ACP protocol over stdin/stdout."
|
||||
}
|
||||
func (a *CopilotACP) Enabled() bool { return true }
|
||||
func (a *CopilotACP) DisplayOrder() int { return 7 }
|
||||
|
||||
func (a *CopilotACP) Logo(v LogoVariant) []byte {
|
||||
if v == LogoDark {
|
||||
return copilotACPLogoDark
|
||||
}
|
||||
return copilotACPLogoLight
|
||||
}
|
||||
|
||||
func (a *CopilotACP) IsInstalled(ctx context.Context) (*DiscoveryResult, error) {
|
||||
install := OSPaths{
|
||||
MacOS: []string{"~/.copilot/pkg"},
|
||||
}
|
||||
mcp := OSPaths{
|
||||
Linux: []string{"~/.copilot/mcp-config.json"},
|
||||
MacOS: []string{"~/.copilot/mcp-config.json"},
|
||||
}
|
||||
|
||||
result, err := Detect(ctx, WithFileExists(install.Resolve()...))
|
||||
if err != nil {
|
||||
return result, err
|
||||
}
|
||||
result.SupportsMCP = true
|
||||
result.InstallationPaths = install.Expanded()
|
||||
result.MCPConfigPaths = mcp.Expanded()
|
||||
result.Capabilities = DiscoveryCapabilities{
|
||||
SupportsSessionResume: true,
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func (a *CopilotACP) DefaultModel() string { return "gpt-4.1" }
|
||||
|
||||
func (a *CopilotACP) ListModels(ctx context.Context) (*ModelList, error) {
|
||||
return &ModelList{Models: copilotStaticModels(), SupportsDynamic: false}, nil
|
||||
}
|
||||
|
||||
func (a *CopilotACP) BuildCommand(opts CommandOptions) Command {
|
||||
return Cmd("npx", "-y", copilotACPPkg, "--acp").
|
||||
Model(NewParam("--model", "{model}"), opts.Model).
|
||||
Settings(copilotPermSettings, opts.PermissionValues).
|
||||
Build()
|
||||
}
|
||||
|
||||
func (a *CopilotACP) Runtime() *RuntimeConfig {
|
||||
canRecover := true
|
||||
return &RuntimeConfig{
|
||||
Cmd: Cmd("npx", "-y", copilotACPPkg, "--acp").Build(),
|
||||
WorkingDir: "{workspace}",
|
||||
Env: map[string]string{},
|
||||
ResourceLimits: ResourceLimits{MemoryMB: 4096, CPUCores: 2.0, Timeout: time.Hour},
|
||||
Protocol: agent.ProtocolACP,
|
||||
ModelFlag: NewParam("--model", "{model}"),
|
||||
SessionConfig: SessionConfig{
|
||||
NativeSessionResume: true,
|
||||
CanRecover: &canRecover,
|
||||
SessionDirTemplate: "{home}/.copilot",
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func (a *CopilotACP) RemoteAuth() *RemoteAuth { return nil }
|
||||
|
||||
func (a *CopilotACP) InstallScript() string {
|
||||
return "npm install -g " + copilotACPPkg
|
||||
}
|
||||
|
||||
func (a *CopilotACP) PermissionSettings() map[string]PermissionSetting {
|
||||
return copilotPermSettings
|
||||
}
|
||||
@@ -97,7 +97,6 @@ func (a *MockAgent) BuildCommand(opts CommandOptions) Command {
|
||||
}
|
||||
return Cmd(binary).
|
||||
Model(NewParam("--model", "{model}"), opts.Model).
|
||||
Resume(NewParam("--resume"), opts.SessionID, false).
|
||||
Build()
|
||||
}
|
||||
|
||||
@@ -108,10 +107,9 @@ func (a *MockAgent) Runtime() *RuntimeConfig {
|
||||
WorkingDir: "{workspace}",
|
||||
Env: map[string]string{},
|
||||
ResourceLimits: ResourceLimits{MemoryMB: 512, CPUCores: 0.5, Timeout: time.Hour},
|
||||
Protocol: agent.ProtocolClaudeCode,
|
||||
Protocol: agent.ProtocolACP,
|
||||
ModelFlag: NewParam("--model", "{model}"),
|
||||
SessionConfig: SessionConfig{
|
||||
ResumeFlag: NewParam("--resume"),
|
||||
CanRecover: &canRecover,
|
||||
},
|
||||
}
|
||||
|
||||
@@ -2,63 +2,36 @@ package agents
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/kandev/kandev/pkg/agent"
|
||||
)
|
||||
|
||||
func TestMockAgent_BuildCommand_WithSessionID(t *testing.T) {
|
||||
a := NewMockAgent()
|
||||
cmd := a.BuildCommand(CommandOptions{Model: "mock-fast", SessionID: "sess-123"})
|
||||
args := cmd.Args()
|
||||
|
||||
foundResume := false
|
||||
for i, arg := range args {
|
||||
if arg == "--resume" {
|
||||
foundResume = true
|
||||
if i+1 >= len(args) {
|
||||
t.Fatal("--resume flag has no value")
|
||||
}
|
||||
if args[i+1] != "sess-123" {
|
||||
t.Errorf("--resume value = %q, want %q", args[i+1], "sess-123")
|
||||
}
|
||||
break
|
||||
}
|
||||
}
|
||||
if !foundResume {
|
||||
t.Errorf("expected --resume flag in args %v", args)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMockAgent_BuildCommand_WithoutSessionID(t *testing.T) {
|
||||
func TestMockAgent_BuildCommand_WithModel(t *testing.T) {
|
||||
a := NewMockAgent()
|
||||
cmd := a.BuildCommand(CommandOptions{Model: "mock-fast"})
|
||||
args := cmd.Args()
|
||||
|
||||
for _, arg := range args {
|
||||
if arg == "--resume" {
|
||||
t.Errorf("--resume flag should not be present without SessionID, got args %v", args)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestMockAgent_BuildCommand_WithModel(t *testing.T) {
|
||||
a := NewMockAgent()
|
||||
cmd := a.BuildCommand(CommandOptions{Model: "mock-fast", SessionID: "sess-456"})
|
||||
args := cmd.Args()
|
||||
|
||||
foundModel := false
|
||||
foundResume := false
|
||||
for i, arg := range args {
|
||||
if arg == "--model" && i+1 < len(args) && args[i+1] == "mock-fast" {
|
||||
foundModel = true
|
||||
}
|
||||
if arg == "--resume" && i+1 < len(args) && args[i+1] == "sess-456" {
|
||||
foundResume = true
|
||||
}
|
||||
}
|
||||
if !foundModel {
|
||||
t.Errorf("expected --model mock-fast in args %v", args)
|
||||
}
|
||||
if !foundResume {
|
||||
t.Errorf("expected --resume sess-456 in args %v", args)
|
||||
}
|
||||
|
||||
func TestMockAgent_BuildCommand_NoResumeFlag(t *testing.T) {
|
||||
a := NewMockAgent()
|
||||
// ACP handles resume via session/load, so --resume should not appear.
|
||||
cmd := a.BuildCommand(CommandOptions{Model: "mock-fast", SessionID: "sess-123"})
|
||||
args := cmd.Args()
|
||||
|
||||
for _, arg := range args {
|
||||
if arg == "--resume" {
|
||||
t.Errorf("--resume flag should not be present for ACP agent, got args %v", args)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -71,16 +44,22 @@ func TestMockAgent_Runtime_CanRecover(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestMockAgent_Runtime_ResumeFlag(t *testing.T) {
|
||||
func TestMockAgent_Runtime_ProtocolACP(t *testing.T) {
|
||||
a := NewMockAgent()
|
||||
rt := a.Runtime()
|
||||
|
||||
if rt.SessionConfig.ResumeFlag.IsEmpty() {
|
||||
t.Error("expected ResumeFlag to be set on mock agent RuntimeConfig")
|
||||
if rt.Protocol != agent.ProtocolACP {
|
||||
t.Errorf("expected Protocol = %q, got %q", agent.ProtocolACP, rt.Protocol)
|
||||
}
|
||||
flagArgs := rt.SessionConfig.ResumeFlag.Args()
|
||||
if len(flagArgs) == 0 || flagArgs[0] != "--resume" {
|
||||
t.Errorf("expected ResumeFlag args to start with --resume, got %v", flagArgs)
|
||||
}
|
||||
|
||||
func TestMockAgent_Runtime_NoResumeFlag(t *testing.T) {
|
||||
a := NewMockAgent()
|
||||
rt := a.Runtime()
|
||||
|
||||
// ACP agents handle resume via session/load, not CLI flags.
|
||||
if !rt.SessionConfig.ResumeFlag.IsEmpty() {
|
||||
t.Error("expected ResumeFlag to be empty for ACP agent")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -88,7 +67,7 @@ func TestMockAgent_PassthroughConfig_ResumeFlags(t *testing.T) {
|
||||
a := NewMockAgent()
|
||||
pt := a.PassthroughConfig()
|
||||
|
||||
// Generic resume flag (-c)
|
||||
// Generic resume flag (-c) — still used for TUI passthrough mode
|
||||
if pt.ResumeFlag.IsEmpty() {
|
||||
t.Error("expected ResumeFlag to be set on PassthroughConfig")
|
||||
}
|
||||
@@ -97,7 +76,7 @@ func TestMockAgent_PassthroughConfig_ResumeFlags(t *testing.T) {
|
||||
t.Errorf("expected ResumeFlag = -c, got %v", resumeArgs)
|
||||
}
|
||||
|
||||
// Session-specific resume flag (--resume)
|
||||
// Session-specific resume flag (--resume) — TUI passthrough mode
|
||||
if pt.SessionResumeFlag.IsEmpty() {
|
||||
t.Error("expected SessionResumeFlag to be set on PassthroughConfig")
|
||||
}
|
||||
|
||||
@@ -8,15 +8,35 @@ import (
|
||||
)
|
||||
|
||||
var (
|
||||
_ Agent = (*OpenCodeACP)(nil)
|
||||
_ InferenceAgent = (*OpenCodeACP)(nil)
|
||||
_ Agent = (*OpenCodeACP)(nil)
|
||||
_ PassthroughAgent = (*OpenCodeACP)(nil)
|
||||
_ InferenceAgent = (*OpenCodeACP)(nil)
|
||||
)
|
||||
|
||||
// OpenCodeACP is the ACP protocol variant of OpenCode.
|
||||
// Uses JSON-RPC 2.0 over stdin/stdout via "opencode acp" instead of REST/SSE.
|
||||
type OpenCodeACP struct{}
|
||||
type OpenCodeACP struct {
|
||||
StandardPassthrough
|
||||
}
|
||||
|
||||
func NewOpenCodeACP() *OpenCodeACP { return &OpenCodeACP{} }
|
||||
func NewOpenCodeACP() *OpenCodeACP {
|
||||
return &OpenCodeACP{
|
||||
StandardPassthrough: StandardPassthrough{
|
||||
PermSettings: opencodePermSettings,
|
||||
Cfg: PassthroughConfig{
|
||||
Supported: true,
|
||||
Label: "CLI Passthrough",
|
||||
Description: "Show terminal directly instead of chat interface",
|
||||
PassthroughCmd: NewCommand("opencode"),
|
||||
ModelFlag: NewParam("--model", "{model}"),
|
||||
PromptFlag: NewParam("--prompt", "{prompt}"),
|
||||
IdleTimeout: 3 * time.Second,
|
||||
BufferMaxBytes: DefaultBufferMaxBytes,
|
||||
ResumeFlag: NewParam("-c"),
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func (a *OpenCodeACP) ID() string { return "opencode-acp" }
|
||||
func (a *OpenCodeACP) Name() string { return "OpenCode AI Agent (ACP)" }
|
||||
|
||||
@@ -130,6 +130,27 @@ type AgentStreamEventData struct {
|
||||
// CurrentModeID is the active session mode identifier.
|
||||
// Populated when Type is "session_mode".
|
||||
CurrentModeID string `json:"current_mode_id,omitempty"`
|
||||
|
||||
// AvailableModes lists modes the agent supports.
|
||||
// Populated when Type is "session_mode".
|
||||
AvailableModes []streams.SessionModeInfo `json:"available_modes,omitempty"`
|
||||
|
||||
// Agent capabilities (from "agent_capabilities" event)
|
||||
SupportsImage bool `json:"supports_image"`
|
||||
SupportsAudio bool `json:"supports_audio"`
|
||||
SupportsEmbeddedContext bool `json:"supports_embedded_context"`
|
||||
AuthMethods []streams.AuthMethodInfo `json:"auth_methods,omitempty"`
|
||||
|
||||
// Session models (from "session_models" event)
|
||||
CurrentModelID string `json:"current_model_id,omitempty"`
|
||||
SessionModels []streams.SessionModelInfo `json:"session_models,omitempty"`
|
||||
ConfigOptions []streams.ConfigOption `json:"config_options,omitempty"`
|
||||
|
||||
// Usage (attached to "complete" event)
|
||||
Usage *streams.PromptUsage `json:"usage,omitempty"`
|
||||
|
||||
// Plan entries (from "plan" event — ACP/Codex agent todos)
|
||||
PlanEntries []streams.PlanEntry `json:"plan_entries,omitempty"`
|
||||
}
|
||||
|
||||
// AgentStreamEventPayload is the payload for agent stream events (WebSocket streaming).
|
||||
@@ -374,14 +395,76 @@ func (p AvailableCommandsEventPayload) GetSessionID() string {
|
||||
|
||||
// SessionModeEventPayload is the payload for session mode change events.
|
||||
type SessionModeEventPayload struct {
|
||||
TaskID string `json:"task_id"`
|
||||
SessionID string `json:"session_id"`
|
||||
AgentID string `json:"agent_id"`
|
||||
CurrentModeID string `json:"current_mode_id"`
|
||||
Timestamp string `json:"timestamp"`
|
||||
TaskID string `json:"task_id"`
|
||||
SessionID string `json:"session_id"`
|
||||
AgentID string `json:"agent_id"`
|
||||
CurrentModeID string `json:"current_mode_id"`
|
||||
AvailableModes []streams.SessionModeInfo `json:"available_modes,omitempty"`
|
||||
Timestamp string `json:"timestamp"`
|
||||
}
|
||||
|
||||
// GetSessionID returns the session ID for this event (used by event routing).
|
||||
func (p SessionModeEventPayload) GetSessionID() string {
|
||||
return p.SessionID
|
||||
}
|
||||
|
||||
// AgentCapabilitiesEventPayload is the payload for agent capabilities events.
|
||||
type AgentCapabilitiesEventPayload struct {
|
||||
TaskID string `json:"task_id"`
|
||||
SessionID string `json:"session_id"`
|
||||
AgentID string `json:"agent_id"`
|
||||
SupportsImage bool `json:"supports_image"`
|
||||
SupportsAudio bool `json:"supports_audio"`
|
||||
SupportsEmbeddedContext bool `json:"supports_embedded_context"`
|
||||
AuthMethods []streams.AuthMethodInfo `json:"auth_methods"`
|
||||
Timestamp string `json:"timestamp"`
|
||||
}
|
||||
|
||||
// GetSessionID returns the session ID for this event (used by event routing).
|
||||
func (p AgentCapabilitiesEventPayload) GetSessionID() string {
|
||||
return p.SessionID
|
||||
}
|
||||
|
||||
// SessionModelsEventPayload is the payload for session models events.
|
||||
type SessionModelsEventPayload struct {
|
||||
TaskID string `json:"task_id"`
|
||||
SessionID string `json:"session_id"`
|
||||
AgentID string `json:"agent_id"`
|
||||
CurrentModelID string `json:"current_model_id"`
|
||||
Models []streams.SessionModelInfo `json:"models"`
|
||||
ConfigOptions []streams.ConfigOption `json:"config_options,omitempty"`
|
||||
Timestamp string `json:"timestamp"`
|
||||
}
|
||||
|
||||
// GetSessionID returns the session ID for this event (used by event routing).
|
||||
func (p SessionModelsEventPayload) GetSessionID() string {
|
||||
return p.SessionID
|
||||
}
|
||||
|
||||
// SessionTodosEventPayload is the payload for session todos (ACP plan entries) events.
|
||||
type SessionTodosEventPayload struct {
|
||||
TaskID string `json:"task_id"`
|
||||
SessionID string `json:"session_id"`
|
||||
AgentID string `json:"agent_id"`
|
||||
Entries []streams.PlanEntry `json:"entries"`
|
||||
Timestamp string `json:"timestamp"`
|
||||
}
|
||||
|
||||
// GetSessionID returns the session ID for this event (used by event routing).
|
||||
func (p SessionTodosEventPayload) GetSessionID() string {
|
||||
return p.SessionID
|
||||
}
|
||||
|
||||
// SessionPromptUsageEventPayload is the payload for prompt usage events.
|
||||
type SessionPromptUsageEventPayload struct {
|
||||
TaskID string `json:"task_id"`
|
||||
SessionID string `json:"session_id"`
|
||||
AgentID string `json:"agent_id"`
|
||||
Usage *streams.PromptUsage `json:"usage"`
|
||||
Timestamp string `json:"timestamp"`
|
||||
}
|
||||
|
||||
// GetSessionID returns the session ID for this event (used by event routing).
|
||||
func (p SessionPromptUsageEventPayload) GetSessionID() string {
|
||||
return p.SessionID
|
||||
}
|
||||
|
||||
@@ -130,24 +130,34 @@ func (p *EventPublisher) PublishAgentStreamEvent(execution *AgentExecution, even
|
||||
// Build the nested event data
|
||||
// event.SessionID is the ACP session ID (internal agent protocol session)
|
||||
eventData := &AgentStreamEventData{
|
||||
Type: event.Type,
|
||||
ACPSessionID: event.SessionID,
|
||||
Text: event.Text,
|
||||
ToolCallID: event.ToolCallID,
|
||||
ParentToolCallID: event.ParentToolCallID,
|
||||
PendingID: event.PendingID,
|
||||
ToolName: event.ToolName,
|
||||
ToolTitle: event.ToolTitle,
|
||||
ToolStatus: event.ToolStatus,
|
||||
Error: event.Error,
|
||||
SessionStatus: event.SessionStatus,
|
||||
Data: event.Data,
|
||||
Normalized: event.NormalizedPayload,
|
||||
AvailableCommands: event.AvailableCommands,
|
||||
ToolCallContents: event.ToolCallContents,
|
||||
ContentBlocks: event.ContentBlocks,
|
||||
Role: event.Role,
|
||||
CurrentModeID: event.CurrentModeID,
|
||||
Type: event.Type,
|
||||
ACPSessionID: event.SessionID,
|
||||
Text: event.Text,
|
||||
ToolCallID: event.ToolCallID,
|
||||
ParentToolCallID: event.ParentToolCallID,
|
||||
PendingID: event.PendingID,
|
||||
ToolName: event.ToolName,
|
||||
ToolTitle: event.ToolTitle,
|
||||
ToolStatus: event.ToolStatus,
|
||||
Error: event.Error,
|
||||
SessionStatus: event.SessionStatus,
|
||||
Data: event.Data,
|
||||
Normalized: event.NormalizedPayload,
|
||||
AvailableCommands: event.AvailableCommands,
|
||||
ToolCallContents: event.ToolCallContents,
|
||||
ContentBlocks: event.ContentBlocks,
|
||||
Role: event.Role,
|
||||
CurrentModeID: event.CurrentModeID,
|
||||
AvailableModes: event.AvailableModes,
|
||||
SupportsImage: event.SupportsImage,
|
||||
SupportsAudio: event.SupportsAudio,
|
||||
SupportsEmbeddedContext: event.SupportsEmbeddedContext,
|
||||
AuthMethods: event.AuthMethods,
|
||||
CurrentModelID: event.CurrentModelID,
|
||||
SessionModels: event.SessionModels,
|
||||
ConfigOptions: event.ConfigOptions,
|
||||
Usage: event.Usage,
|
||||
PlanEntries: event.PlanEntries,
|
||||
}
|
||||
|
||||
// Build agent event message payload
|
||||
|
||||
@@ -349,6 +349,23 @@ func (m *Manager) handleAgentEvent(execution *AgentExecution, event agentctl.Age
|
||||
case "available_commands":
|
||||
m.handleAvailableCommandsEvent(execution, event)
|
||||
return
|
||||
|
||||
case "session_mode":
|
||||
execution.SetModeState(&CachedModeState{
|
||||
CurrentModeID: event.CurrentModeID,
|
||||
AvailableModes: event.AvailableModes,
|
||||
})
|
||||
// No return — must flow through to PublishAgentStreamEvent so the orchestrator
|
||||
// can filter and re-publish to the dedicated session mode subject.
|
||||
|
||||
case "session_models":
|
||||
execution.SetModelState(&CachedModelState{
|
||||
CurrentModelID: event.CurrentModelID,
|
||||
Models: event.SessionModels,
|
||||
ConfigOptions: event.ConfigOptions,
|
||||
})
|
||||
// No return — must flow through to PublishAgentStreamEvent so the orchestrator
|
||||
// can persist the model and re-publish to the dedicated session models subject.
|
||||
}
|
||||
|
||||
m.eventPublisher.PublishAgentStreamEvent(execution, event)
|
||||
|
||||
@@ -72,6 +72,137 @@ func (m *Manager) CancelAgent(ctx context.Context, executionID string) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// SetSessionMode changes the session mode for a running agent.
|
||||
// Always uses the execution's current ACPSessionID rather than the caller's copy,
|
||||
// which may be stale during startup/restart when the session is being re-initialized.
|
||||
func (m *Manager) SetSessionMode(ctx context.Context, executionID, _ string, modeID string) error {
|
||||
execution, exists := m.executionStore.Get(executionID)
|
||||
if !exists {
|
||||
return fmt.Errorf("execution %q not found", executionID)
|
||||
}
|
||||
if execution.agentctl == nil {
|
||||
return fmt.Errorf("execution %q has no agentctl client", executionID)
|
||||
}
|
||||
if !execution.sessionInitialized || execution.ACPSessionID == "" {
|
||||
return fmt.Errorf("execution %q ACP session is not ready", executionID)
|
||||
}
|
||||
return execution.agentctl.SetMode(ctx, execution.ACPSessionID, modeID)
|
||||
}
|
||||
|
||||
// SetSessionModeBySessionID changes the session mode for a running agent by session ID.
|
||||
func (m *Manager) SetSessionModeBySessionID(ctx context.Context, sessionID, modeID string) error {
|
||||
execution, exists := m.executionStore.GetBySessionID(sessionID)
|
||||
if !exists {
|
||||
return fmt.Errorf("no agent running for session %q", sessionID)
|
||||
}
|
||||
return m.SetSessionMode(ctx, execution.ID, execution.ACPSessionID, modeID)
|
||||
}
|
||||
|
||||
// SetSessionModel changes the session model for a running agent.
|
||||
func (m *Manager) SetSessionModel(ctx context.Context, executionID, modelID string) error {
|
||||
execution, exists := m.executionStore.Get(executionID)
|
||||
if !exists {
|
||||
return fmt.Errorf("execution %q not found", executionID)
|
||||
}
|
||||
if execution.agentctl == nil {
|
||||
return fmt.Errorf("execution %q has no agentctl client", executionID)
|
||||
}
|
||||
return execution.agentctl.SetModel(ctx, modelID)
|
||||
}
|
||||
|
||||
// SetSessionModelBySessionID changes the session model for a running agent by session ID.
|
||||
func (m *Manager) SetSessionModelBySessionID(ctx context.Context, sessionID, modelID string) error {
|
||||
execution, exists := m.executionStore.GetBySessionID(sessionID)
|
||||
if !exists {
|
||||
return fmt.Errorf("no agent running for session %q", sessionID)
|
||||
}
|
||||
return m.SetSessionModel(ctx, execution.ID, modelID)
|
||||
}
|
||||
|
||||
// AuthenticateBySessionID triggers authentication for a given auth method on the agent.
|
||||
func (m *Manager) AuthenticateBySessionID(ctx context.Context, sessionID, methodID string) error {
|
||||
execution, exists := m.executionStore.GetBySessionID(sessionID)
|
||||
if !exists {
|
||||
return fmt.Errorf("no agent running for session %q", sessionID)
|
||||
}
|
||||
if execution.agentctl == nil {
|
||||
return fmt.Errorf("execution %q has no agentctl client", execution.ID)
|
||||
}
|
||||
return execution.agentctl.Authenticate(ctx, methodID)
|
||||
}
|
||||
|
||||
// ResetAgentContext resets the agent's conversation context. For ACP agents that support
|
||||
// session reset, this creates a new session on the existing connection (fast, no process restart).
|
||||
// For all other agents, this falls back to RestartAgentProcess (full subprocess restart).
|
||||
func (m *Manager) ResetAgentContext(ctx context.Context, executionID string) error {
|
||||
execution, exists := m.executionStore.Get(executionID)
|
||||
if !exists {
|
||||
return fmt.Errorf("execution %q not found: %w", executionID, ErrExecutionNotFound)
|
||||
}
|
||||
|
||||
// Passthrough agents always need full restart
|
||||
if execution.PassthroughProcessID != "" {
|
||||
return m.RestartAgentProcess(ctx, executionID)
|
||||
}
|
||||
|
||||
if execution.agentctl == nil {
|
||||
return fmt.Errorf("execution %q has no agentctl client", executionID)
|
||||
}
|
||||
|
||||
// Resolve agent config and MCP servers for session reset
|
||||
agentConfig, err := m.getAgentConfigForExecution(execution)
|
||||
if err != nil {
|
||||
m.logger.Info("cannot resolve agent config for session reset, falling back to process restart",
|
||||
zap.String("execution_id", executionID), zap.Error(err))
|
||||
return m.RestartAgentProcess(ctx, executionID)
|
||||
}
|
||||
|
||||
mcpServers, err := m.resolveMcpServers(ctx, execution, agentConfig)
|
||||
if err != nil {
|
||||
m.logger.Warn("cannot resolve MCP servers for session reset, falling back to process restart",
|
||||
zap.String("execution_id", executionID), zap.Error(err))
|
||||
return m.RestartAgentProcess(ctx, executionID)
|
||||
}
|
||||
|
||||
// Try session-level reset (only ACP adapters support this)
|
||||
newSessionID, err := execution.agentctl.ResetSession(ctx, execution.WorkspacePath, mcpServers)
|
||||
if err != nil {
|
||||
m.logger.Info("session reset not supported, falling back to process restart",
|
||||
zap.String("execution_id", executionID), zap.Error(err))
|
||||
return m.RestartAgentProcess(ctx, executionID)
|
||||
}
|
||||
|
||||
// Success — update execution state without restarting process
|
||||
_ = m.executionStore.WithLock(executionID, func(exec *AgentExecution) {
|
||||
exec.ACPSessionID = newSessionID
|
||||
exec.Status = v1.AgentStatusReady
|
||||
exec.needsResumeContext = false
|
||||
exec.resumeContextInjected = false
|
||||
|
||||
exec.messageMu.Lock()
|
||||
exec.messageBuffer.Reset()
|
||||
exec.thinkingBuffer.Reset()
|
||||
exec.currentMessageID = ""
|
||||
exec.currentThinkingID = ""
|
||||
exec.messageMu.Unlock()
|
||||
|
||||
// Drain any stale prompt completion signal
|
||||
select {
|
||||
case <-exec.promptDoneCh:
|
||||
default:
|
||||
}
|
||||
})
|
||||
|
||||
m.logger.Info("agent context reset via session (no process restart)",
|
||||
zap.String("execution_id", executionID),
|
||||
zap.String("session_id", execution.SessionID),
|
||||
zap.String("new_acp_session_id", newSessionID))
|
||||
|
||||
m.eventPublisher.PublishAgentEvent(ctx, events.AgentContextReset, execution)
|
||||
m.eventPublisher.PublishAgentEvent(ctx, events.AgentReady, execution)
|
||||
return nil
|
||||
}
|
||||
|
||||
// CancelAgentBySessionID cancels the current agent turn for a specific session
|
||||
func (m *Manager) CancelAgentBySessionID(ctx context.Context, sessionID string) error {
|
||||
execution, exists := m.executionStore.GetBySessionID(sessionID)
|
||||
@@ -369,6 +500,26 @@ func (m *Manager) GetAvailableCommandsForSession(sessionID string) []streams.Ava
|
||||
return execution.GetAvailableCommands()
|
||||
}
|
||||
|
||||
// GetModeStateForSession returns the cached session mode state.
|
||||
// Returns nil if the session has no execution or no mode state cached.
|
||||
func (m *Manager) GetModeStateForSession(sessionID string) *CachedModeState {
|
||||
execution, exists := m.executionStore.GetBySessionID(sessionID)
|
||||
if !exists {
|
||||
return nil
|
||||
}
|
||||
return execution.GetModeState()
|
||||
}
|
||||
|
||||
// GetModelStateForSession returns the cached session model state.
|
||||
// Returns nil if the session has no execution or no model state cached.
|
||||
func (m *Manager) GetModelStateForSession(sessionID string) *CachedModelState {
|
||||
execution, exists := m.executionStore.GetBySessionID(sessionID)
|
||||
if !exists {
|
||||
return nil
|
||||
}
|
||||
return execution.GetModelState()
|
||||
}
|
||||
|
||||
// ListExecutions returns all currently tracked agent executions.
|
||||
//
|
||||
// Returns a snapshot of all executions in memory at the time of call. The returned slice
|
||||
@@ -520,6 +671,16 @@ func (m *Manager) MarkCompleted(executionID string, exitCode int, errorMessage s
|
||||
return fmt.Errorf("execution %q not found", executionID)
|
||||
}
|
||||
|
||||
// Guard against duplicate completion (e.g. ACP prompt error + process exit error).
|
||||
// MarkCompleted is a terminal transition — once in Completed/Failed, skip re-publishing.
|
||||
if execution.Status == v1.AgentStatusCompleted || execution.Status == v1.AgentStatusFailed {
|
||||
m.logger.Warn("ignoring duplicate MarkCompleted for already-terminal execution",
|
||||
zap.String("execution_id", executionID),
|
||||
zap.String("current_status", string(execution.Status)),
|
||||
zap.Int("exit_code", exitCode))
|
||||
return nil
|
||||
}
|
||||
|
||||
_ = m.executionStore.WithLock(executionID, func(exec *AgentExecution) {
|
||||
now := time.Now()
|
||||
exec.FinishedAt = &now
|
||||
|
||||
@@ -72,6 +72,34 @@ func TestManager_MarkCompleted_Failure(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestManager_MarkCompleted_Idempotent(t *testing.T) {
|
||||
mgr := newTestManager()
|
||||
|
||||
execution := &AgentExecution{
|
||||
ID: "test-execution-id",
|
||||
TaskID: "test-task-id",
|
||||
AgentProfileID: "test-agent",
|
||||
Status: v1.AgentStatusFailed,
|
||||
StartedAt: time.Now(),
|
||||
}
|
||||
exitCode := 1
|
||||
execution.ExitCode = &exitCode
|
||||
execution.ErrorMessage = "first error"
|
||||
|
||||
mgr.executionStore.Add(execution)
|
||||
|
||||
// Second MarkCompleted should be a no-op (already terminal)
|
||||
err := mgr.MarkCompleted("test-execution-id", 1, "second error")
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
|
||||
got, _ := mgr.GetExecution("test-execution-id")
|
||||
if got.ErrorMessage != "first error" {
|
||||
t.Errorf("expected original error message preserved, got %q", got.ErrorMessage)
|
||||
}
|
||||
}
|
||||
|
||||
func TestManager_MarkCompleted_NotFound(t *testing.T) {
|
||||
mgr := newTestManager()
|
||||
|
||||
|
||||
@@ -144,7 +144,21 @@ func runtimeName(rt ExecutorBackend) executor.Name {
|
||||
return rt.Name()
|
||||
}
|
||||
|
||||
// resolveProfileModel resolves the model configured on an agent profile.
|
||||
// Returns empty string if the profile cannot be resolved.
|
||||
func (m *Manager) resolveProfileModel(ctx context.Context, profileID string) string {
|
||||
if profileID == "" || m.profileResolver == nil {
|
||||
return ""
|
||||
}
|
||||
info, err := m.profileResolver.ResolveProfile(ctx, profileID)
|
||||
if err != nil || info == nil {
|
||||
return ""
|
||||
}
|
||||
return info.Model
|
||||
}
|
||||
|
||||
// initializeACPSession delegates to SessionManager for full ACP session initialization and prompting
|
||||
func (m *Manager) initializeACPSession(ctx context.Context, execution *AgentExecution, agentConfig agents.Agent, taskDescription string, mcpServers []agentctltypes.McpServer) error {
|
||||
return m.sessionManager.InitializeAndPrompt(ctx, execution, agentConfig, taskDescription, mcpServers, m.MarkReady)
|
||||
profileModel := m.resolveProfileModel(ctx, execution.AgentProfileID)
|
||||
return m.sessionManager.InitializeAndPrompt(ctx, execution, agentConfig, taskDescription, mcpServers, m.MarkReady, profileModel)
|
||||
}
|
||||
|
||||
@@ -124,6 +124,11 @@ func (sm *SessionManager) createOrLoadSession(
|
||||
mcpServers []agentctltypes.McpServer,
|
||||
) (string, error) {
|
||||
rt := agentConfig.Runtime()
|
||||
sm.logger.Debug("createOrLoadSession decision",
|
||||
zap.String("agent_type", agentConfig.ID()),
|
||||
zap.Bool("native_session_resume", rt.SessionConfig.NativeSessionResume),
|
||||
zap.String("existing_session_id", existingSessionID),
|
||||
zap.Bool("will_attempt_load", rt.SessionConfig.NativeSessionResume && existingSessionID != ""))
|
||||
if rt.SessionConfig.NativeSessionResume && existingSessionID != "" {
|
||||
sessionID, err := sm.loadSession(ctx, client, agentConfig, existingSessionID)
|
||||
if err != nil {
|
||||
@@ -258,6 +263,7 @@ func (sm *SessionManager) InitializeAndPrompt(
|
||||
taskDescription string,
|
||||
mcpServers []agentctltypes.McpServer,
|
||||
markReady func(executionID string) error,
|
||||
profileModel string,
|
||||
) error {
|
||||
// Create session-level trace span to group all operations under one trace
|
||||
_, sessionSpan := tracing.TraceSessionStart(
|
||||
@@ -321,6 +327,21 @@ func (sm *SessionManager) InitializeAndPrompt(
|
||||
execution.ACPSessionID = result.SessionID
|
||||
execution.sessionInitialized = true
|
||||
|
||||
// Set the user's configured profile model if it differs from the agent's default.
|
||||
// ACP agents ignore --model CLI flags, so the model must be set via ACP protocol.
|
||||
if profileModel != "" && profileModel != agentConfig.DefaultModel() && execution.agentctl != nil {
|
||||
if err := execution.agentctl.SetModel(ctx, profileModel); err != nil {
|
||||
sm.logger.Warn("failed to set profile model via ACP",
|
||||
zap.String("execution_id", execution.ID),
|
||||
zap.String("model", profileModel),
|
||||
zap.Error(err))
|
||||
} else {
|
||||
sm.logger.Info("set profile model on ACP session",
|
||||
zap.String("execution_id", execution.ID),
|
||||
zap.String("model", profileModel))
|
||||
}
|
||||
}
|
||||
|
||||
// Publish session created event
|
||||
if sm.eventPublisher != nil {
|
||||
sm.eventPublisher.PublishACPSessionCreated(execution, result.SessionID)
|
||||
|
||||
@@ -234,7 +234,7 @@ func TestInitializeAndPrompt_StreamBeforeInitialize(t *testing.T) {
|
||||
|
||||
err := sm.InitializeAndPrompt(ctx, execution, agentConfig, "", nil, func(executionID string) error {
|
||||
return nil
|
||||
})
|
||||
}, "")
|
||||
if err != nil {
|
||||
t.Fatalf("InitializeAndPrompt failed: %v", err)
|
||||
}
|
||||
@@ -306,7 +306,7 @@ func TestInitializeAndPrompt_StreamTimeout(t *testing.T) {
|
||||
|
||||
err := sm.InitializeAndPrompt(ctx, execution, agentConfig, "", nil, func(executionID string) error {
|
||||
return nil
|
||||
})
|
||||
}, "")
|
||||
|
||||
// Should fail because stream couldn't connect and Initialize fails
|
||||
if err == nil {
|
||||
@@ -359,7 +359,7 @@ func TestInitializeAndPrompt_WithTaskDescription(t *testing.T) {
|
||||
|
||||
err := sm.InitializeAndPrompt(ctx, execution, agentConfig, "Build a feature", nil, func(executionID string) error {
|
||||
return nil
|
||||
})
|
||||
}, "")
|
||||
if err != nil {
|
||||
t.Fatalf("InitializeAndPrompt failed: %v", err)
|
||||
}
|
||||
@@ -427,7 +427,7 @@ func TestInitializeAndPrompt_NoStreamManager(t *testing.T) {
|
||||
// But it should NOT panic due to nil streamManager.
|
||||
err := sm.InitializeAndPrompt(ctx, execution, agentConfig, "", nil, func(executionID string) error {
|
||||
return nil
|
||||
})
|
||||
}, "")
|
||||
|
||||
// Expect error because Initialize call over WS will fail (stream not connected)
|
||||
if err == nil {
|
||||
|
||||
@@ -84,6 +84,14 @@ type AgentExecution struct {
|
||||
availableCommands []streams.AvailableCommand
|
||||
availableCommandsMu sync.RWMutex
|
||||
|
||||
// Cached session mode state (for re-sending on subscribe after page refresh)
|
||||
modeState *CachedModeState
|
||||
modeStateMu sync.RWMutex
|
||||
|
||||
// Cached session model state (for re-sending on subscribe after page refresh)
|
||||
modelState *CachedModelState
|
||||
modelStateMu sync.RWMutex
|
||||
|
||||
// Channel signaled by handleAgentEvent(complete) or stream disconnect to unblock SendPrompt.
|
||||
// Buffered (size 1) so the sender never blocks.
|
||||
promptDoneCh chan PromptCompletionSignal
|
||||
@@ -140,6 +148,47 @@ func (ae *AgentExecution) GetAvailableCommands() []streams.AvailableCommand {
|
||||
return ae.availableCommands
|
||||
}
|
||||
|
||||
// CachedModeState holds the last-known session mode state for re-sending on subscribe.
|
||||
type CachedModeState struct {
|
||||
CurrentModeID string
|
||||
AvailableModes []streams.SessionModeInfo
|
||||
}
|
||||
|
||||
// CachedModelState holds the last-known session model state for re-sending on subscribe.
|
||||
type CachedModelState struct {
|
||||
CurrentModelID string
|
||||
Models []streams.SessionModelInfo
|
||||
ConfigOptions []streams.ConfigOption
|
||||
}
|
||||
|
||||
// SetModeState caches the session mode state on this execution.
|
||||
func (ae *AgentExecution) SetModeState(state *CachedModeState) {
|
||||
ae.modeStateMu.Lock()
|
||||
defer ae.modeStateMu.Unlock()
|
||||
ae.modeState = state
|
||||
}
|
||||
|
||||
// GetModeState returns the cached session mode state.
|
||||
func (ae *AgentExecution) GetModeState() *CachedModeState {
|
||||
ae.modeStateMu.RLock()
|
||||
defer ae.modeStateMu.RUnlock()
|
||||
return ae.modeState
|
||||
}
|
||||
|
||||
// SetModelState caches the session model state on this execution.
|
||||
func (ae *AgentExecution) SetModelState(state *CachedModelState) {
|
||||
ae.modelStateMu.Lock()
|
||||
defer ae.modelStateMu.Unlock()
|
||||
ae.modelState = state
|
||||
}
|
||||
|
||||
// GetModelState returns the cached session model state.
|
||||
func (ae *AgentExecution) GetModelState() *CachedModelState {
|
||||
ae.modelStateMu.RLock()
|
||||
defer ae.modelStateMu.RUnlock()
|
||||
return ae.modelState
|
||||
}
|
||||
|
||||
// SetSessionSpan stores the session-level trace span on the execution.
|
||||
func (ae *AgentExecution) SetSessionSpan(span trace.Span) {
|
||||
ae.sessionSpanMu.Lock()
|
||||
|
||||
@@ -47,12 +47,16 @@ func (r *Registry) LoadDefaults() {
|
||||
all := []agents.Agent{
|
||||
agents.NewAuggie(),
|
||||
agents.NewClaudeCode(),
|
||||
agents.NewClaudeACP(),
|
||||
agents.NewCodex(),
|
||||
agents.NewCodexACP(),
|
||||
agents.NewCopilot(),
|
||||
agents.NewCopilotACP(),
|
||||
agents.NewGemini(),
|
||||
agents.NewOpenCode(),
|
||||
agents.NewOpenCodeACP(),
|
||||
agents.NewAmp(),
|
||||
agents.NewAmpACP(),
|
||||
agents.NewMockAgent(),
|
||||
}
|
||||
|
||||
|
||||
@@ -77,36 +77,48 @@ type NewSessionResponse struct {
|
||||
Error string `json:"error,omitempty"`
|
||||
}
|
||||
|
||||
// NewSession creates a new ACP session via the agent WebSocket stream.
|
||||
func (c *Client) NewSession(ctx context.Context, cwd string, mcpServers []types.McpServer) (string, error) {
|
||||
// createSessionRequest sends a session creation request and parses the response.
|
||||
// Used by both NewSession and ResetSession which share the same payload/response format.
|
||||
func (c *Client) createSessionRequest(ctx context.Context, action, cwd string, mcpServers []types.McpServer) (string, error) {
|
||||
payload := struct {
|
||||
Cwd string `json:"cwd"`
|
||||
McpServers []types.McpServer `json:"mcp_servers,omitempty"`
|
||||
}{Cwd: cwd, McpServers: mcpServers}
|
||||
|
||||
resp, err := c.sendStreamRequest(ctx, "agent.session.new", payload)
|
||||
resp, err := c.sendStreamRequest(ctx, action, payload)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("new session request failed: %w", err)
|
||||
return "", fmt.Errorf("%s request failed: %w", action, err)
|
||||
}
|
||||
|
||||
if resp.Type == ws.MessageTypeError {
|
||||
var errPayload ws.ErrorPayload
|
||||
if err := resp.ParsePayload(&errPayload); err != nil {
|
||||
return "", fmt.Errorf("new session failed: unable to parse error")
|
||||
return "", fmt.Errorf("%s failed: unable to parse error", action)
|
||||
}
|
||||
return "", fmt.Errorf("new session failed: %s", errPayload.Message)
|
||||
return "", fmt.Errorf("%s failed: %s", action, errPayload.Message)
|
||||
}
|
||||
|
||||
var result NewSessionResponse
|
||||
if err := resp.ParsePayload(&result); err != nil {
|
||||
return "", fmt.Errorf("failed to parse new session response: %w", err)
|
||||
return "", fmt.Errorf("failed to parse %s response: %w", action, err)
|
||||
}
|
||||
if !result.Success {
|
||||
return "", fmt.Errorf("new session failed: %s", result.Error)
|
||||
return "", fmt.Errorf("%s failed: %s", action, result.Error)
|
||||
}
|
||||
return result.SessionID, nil
|
||||
}
|
||||
|
||||
// NewSession creates a new ACP session via the agent WebSocket stream.
|
||||
func (c *Client) NewSession(ctx context.Context, cwd string, mcpServers []types.McpServer) (string, error) {
|
||||
return c.createSessionRequest(ctx, "agent.session.new", cwd, mcpServers)
|
||||
}
|
||||
|
||||
// ResetSession creates a new session on the same connection, resetting context without
|
||||
// restarting the subprocess. Returns the new session ID or an error if not supported.
|
||||
func (c *Client) ResetSession(ctx context.Context, cwd string, mcpServers []types.McpServer) (string, error) {
|
||||
return c.createSessionRequest(ctx, "agent.session.reset", cwd, mcpServers)
|
||||
}
|
||||
|
||||
// LoadSession resumes an existing ACP session via the agent WebSocket stream.
|
||||
func (c *Client) LoadSession(ctx context.Context, sessionID string) error {
|
||||
payload := struct {
|
||||
@@ -139,6 +151,73 @@ func (c *Client) LoadSession(ctx context.Context, sessionID string) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// SetMode changes the agent's session mode via the agent WebSocket stream.
|
||||
func (c *Client) SetMode(ctx context.Context, sessionID, modeID string) error {
|
||||
payload := struct {
|
||||
SessionID string `json:"session_id"`
|
||||
ModeID string `json:"mode_id"`
|
||||
}{SessionID: sessionID, ModeID: modeID}
|
||||
|
||||
resp, err := c.sendStreamRequest(ctx, "agent.session.set_mode", payload)
|
||||
if err != nil {
|
||||
return fmt.Errorf("set mode request failed: %w", err)
|
||||
}
|
||||
|
||||
if resp.Type == ws.MessageTypeError {
|
||||
var errPayload ws.ErrorPayload
|
||||
if err := resp.ParsePayload(&errPayload); err != nil {
|
||||
return fmt.Errorf("set mode failed: unable to parse error")
|
||||
}
|
||||
return fmt.Errorf("set mode failed: %s", errPayload.Message)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// SetModel changes the agent's model via the agent WebSocket stream.
|
||||
func (c *Client) SetModel(ctx context.Context, modelID string) error {
|
||||
payload := struct {
|
||||
ModelID string `json:"model_id"`
|
||||
}{ModelID: modelID}
|
||||
|
||||
resp, err := c.sendStreamRequest(ctx, "agent.session.set_model", payload)
|
||||
if err != nil {
|
||||
return fmt.Errorf("set model request failed: %w", err)
|
||||
}
|
||||
|
||||
if resp.Type == ws.MessageTypeError {
|
||||
var errPayload ws.ErrorPayload
|
||||
if err := resp.ParsePayload(&errPayload); err != nil {
|
||||
return fmt.Errorf("set model failed: unable to parse error")
|
||||
}
|
||||
return fmt.Errorf("set model failed: %s", errPayload.Message)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Authenticate triggers authentication for a given auth method via the agent WebSocket stream.
|
||||
func (c *Client) Authenticate(ctx context.Context, methodID string) error {
|
||||
payload := struct {
|
||||
MethodID string `json:"method_id"`
|
||||
}{MethodID: methodID}
|
||||
|
||||
resp, err := c.sendStreamRequest(ctx, "agent.session.authenticate", payload)
|
||||
if err != nil {
|
||||
return fmt.Errorf("authenticate request failed: %w", err)
|
||||
}
|
||||
|
||||
if resp.Type == ws.MessageTypeError {
|
||||
var errPayload ws.ErrorPayload
|
||||
if err := resp.ParsePayload(&errPayload); err != nil {
|
||||
return fmt.Errorf("authenticate failed: unable to parse error")
|
||||
}
|
||||
return fmt.Errorf("authenticate failed: %s", errPayload.Message)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Prompt sends a fire-and-forget prompt to the agent via the agent WebSocket stream.
|
||||
// The server returns an accepted response immediately; completion is signaled via stream events.
|
||||
// Attachments (images) are passed to the agent if provided.
|
||||
|
||||
@@ -27,6 +27,7 @@ type PermissionRequestHandler func(ctx context.Context, req *types.PermissionReq
|
||||
type Client struct {
|
||||
logger *zap.Logger
|
||||
workspaceRoot string
|
||||
terminals *TerminalManager
|
||||
|
||||
mu sync.RWMutex
|
||||
updateHandler UpdateHandler
|
||||
@@ -73,6 +74,7 @@ func NewClient(opts ...ClientOption) *Client {
|
||||
for _, opt := range opts {
|
||||
opt(c)
|
||||
}
|
||||
c.terminals = NewTerminalManager(c.logger)
|
||||
return c
|
||||
}
|
||||
|
||||
@@ -363,55 +365,98 @@ func (c *Client) WriteTextFile(ctx context.Context, p acp.WriteTextFileRequest)
|
||||
return acp.WriteTextFileResponse{}, err
|
||||
}
|
||||
|
||||
// CreateTerminal creates a new terminal
|
||||
// CreateTerminal starts a command in a new terminal.
|
||||
func (c *Client) CreateTerminal(ctx context.Context, p acp.CreateTerminalRequest) (acp.CreateTerminalResponse, error) {
|
||||
_, span := shared.TraceProtocolRequest(ctx, shared.ProtocolACP, "", "request.create_terminal")
|
||||
defer span.End()
|
||||
span.SetAttributes(attribute.String("command", p.Command))
|
||||
|
||||
c.logger.Debug("create terminal request", zap.String("command", p.Command))
|
||||
return acp.CreateTerminalResponse{TerminalId: "t-1"}, nil
|
||||
c.logger.Debug("create terminal request",
|
||||
zap.String("command", p.Command),
|
||||
zap.Strings("args", p.Args),
|
||||
)
|
||||
|
||||
cwd := c.workspaceRoot
|
||||
if p.Cwd != nil {
|
||||
cwd = *p.Cwd
|
||||
}
|
||||
env := make(map[string]string, len(p.Env))
|
||||
for _, e := range p.Env {
|
||||
env[e.Name] = e.Value
|
||||
}
|
||||
limit := 0
|
||||
if p.OutputByteLimit != nil {
|
||||
limit = *p.OutputByteLimit
|
||||
}
|
||||
|
||||
id, err := c.terminals.Create(p.Command, p.Args, cwd, env, limit)
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
return acp.CreateTerminalResponse{}, err
|
||||
}
|
||||
return acp.CreateTerminalResponse{TerminalId: id}, nil
|
||||
}
|
||||
|
||||
// KillTerminalCommand kills a terminal command
|
||||
// KillTerminalCommand sends SIGTERM to a terminal's process.
|
||||
func (c *Client) KillTerminalCommand(ctx context.Context, p acp.KillTerminalCommandRequest) (acp.KillTerminalCommandResponse, error) {
|
||||
_, span := shared.TraceProtocolRequest(ctx, shared.ProtocolACP, "", "request.kill_terminal_command")
|
||||
defer span.End()
|
||||
span.SetAttributes(attribute.String("terminal_id", p.TerminalId))
|
||||
|
||||
c.logger.Debug("kill terminal request", zap.String("terminal_id", p.TerminalId))
|
||||
if err := c.terminals.Kill(p.TerminalId); err != nil {
|
||||
span.RecordError(err)
|
||||
return acp.KillTerminalCommandResponse{}, err
|
||||
}
|
||||
return acp.KillTerminalCommandResponse{}, nil
|
||||
}
|
||||
|
||||
// TerminalOutput gets terminal output
|
||||
// TerminalOutput returns the current output of a terminal.
|
||||
func (c *Client) TerminalOutput(ctx context.Context, p acp.TerminalOutputRequest) (acp.TerminalOutputResponse, error) {
|
||||
_, span := shared.TraceProtocolRequest(ctx, shared.ProtocolACP, "", "request.terminal_output")
|
||||
defer span.End()
|
||||
span.SetAttributes(attribute.String("terminal_id", p.TerminalId))
|
||||
|
||||
c.logger.Debug("terminal output request", zap.String("terminal_id", p.TerminalId))
|
||||
return acp.TerminalOutputResponse{Output: "ok", Truncated: false}, nil
|
||||
output, truncated, exitCode, signal, err := c.terminals.Output(p.TerminalId)
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
return acp.TerminalOutputResponse{}, err
|
||||
}
|
||||
|
||||
resp := acp.TerminalOutputResponse{
|
||||
Output: output,
|
||||
Truncated: truncated,
|
||||
}
|
||||
if exitCode != nil || signal != nil {
|
||||
resp.ExitStatus = &acp.TerminalExitStatus{
|
||||
ExitCode: exitCode,
|
||||
Signal: signal,
|
||||
}
|
||||
}
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
// ReleaseTerminal releases a terminal
|
||||
// ReleaseTerminal kills (if running) and releases a terminal.
|
||||
func (c *Client) ReleaseTerminal(ctx context.Context, p acp.ReleaseTerminalRequest) (acp.ReleaseTerminalResponse, error) {
|
||||
_, span := shared.TraceProtocolRequest(ctx, shared.ProtocolACP, "", "request.release_terminal")
|
||||
defer span.End()
|
||||
span.SetAttributes(attribute.String("terminal_id", p.TerminalId))
|
||||
|
||||
c.logger.Debug("release terminal request", zap.String("terminal_id", p.TerminalId))
|
||||
_ = c.terminals.Release(p.TerminalId)
|
||||
return acp.ReleaseTerminalResponse{}, nil
|
||||
}
|
||||
|
||||
// WaitForTerminalExit waits for terminal to exit
|
||||
// WaitForTerminalExit blocks until the terminal's command exits.
|
||||
func (c *Client) WaitForTerminalExit(ctx context.Context, p acp.WaitForTerminalExitRequest) (acp.WaitForTerminalExitResponse, error) {
|
||||
_, span := shared.TraceProtocolRequest(ctx, shared.ProtocolACP, "", "request.wait_for_terminal_exit")
|
||||
defer span.End()
|
||||
span.SetAttributes(attribute.String("terminal_id", p.TerminalId))
|
||||
|
||||
c.logger.Debug("wait for terminal exit request", zap.String("terminal_id", p.TerminalId))
|
||||
exitCode := 0
|
||||
return acp.WaitForTerminalExitResponse{ExitCode: &exitCode}, nil
|
||||
exitCode, signal, err := c.terminals.WaitForExit(p.TerminalId)
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
return acp.WaitForTerminalExitResponse{}, err
|
||||
}
|
||||
return acp.WaitForTerminalExitResponse{ExitCode: exitCode, Signal: signal}, nil
|
||||
}
|
||||
|
||||
// Verify interface implementation
|
||||
|
||||
@@ -0,0 +1,232 @@
|
||||
package acp
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"os"
|
||||
"os/exec"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"syscall"
|
||||
|
||||
"go.uber.org/zap"
|
||||
)
|
||||
|
||||
// terminal represents a single ACP terminal (one command execution).
|
||||
type terminal struct {
|
||||
cmd *exec.Cmd
|
||||
output *terminalOutput
|
||||
doneCh chan struct{} // closed when the process exits
|
||||
mu sync.Mutex
|
||||
killed bool
|
||||
}
|
||||
|
||||
// terminalOutput is a thread-safe, bounded output buffer.
|
||||
type terminalOutput struct {
|
||||
mu sync.Mutex
|
||||
buf bytes.Buffer
|
||||
limit int
|
||||
truncated bool
|
||||
}
|
||||
|
||||
func newTerminalOutput(limit int) *terminalOutput {
|
||||
if limit <= 0 {
|
||||
limit = 1024 * 1024 // 1MB default
|
||||
}
|
||||
return &terminalOutput{limit: limit}
|
||||
}
|
||||
|
||||
func (o *terminalOutput) Write(p []byte) (int, error) {
|
||||
o.mu.Lock()
|
||||
defer o.mu.Unlock()
|
||||
n, err := o.buf.Write(p)
|
||||
if o.buf.Len() > o.limit {
|
||||
excess := o.buf.Len() - o.limit
|
||||
o.buf.Next(excess)
|
||||
o.truncated = true
|
||||
}
|
||||
return n, err
|
||||
}
|
||||
|
||||
func (o *terminalOutput) snapshot() (string, bool) {
|
||||
o.mu.Lock()
|
||||
defer o.mu.Unlock()
|
||||
return o.buf.String(), o.truncated
|
||||
}
|
||||
|
||||
// TerminalManager manages ACP terminal instances.
|
||||
type TerminalManager struct {
|
||||
logger *zap.Logger
|
||||
nextID atomic.Int64
|
||||
|
||||
mu sync.RWMutex
|
||||
terminals map[string]*terminal
|
||||
}
|
||||
|
||||
// NewTerminalManager creates a new terminal manager.
|
||||
func NewTerminalManager(logger *zap.Logger) *TerminalManager {
|
||||
return &TerminalManager{
|
||||
logger: logger,
|
||||
terminals: make(map[string]*terminal),
|
||||
}
|
||||
}
|
||||
|
||||
// Create starts a command in a new terminal and returns its ID.
|
||||
func (m *TerminalManager) Create(command string, args []string, cwd string, env map[string]string, outputByteLimit int) (string, error) {
|
||||
id := fmt.Sprintf("t-%d", m.nextID.Add(1))
|
||||
|
||||
cmd := exec.Command(command, args...)
|
||||
if cwd != "" {
|
||||
cmd.Dir = cwd
|
||||
}
|
||||
if len(env) > 0 {
|
||||
cmd.Env = os.Environ()
|
||||
for k, v := range env {
|
||||
cmd.Env = append(cmd.Env, k+"="+v)
|
||||
}
|
||||
}
|
||||
|
||||
out := newTerminalOutput(outputByteLimit)
|
||||
cmd.Stdout = out
|
||||
cmd.Stderr = out
|
||||
|
||||
if err := cmd.Start(); err != nil {
|
||||
return "", fmt.Errorf("start command %q: %w", command, err)
|
||||
}
|
||||
|
||||
t := &terminal{
|
||||
cmd: cmd,
|
||||
output: out,
|
||||
doneCh: make(chan struct{}),
|
||||
}
|
||||
|
||||
// Wait for exit in background and close doneCh.
|
||||
go func() {
|
||||
_ = cmd.Wait()
|
||||
close(t.doneCh)
|
||||
}()
|
||||
|
||||
m.mu.Lock()
|
||||
m.terminals[id] = t
|
||||
m.mu.Unlock()
|
||||
|
||||
m.logger.Debug("terminal created",
|
||||
zap.String("terminal_id", id),
|
||||
zap.String("command", command),
|
||||
zap.Strings("args", args),
|
||||
)
|
||||
return id, nil
|
||||
}
|
||||
|
||||
// Output returns the current output of a terminal.
|
||||
func (m *TerminalManager) Output(id string) (output string, truncated bool, exitCode *int, signal *string, err error) {
|
||||
m.mu.RLock()
|
||||
t, ok := m.terminals[id]
|
||||
m.mu.RUnlock()
|
||||
if !ok {
|
||||
return "", false, nil, nil, fmt.Errorf("terminal %q not found", id)
|
||||
}
|
||||
|
||||
output, truncated = t.output.snapshot()
|
||||
|
||||
// Check if process has exited.
|
||||
select {
|
||||
case <-t.doneCh:
|
||||
code, sig := exitStatus(t.cmd)
|
||||
return output, truncated, code, sig, nil
|
||||
default:
|
||||
return output, truncated, nil, nil, nil
|
||||
}
|
||||
}
|
||||
|
||||
// WaitForExit blocks until the terminal's command exits.
|
||||
func (m *TerminalManager) WaitForExit(id string) (exitCode *int, signal *string, err error) {
|
||||
m.mu.RLock()
|
||||
t, ok := m.terminals[id]
|
||||
m.mu.RUnlock()
|
||||
if !ok {
|
||||
return nil, nil, fmt.Errorf("terminal %q not found", id)
|
||||
}
|
||||
|
||||
<-t.doneCh
|
||||
code, sig := exitStatus(t.cmd)
|
||||
return code, sig, nil
|
||||
}
|
||||
|
||||
// Kill sends SIGTERM to the terminal's process without releasing resources.
|
||||
func (m *TerminalManager) Kill(id string) error {
|
||||
m.mu.RLock()
|
||||
t, ok := m.terminals[id]
|
||||
m.mu.RUnlock()
|
||||
if !ok {
|
||||
return fmt.Errorf("terminal %q not found", id)
|
||||
}
|
||||
|
||||
t.mu.Lock()
|
||||
defer t.mu.Unlock()
|
||||
if t.killed {
|
||||
return nil
|
||||
}
|
||||
t.killed = true
|
||||
|
||||
if t.cmd.Process != nil {
|
||||
_ = t.cmd.Process.Signal(syscall.SIGTERM)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Release kills the terminal (if still running) and removes it.
|
||||
func (m *TerminalManager) Release(id string) error {
|
||||
m.mu.Lock()
|
||||
t, ok := m.terminals[id]
|
||||
if ok {
|
||||
delete(m.terminals, id)
|
||||
}
|
||||
m.mu.Unlock()
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
|
||||
t.mu.Lock()
|
||||
if !t.killed && t.cmd.Process != nil {
|
||||
_ = t.cmd.Process.Signal(syscall.SIGKILL)
|
||||
}
|
||||
t.mu.Unlock()
|
||||
|
||||
m.logger.Debug("terminal released", zap.String("terminal_id", id))
|
||||
return nil
|
||||
}
|
||||
|
||||
// ReleaseAll kills and removes all terminals.
|
||||
func (m *TerminalManager) ReleaseAll() {
|
||||
m.mu.Lock()
|
||||
terminals := m.terminals
|
||||
m.terminals = make(map[string]*terminal)
|
||||
m.mu.Unlock()
|
||||
|
||||
for id, t := range terminals {
|
||||
if t.cmd.Process != nil {
|
||||
_ = t.cmd.Process.Signal(syscall.SIGKILL)
|
||||
}
|
||||
m.logger.Debug("terminal released (shutdown)", zap.String("terminal_id", id))
|
||||
}
|
||||
}
|
||||
|
||||
// exitStatus extracts exit code and signal from a completed command.
|
||||
func exitStatus(cmd *exec.Cmd) (*int, *string) {
|
||||
state := cmd.ProcessState
|
||||
if state == nil {
|
||||
return nil, nil
|
||||
}
|
||||
ws, ok := state.Sys().(syscall.WaitStatus)
|
||||
if !ok {
|
||||
code := state.ExitCode()
|
||||
return &code, nil
|
||||
}
|
||||
if ws.Signaled() {
|
||||
sig := ws.Signal().String()
|
||||
return nil, &sig
|
||||
}
|
||||
code := ws.ExitStatus()
|
||||
return &code, nil
|
||||
}
|
||||
@@ -88,6 +88,31 @@ type StderrProviderSetter interface {
|
||||
SetStderrProvider(provider StderrProvider)
|
||||
}
|
||||
|
||||
// ModeSettableAdapter is an optional interface implemented by adapters that
|
||||
// support changing the session mode (e.g., ACP adapters with session/set_mode).
|
||||
type ModeSettableAdapter interface {
|
||||
SetMode(ctx context.Context, modeID string) error
|
||||
}
|
||||
|
||||
// ModelSettableAdapter is an optional interface implemented by adapters that
|
||||
// support changing the session model (e.g., ACP adapters with session/set_model).
|
||||
type ModelSettableAdapter interface {
|
||||
SetModel(ctx context.Context, modelID string) error
|
||||
}
|
||||
|
||||
// AuthenticatableAdapter is an optional interface implemented by adapters that
|
||||
// support ACP authentication (session/authenticate).
|
||||
type AuthenticatableAdapter interface {
|
||||
Authenticate(ctx context.Context, methodID string) error
|
||||
}
|
||||
|
||||
// SessionResettableAdapter is an optional interface implemented by adapters that
|
||||
// can reset context by creating a new session on the same connection, without
|
||||
// restarting the agent subprocess. Only ACP adapters support this.
|
||||
type SessionResettableAdapter interface {
|
||||
ResetSession(ctx context.Context, mcpServers []types.McpServer) (string, error)
|
||||
}
|
||||
|
||||
// AgentInfo contains information about the connected agent.
|
||||
type AgentInfo struct {
|
||||
Name string `json:"name"`
|
||||
|
||||
@@ -92,6 +92,9 @@ type AmpAdapter struct {
|
||||
// Set in handleMessage before dispatch; used by sendUpdate for OTel tracing.
|
||||
lastRawData json.RawMessage
|
||||
|
||||
// Attachment management
|
||||
attachMgr *shared.AttachmentManager
|
||||
|
||||
// Synchronization
|
||||
mu sync.RWMutex
|
||||
closed bool
|
||||
@@ -104,9 +107,10 @@ const defaultAmpContextWindow = 200000
|
||||
func NewAmpAdapter(cfg *Config, log *logger.Logger) *AmpAdapter {
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
|
||||
l := log.WithFields(zap.String("adapter", "amp"))
|
||||
return &AmpAdapter{
|
||||
cfg: cfg,
|
||||
logger: log.WithFields(zap.String("adapter", "amp")),
|
||||
logger: l,
|
||||
normalizer: NewAmpNormalizer(),
|
||||
oneShotCfg: cfg.OneShotConfig,
|
||||
ctx: ctx,
|
||||
@@ -115,6 +119,7 @@ func NewAmpAdapter(cfg *Config, log *logger.Logger) *AmpAdapter {
|
||||
mainModelContextWindow: defaultAmpContextWindow,
|
||||
pendingToolCalls: make(map[string]bool),
|
||||
pendingToolPayloads: make(map[string]*streams.NormalizedPayload),
|
||||
attachMgr: shared.NewAttachmentManager(cfg.WorkDir, l.Zap()),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -193,6 +198,7 @@ func (a *AmpAdapter) NewSession(ctx context.Context, _ []types.McpServer) (strin
|
||||
// Generate a placeholder session ID - Amp will return its thread ID
|
||||
sessionID := uuid.New().String()
|
||||
a.sessionID = sessionID
|
||||
a.attachMgr.SetSessionID(sessionID)
|
||||
|
||||
a.logger.Info("created new session placeholder", zap.String("session_id", sessionID))
|
||||
|
||||
@@ -206,6 +212,7 @@ func (a *AmpAdapter) LoadSession(ctx context.Context, sessionID string) error {
|
||||
a.sessionID = sessionID
|
||||
a.hasAmpThreadID = sessionID != "" // LoadSession always receives a real Amp thread ID
|
||||
a.mu.Unlock()
|
||||
a.attachMgr.SetSessionID(sessionID)
|
||||
|
||||
// Set thread ID in client for tracking (only for non-one-shot)
|
||||
if a.client != nil {
|
||||
@@ -220,11 +227,26 @@ func (a *AmpAdapter) LoadSession(ctx context.Context, sessionID string) error {
|
||||
// Prompt sends a prompt to Amp and waits for completion.
|
||||
// In one-shot mode, this spawns a new subprocess per prompt.
|
||||
// Note: attachments are not yet supported in Amp protocol - they are ignored.
|
||||
func (a *AmpAdapter) Prompt(ctx context.Context, message string, _ []v1.MessageAttachment) error {
|
||||
if a.oneShotCfg != nil {
|
||||
return a.promptOneShot(ctx, message)
|
||||
func (a *AmpAdapter) Prompt(ctx context.Context, message string, attachments []v1.MessageAttachment) error {
|
||||
// Save attachments to workspace and prepend references to message
|
||||
finalMessage := message
|
||||
if len(attachments) > 0 {
|
||||
saved, err := a.attachMgr.SaveAttachments(attachments)
|
||||
if err != nil {
|
||||
a.logger.Warn("failed to save attachments", zap.Error(err))
|
||||
} else if len(saved) > 0 {
|
||||
finalMessage = shared.BuildAttachmentPrompt(saved) + message
|
||||
}
|
||||
}
|
||||
return a.promptLongLived(ctx, message)
|
||||
|
||||
if a.oneShotCfg != nil {
|
||||
err := a.promptOneShot(ctx, finalMessage)
|
||||
a.attachMgr.Cleanup()
|
||||
return err
|
||||
}
|
||||
err := a.promptLongLived(ctx, finalMessage)
|
||||
a.attachMgr.Cleanup()
|
||||
return err
|
||||
}
|
||||
|
||||
// oneShotProcess holds the state of a one-shot subprocess spawned for a single prompt.
|
||||
@@ -495,6 +517,9 @@ func (a *AmpAdapter) Close() error {
|
||||
|
||||
a.logger.Info("closing Amp adapter")
|
||||
|
||||
// Clean up any saved attachments
|
||||
a.attachMgr.Cleanup()
|
||||
|
||||
// Cancel the context
|
||||
if a.cancel != nil {
|
||||
a.cancel()
|
||||
|
||||
@@ -82,6 +82,9 @@ type CopilotAdapter struct {
|
||||
// Set in handleEvent before dispatch; used by sendUpdate for OTel tracing.
|
||||
lastRawData json.RawMessage
|
||||
|
||||
// Attachment management
|
||||
attachMgr *shared.AttachmentManager
|
||||
|
||||
// Synchronization
|
||||
mu sync.RWMutex
|
||||
closed bool
|
||||
@@ -103,15 +106,17 @@ const mcpServerTypeHTTP = "http"
|
||||
func NewCopilotAdapter(cfg *Config, log *logger.Logger) *CopilotAdapter {
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
|
||||
l := log.WithFields(zap.String("adapter", "copilot"))
|
||||
return &CopilotAdapter{
|
||||
cfg: cfg,
|
||||
logger: log.WithFields(zap.String("adapter", "copilot")),
|
||||
logger: l,
|
||||
normalizer: NewCopilotNormalizer(),
|
||||
ctx: ctx,
|
||||
cancel: cancel,
|
||||
updatesCh: make(chan AgentEvent, 100),
|
||||
contextWindowSize: defaultCopilotContextWindow,
|
||||
pendingToolPayloads: make(map[string]*streams.NormalizedPayload),
|
||||
attachMgr: shared.NewAttachmentManager(cfg.WorkDir, l.Zap()),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -316,6 +321,7 @@ func (a *CopilotAdapter) NewSession(ctx context.Context, mcpServers []types.McpS
|
||||
a.mu.Lock()
|
||||
a.sessionID = sessionID
|
||||
a.mu.Unlock()
|
||||
a.attachMgr.SetSessionID(sessionID)
|
||||
|
||||
a.logger.Info("created new session", zap.String("session_id", sessionID))
|
||||
|
||||
@@ -348,6 +354,7 @@ func (a *CopilotAdapter) LoadSession(ctx context.Context, sessionID string) erro
|
||||
a.mu.Lock()
|
||||
a.sessionID = sessionID
|
||||
a.mu.Unlock()
|
||||
a.attachMgr.SetSessionID(sessionID)
|
||||
|
||||
a.logger.Info("loaded session", zap.String("session_id", sessionID))
|
||||
|
||||
@@ -366,8 +373,7 @@ func (a *CopilotAdapter) LoadSession(ctx context.Context, sessionID string) erro
|
||||
}
|
||||
|
||||
// Prompt sends a prompt to Copilot and waits for completion.
|
||||
// Note: attachments are not yet supported in Copilot protocol - they are ignored.
|
||||
func (a *CopilotAdapter) Prompt(ctx context.Context, message string, _ []v1.MessageAttachment) error {
|
||||
func (a *CopilotAdapter) Prompt(ctx context.Context, message string, attachments []v1.MessageAttachment) error {
|
||||
if a.client == nil {
|
||||
return fmt.Errorf("adapter not initialized")
|
||||
}
|
||||
@@ -381,12 +387,23 @@ func (a *CopilotAdapter) Prompt(ctx context.Context, message string, _ []v1.Mess
|
||||
a.receivedDeltas = false // Reset delta tracking for new operation
|
||||
a.mu.Unlock()
|
||||
|
||||
// Save attachments to workspace and prepend references to message
|
||||
finalMessage := message
|
||||
if len(attachments) > 0 {
|
||||
saved, err := a.attachMgr.SaveAttachments(attachments)
|
||||
if err != nil {
|
||||
a.logger.Warn("failed to save attachments", zap.Error(err))
|
||||
} else if len(saved) > 0 {
|
||||
finalMessage = shared.BuildAttachmentPrompt(saved) + message
|
||||
}
|
||||
}
|
||||
|
||||
a.logger.Info("sending prompt via SDK",
|
||||
zap.String("session_id", sessionID),
|
||||
zap.String("operation_id", operationID))
|
||||
|
||||
// Send message (non-blocking, events come via handler)
|
||||
if _, err := a.client.Send(ctx, message); err != nil {
|
||||
if _, err := a.client.Send(ctx, finalMessage); err != nil {
|
||||
a.mu.Lock()
|
||||
a.resultCh = nil
|
||||
a.mu.Unlock()
|
||||
@@ -414,6 +431,7 @@ func (a *CopilotAdapter) Prompt(ctx context.Context, message string, _ []v1.Mess
|
||||
a.logger.Info("prompt completed",
|
||||
zap.String("operation_id", operationID),
|
||||
zap.Bool("success", result.success))
|
||||
a.attachMgr.Cleanup()
|
||||
return nil
|
||||
}
|
||||
}
|
||||
@@ -466,6 +484,9 @@ func (a *CopilotAdapter) Close() error {
|
||||
|
||||
a.logger.Info("closing Copilot SDK adapter")
|
||||
|
||||
// Clean up any saved attachments
|
||||
a.attachMgr.Cleanup()
|
||||
|
||||
// Cancel the context
|
||||
if a.cancel != nil {
|
||||
a.cancel()
|
||||
|
||||
@@ -3,8 +3,13 @@
|
||||
package e2e
|
||||
|
||||
import (
|
||||
"context"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/kandev/kandev/internal/agentctl/server/adapter"
|
||||
"github.com/kandev/kandev/internal/agentctl/server/process"
|
||||
"github.com/kandev/kandev/pkg/agent"
|
||||
)
|
||||
|
||||
@@ -16,7 +21,7 @@ func TestMockAgent_BasicPrompt(t *testing.T) {
|
||||
result := RunAgent(t, AgentSpec{
|
||||
Name: "mock-agent",
|
||||
Command: binary + " --model mock-fast",
|
||||
Protocol: agent.ProtocolClaudeCode,
|
||||
Protocol: agent.ProtocolACP,
|
||||
DefaultPrompt: "hello",
|
||||
AutoApprove: true,
|
||||
})
|
||||
@@ -27,3 +32,420 @@ func TestMockAgent_BasicPrompt(t *testing.T) {
|
||||
|
||||
t.Logf("mock agent completed in %s with %d events", result.Duration, len(result.Events))
|
||||
}
|
||||
|
||||
// TestMockAgent_SimpleMessage tests the deterministic /e2e:simple-message scenario.
|
||||
// Validates: thinking event + text message event + complete event.
|
||||
func TestMockAgent_SimpleMessage(t *testing.T) {
|
||||
binary := buildMockAgent(t)
|
||||
|
||||
result := RunAgent(t, AgentSpec{
|
||||
Name: "mock-agent",
|
||||
Command: binary + " --model mock-fast",
|
||||
Protocol: agent.ProtocolACP,
|
||||
DefaultPrompt: "/e2e:simple-message",
|
||||
AutoApprove: true,
|
||||
})
|
||||
defer DumpEventsOnFailure(t, result)
|
||||
|
||||
AssertTurnCompleted(t, result)
|
||||
AssertNoErrors(t, result.Events)
|
||||
AssertHasEventType(t, result.Events, adapter.EventTypeReasoning)
|
||||
AssertHasEventType(t, result.Events, adapter.EventTypeMessageChunk)
|
||||
|
||||
// Verify specific content
|
||||
hasThinkingContent := false
|
||||
hasTextContent := false
|
||||
for _, ev := range result.Events {
|
||||
if ev.Type == adapter.EventTypeReasoning && ev.ReasoningText == "Processing the request..." {
|
||||
hasThinkingContent = true
|
||||
}
|
||||
if ev.Type == adapter.EventTypeMessageChunk && ev.Text == "This is a simple mock response for e2e testing." {
|
||||
hasTextContent = true
|
||||
}
|
||||
}
|
||||
if !hasThinkingContent {
|
||||
t.Error("expected thinking event with 'Processing the request...'")
|
||||
}
|
||||
if !hasTextContent {
|
||||
t.Error("expected text event with 'This is a simple mock response for e2e testing.'")
|
||||
}
|
||||
}
|
||||
|
||||
// TestMockAgent_ToolCallEvents tests tool call start + complete flow via /e2e:read-and-edit.
|
||||
// Validates: tool_call and tool_update events are emitted with correct types.
|
||||
func TestMockAgent_ToolCallEvents(t *testing.T) {
|
||||
binary := buildMockAgent(t)
|
||||
|
||||
result := RunAgent(t, AgentSpec{
|
||||
Name: "mock-agent",
|
||||
Command: binary + " --model mock-fast",
|
||||
Protocol: agent.ProtocolACP,
|
||||
DefaultPrompt: "/e2e:read-and-edit",
|
||||
AutoApprove: true,
|
||||
})
|
||||
defer DumpEventsOnFailure(t, result)
|
||||
|
||||
AssertTurnCompleted(t, result)
|
||||
AssertNoErrors(t, result.Events)
|
||||
AssertHasEventType(t, result.Events, adapter.EventTypeToolCall)
|
||||
AssertHasEventType(t, result.Events, adapter.EventTypeToolUpdate)
|
||||
|
||||
// Count tool calls and updates
|
||||
counts := CountEventsByType(result.Events)
|
||||
if counts[adapter.EventTypeToolCall] < 2 {
|
||||
t.Errorf("expected at least 2 tool_call events (read + edit), got %d", counts[adapter.EventTypeToolCall])
|
||||
}
|
||||
|
||||
t.Logf("event counts: %v", counts)
|
||||
}
|
||||
|
||||
// TestMockAgent_PermissionFlow tests auto-approved permission requests via /e2e:permission-flow.
|
||||
func TestMockAgent_PermissionFlow(t *testing.T) {
|
||||
binary := buildMockAgent(t)
|
||||
|
||||
result := RunAgent(t, AgentSpec{
|
||||
Name: "mock-agent",
|
||||
Command: binary + " --model mock-fast",
|
||||
Protocol: agent.ProtocolACP,
|
||||
DefaultPrompt: "/e2e:permission-flow",
|
||||
AutoApprove: true,
|
||||
})
|
||||
defer DumpEventsOnFailure(t, result)
|
||||
|
||||
AssertTurnCompleted(t, result)
|
||||
AssertNoErrors(t, result.Events)
|
||||
|
||||
// With auto-approve, the tool call should complete successfully
|
||||
AssertHasEventType(t, result.Events, adapter.EventTypeToolCall)
|
||||
|
||||
// Look for the "Permission was granted" text
|
||||
hasGrantedText := false
|
||||
for _, ev := range result.Events {
|
||||
if ev.Type == adapter.EventTypeMessageChunk && ev.Text == "Permission was granted and command executed." {
|
||||
hasGrantedText = true
|
||||
}
|
||||
}
|
||||
if !hasGrantedText {
|
||||
t.Error("expected 'Permission was granted and command executed.' message (auto-approve should grant)")
|
||||
}
|
||||
}
|
||||
|
||||
// TestMockAgent_AllTools tests one of every tool kind via /e2e:all-tools.
|
||||
// Validates: read, search, edit, execute, fetch tool kinds all appear.
|
||||
func TestMockAgent_AllTools(t *testing.T) {
|
||||
binary := buildMockAgent(t)
|
||||
|
||||
result := RunAgent(t, AgentSpec{
|
||||
Name: "mock-agent",
|
||||
Command: binary + " --model mock-fast",
|
||||
Protocol: agent.ProtocolACP,
|
||||
DefaultPrompt: "/e2e:all-tools",
|
||||
AutoApprove: true,
|
||||
})
|
||||
defer DumpEventsOnFailure(t, result)
|
||||
|
||||
AssertTurnCompleted(t, result)
|
||||
AssertNoErrors(t, result.Events)
|
||||
|
||||
// Check that multiple tool kinds are present
|
||||
toolNames := map[string]bool{}
|
||||
for _, ev := range result.Events {
|
||||
if ev.Type == adapter.EventTypeToolCall && ev.ToolName != "" {
|
||||
toolNames[ev.ToolName] = true
|
||||
}
|
||||
}
|
||||
|
||||
// ACP tool kinds map to ToolName in events
|
||||
expectedKinds := []string{"read", "search", "edit", "execute", "fetch"}
|
||||
for _, kind := range expectedKinds {
|
||||
if !toolNames[kind] {
|
||||
t.Errorf("expected tool kind %q in events, got tools: %v", kind, toolNames)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestMockAgent_MultiTurn sends two prompts to the same session.
|
||||
// Validates: the agent handles multiple prompts without errors and session ID stays consistent.
|
||||
func TestMockAgent_MultiTurn(t *testing.T) {
|
||||
binary := buildMockAgent(t)
|
||||
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
|
||||
defer cancel()
|
||||
|
||||
setup := setupAgentProcess(t, ctx, AgentSpec{
|
||||
Name: "mock-agent",
|
||||
Command: binary + " --model mock-fast",
|
||||
Protocol: agent.ProtocolACP,
|
||||
})
|
||||
|
||||
// First turn
|
||||
events1 := collectPromptEvents(ctx, t, setup, "/e2e:simple-message")
|
||||
assertEventsHaveType(t, events1, adapter.EventTypeComplete, "turn 1")
|
||||
assertEventsNoErrors(t, events1, "turn 1")
|
||||
|
||||
sessionID := setup.adpt.GetSessionID()
|
||||
if sessionID == "" {
|
||||
t.Fatal("session ID is empty after first turn")
|
||||
}
|
||||
|
||||
// Second turn — same session
|
||||
events2 := collectPromptEvents(ctx, t, setup, "/e2e:multi-turn")
|
||||
assertEventsHaveType(t, events2, adapter.EventTypeComplete, "turn 2")
|
||||
assertEventsNoErrors(t, events2, "turn 2")
|
||||
|
||||
// Session ID must remain the same
|
||||
if setup.adpt.GetSessionID() != sessionID {
|
||||
t.Errorf("session ID changed between turns: %s -> %s", sessionID, setup.adpt.GetSessionID())
|
||||
}
|
||||
|
||||
t.Logf("multi-turn: turn 1 had %d events, turn 2 had %d events", len(events1), len(events2))
|
||||
}
|
||||
|
||||
// TestMockAgent_SessionReset tests creating a new session on the same connection.
|
||||
// Validates: ResetSession works and produces a different session ID.
|
||||
func TestMockAgent_SessionReset(t *testing.T) {
|
||||
binary := buildMockAgent(t)
|
||||
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
|
||||
defer cancel()
|
||||
|
||||
setup := setupAgentProcess(t, ctx, AgentSpec{
|
||||
Name: "mock-agent",
|
||||
Command: binary + " --model mock-fast",
|
||||
Protocol: agent.ProtocolACP,
|
||||
})
|
||||
|
||||
// First turn
|
||||
events1 := collectPromptEvents(ctx, t, setup, "/e2e:simple-message")
|
||||
assertEventsHaveType(t, events1, adapter.EventTypeComplete, "turn 1")
|
||||
|
||||
firstSessionID := setup.adpt.GetSessionID()
|
||||
|
||||
// Reset session (creates new session on same connection)
|
||||
resettable, ok := setup.adpt.(adapter.SessionResettableAdapter)
|
||||
if !ok {
|
||||
t.Fatal("adapter does not implement SessionResettableAdapter")
|
||||
}
|
||||
|
||||
newSessionID, err := resettable.ResetSession(ctx, nil)
|
||||
if err != nil {
|
||||
t.Fatalf("ResetSession failed: %v", err)
|
||||
}
|
||||
|
||||
if newSessionID == "" {
|
||||
t.Fatal("new session ID is empty after reset")
|
||||
}
|
||||
|
||||
// Drain events from ResetSession (session_status etc.)
|
||||
drainEvents(ctx, setup, 200*time.Millisecond)
|
||||
|
||||
// Prompt on the new session
|
||||
events2 := collectPromptEvents(ctx, t, setup, "/e2e:simple-message")
|
||||
assertEventsHaveType(t, events2, adapter.EventTypeComplete, "post-reset turn")
|
||||
assertEventsNoErrors(t, events2, "post-reset turn")
|
||||
|
||||
t.Logf("session reset: %s -> %s", firstSessionID, newSessionID)
|
||||
}
|
||||
|
||||
// TestMockAgent_LoadSession tests resuming a session via LoadSession.
|
||||
// Validates: LoadSession succeeds and subsequent prompts work.
|
||||
func TestMockAgent_LoadSession(t *testing.T) {
|
||||
binary := buildMockAgent(t)
|
||||
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
|
||||
defer cancel()
|
||||
|
||||
setup := setupAgentProcess(t, ctx, AgentSpec{
|
||||
Name: "mock-agent",
|
||||
Command: binary + " --model mock-fast",
|
||||
Protocol: agent.ProtocolACP,
|
||||
})
|
||||
|
||||
// First turn to establish a session
|
||||
events1 := collectPromptEvents(ctx, t, setup, "/e2e:simple-message")
|
||||
assertEventsHaveType(t, events1, adapter.EventTypeComplete, "initial turn")
|
||||
|
||||
sessionID := setup.adpt.GetSessionID()
|
||||
if sessionID == "" {
|
||||
t.Fatal("session ID is empty")
|
||||
}
|
||||
|
||||
// Load the same session (simulates resume after process restart)
|
||||
if err := setup.adpt.LoadSession(ctx, sessionID); err != nil {
|
||||
t.Fatalf("LoadSession failed: %v", err)
|
||||
}
|
||||
|
||||
// Drain events from LoadSession (session_status etc.)
|
||||
drainEvents(ctx, setup, 200*time.Millisecond)
|
||||
|
||||
// Prompt on the loaded session
|
||||
events2 := collectPromptEvents(ctx, t, setup, "/e2e:simple-message")
|
||||
assertEventsHaveType(t, events2, adapter.EventTypeComplete, "post-load turn")
|
||||
assertEventsNoErrors(t, events2, "post-load turn")
|
||||
|
||||
// Session ID should match
|
||||
if setup.adpt.GetSessionID() != sessionID {
|
||||
t.Errorf("session ID changed after LoadSession: %s -> %s", sessionID, setup.adpt.GetSessionID())
|
||||
}
|
||||
|
||||
t.Logf("session load: resumed %s successfully", sessionID)
|
||||
}
|
||||
|
||||
// TestMockAgent_ThinkingEvents tests extended thinking/reasoning via /thinking.
|
||||
func TestMockAgent_ThinkingEvents(t *testing.T) {
|
||||
binary := buildMockAgent(t)
|
||||
|
||||
result := RunAgent(t, AgentSpec{
|
||||
Name: "mock-agent",
|
||||
Command: binary + " --model mock-fast",
|
||||
Protocol: agent.ProtocolACP,
|
||||
DefaultPrompt: "/thinking",
|
||||
AutoApprove: true,
|
||||
})
|
||||
defer DumpEventsOnFailure(t, result)
|
||||
|
||||
AssertTurnCompleted(t, result)
|
||||
AssertNoErrors(t, result.Events)
|
||||
|
||||
// Should have multiple reasoning events (the scenario emits 5 thoughts)
|
||||
reasoningCount := 0
|
||||
for _, ev := range result.Events {
|
||||
if ev.Type == adapter.EventTypeReasoning {
|
||||
reasoningCount++
|
||||
}
|
||||
}
|
||||
if reasoningCount < 3 {
|
||||
t.Errorf("expected at least 3 reasoning events, got %d", reasoningCount)
|
||||
}
|
||||
|
||||
t.Logf("thinking: %d reasoning events emitted", reasoningCount)
|
||||
}
|
||||
|
||||
// --- Multi-turn helpers ---
|
||||
|
||||
// agentSetup holds the state for multi-turn tests.
|
||||
type agentSetup struct {
|
||||
mgr managerInterface
|
||||
adpt adapter.AgentAdapter
|
||||
}
|
||||
|
||||
// managerInterface is the subset of process.Manager needed by helpers.
|
||||
type managerInterface interface {
|
||||
GetUpdates() <-chan adapter.AgentEvent
|
||||
}
|
||||
|
||||
// setupAgentProcess initializes an agent process for multi-turn testing.
|
||||
// Returns the setup with manager and adapter ready for prompting.
|
||||
func setupAgentProcess(t *testing.T, ctx context.Context, spec AgentSpec) *agentSetup {
|
||||
t.Helper()
|
||||
requireBinary(t, spec.Command)
|
||||
|
||||
workDir := setupWorkspace(t)
|
||||
cfg := buildInstanceConfig(spec.Command, spec.Protocol, workDir, spec.AutoApprove, spec.ContinueCommand)
|
||||
log := newTestLogger(t)
|
||||
|
||||
mgr := process.NewManager(cfg, log)
|
||||
if err := mgr.Start(ctx); err != nil {
|
||||
t.Fatalf("failed to start agent: %v", err)
|
||||
}
|
||||
t.Cleanup(func() {
|
||||
stopCtx, stopCancel := context.WithTimeout(context.Background(), 30*time.Second)
|
||||
defer stopCancel()
|
||||
_ = mgr.Stop(stopCtx)
|
||||
})
|
||||
|
||||
adpt := mgr.GetAdapter()
|
||||
if adpt == nil {
|
||||
t.Fatal("adapter is nil after Start")
|
||||
}
|
||||
if err := adpt.Initialize(ctx); err != nil {
|
||||
t.Fatalf("failed to initialize adapter: %v", err)
|
||||
}
|
||||
if _, err := adpt.NewSession(ctx, nil); err != nil {
|
||||
t.Fatalf("failed to create session: %v", err)
|
||||
}
|
||||
|
||||
return &agentSetup{mgr: mgr, adpt: adpt}
|
||||
}
|
||||
|
||||
// collectPromptEvents sends a prompt and collects all events until the turn completes.
|
||||
// It uses a dedicated context to stop the collector goroutine cleanly between calls.
|
||||
func collectPromptEvents(ctx context.Context, t *testing.T, setup *agentSetup, prompt string) []adapter.AgentEvent {
|
||||
t.Helper()
|
||||
|
||||
var events []adapter.AgentEvent
|
||||
var mu sync.Mutex
|
||||
collectCtx, collectCancel := context.WithCancel(ctx)
|
||||
|
||||
go func() {
|
||||
ch := setup.mgr.GetUpdates()
|
||||
for {
|
||||
select {
|
||||
case ev, ok := <-ch:
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
mu.Lock()
|
||||
events = append(events, ev)
|
||||
mu.Unlock()
|
||||
case <-collectCtx.Done():
|
||||
return
|
||||
}
|
||||
}
|
||||
}()
|
||||
|
||||
if err := setup.adpt.Prompt(ctx, prompt, nil); err != nil {
|
||||
collectCancel()
|
||||
t.Fatalf("prompt failed: %v", err)
|
||||
}
|
||||
|
||||
// Grace period for remaining events to propagate
|
||||
time.Sleep(500 * time.Millisecond)
|
||||
collectCancel() // Stop the collector goroutine
|
||||
|
||||
mu.Lock()
|
||||
defer mu.Unlock()
|
||||
result := make([]adapter.AgentEvent, len(events))
|
||||
copy(result, events)
|
||||
return result
|
||||
}
|
||||
|
||||
// drainEvents reads and discards events from the updates channel for the given duration.
|
||||
// Use between operations that emit events (e.g., ResetSession, LoadSession) to avoid
|
||||
// stale events being picked up by the next collectPromptEvents call.
|
||||
func drainEvents(ctx context.Context, setup *agentSetup, duration time.Duration) {
|
||||
timer := time.NewTimer(duration)
|
||||
defer timer.Stop()
|
||||
ch := setup.mgr.GetUpdates()
|
||||
for {
|
||||
select {
|
||||
case <-ch:
|
||||
// discard
|
||||
case <-timer.C:
|
||||
return
|
||||
case <-ctx.Done():
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// assertEventsHaveType checks that at least one event of the given type exists.
|
||||
func assertEventsHaveType(t *testing.T, events []adapter.AgentEvent, eventType, context string) {
|
||||
t.Helper()
|
||||
for _, ev := range events {
|
||||
if ev.Type == eventType {
|
||||
return
|
||||
}
|
||||
}
|
||||
t.Errorf("[%s] expected at least one %q event, got none (total: %d events)", context, eventType, len(events))
|
||||
}
|
||||
|
||||
// assertEventsNoErrors checks that no error events were received.
|
||||
func assertEventsNoErrors(t *testing.T, events []adapter.AgentEvent, context string) {
|
||||
t.Helper()
|
||||
for _, ev := range events {
|
||||
if ev.Type == adapter.EventTypeError {
|
||||
t.Errorf("[%s] unexpected error event: %s", context, ev.Error)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,10 +4,12 @@ package acp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"log/slog"
|
||||
"strings"
|
||||
"sync"
|
||||
|
||||
"github.com/coder/acp-go-sdk"
|
||||
@@ -31,6 +33,13 @@ type (
|
||||
PlanEntry = streams.PlanEntry
|
||||
)
|
||||
|
||||
// Content block type constants.
|
||||
const (
|
||||
contentTypeImage = "image"
|
||||
contentTypeAudio = "audio"
|
||||
contentTypeResource = "resource"
|
||||
)
|
||||
|
||||
// AgentInfo contains information about the connected agent.
|
||||
type AgentInfo struct {
|
||||
Name string `json:"name"`
|
||||
@@ -88,6 +97,9 @@ type Adapter struct {
|
||||
promptTraceCtx context.Context
|
||||
promptTraceMu sync.RWMutex
|
||||
|
||||
// Attachment management
|
||||
attachMgr *shared.AttachmentManager
|
||||
|
||||
// Synchronization
|
||||
mu sync.RWMutex
|
||||
closed bool
|
||||
@@ -97,13 +109,15 @@ type Adapter struct {
|
||||
// Call Connect() after starting the subprocess to wire up stdin/stdout.
|
||||
// cfg.AgentID is required for debug file naming.
|
||||
func NewAdapter(cfg *shared.Config, log *logger.Logger) *Adapter {
|
||||
l := log.WithFields(zap.String("adapter", "acp"), zap.String("agent_id", cfg.AgentID))
|
||||
return &Adapter{
|
||||
cfg: cfg,
|
||||
logger: log.WithFields(zap.String("adapter", "acp"), zap.String("agent_id", cfg.AgentID)),
|
||||
logger: l,
|
||||
agentID: cfg.AgentID,
|
||||
normalizer: NewNormalizer(),
|
||||
updatesCh: make(chan AgentEvent, 100),
|
||||
activeToolCalls: make(map[string]*streams.NormalizedPayload),
|
||||
attachMgr: shared.NewAttachmentManager(cfg.WorkDir, l.Zap()),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -189,6 +203,15 @@ func (a *Adapter) Initialize(ctx context.Context) error {
|
||||
zap.String("agent_version", a.agentInfo.Version),
|
||||
zap.Bool("supports_load_session", a.capabilities.LoadSession))
|
||||
|
||||
// Emit agent capabilities event with prompt capabilities and auth methods
|
||||
a.sendUpdate(AgentEvent{
|
||||
Type: streams.EventTypeAgentCapabilities,
|
||||
SupportsImage: a.capabilities.PromptCapabilities.Image,
|
||||
SupportsAudio: a.capabilities.PromptCapabilities.Audio,
|
||||
SupportsEmbeddedContext: a.capabilities.PromptCapabilities.EmbeddedContext,
|
||||
AuthMethods: convertAuthMethods(resp.AuthMethods),
|
||||
})
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -210,9 +233,10 @@ func (a *Adapter) NewSession(ctx context.Context, mcpServers []types.McpServer)
|
||||
ctx, span := shared.TraceProtocolRequest(ctx, shared.ProtocolACP, a.agentID, "session.new")
|
||||
defer span.End()
|
||||
|
||||
filteredServers := filterMcpServersByCapabilities(mcpServers, a.capabilities.McpCapabilities, a.logger)
|
||||
resp, err := conn.NewSession(ctx, acp.NewSessionRequest{
|
||||
Cwd: a.cfg.WorkDir,
|
||||
McpServers: toACPMcpServers(mcpServers),
|
||||
McpServers: toACPMcpServers(filteredServers),
|
||||
})
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
@@ -223,6 +247,7 @@ func (a *Adapter) NewSession(ctx context.Context, mcpServers []types.McpServer)
|
||||
a.sessionID = string(resp.SessionId)
|
||||
sessionID := a.sessionID
|
||||
a.mu.Unlock()
|
||||
a.attachMgr.SetSessionID(sessionID)
|
||||
|
||||
span.SetAttributes(attribute.String("session_id", sessionID))
|
||||
a.logger.Info("created new session", zap.String("session_id", sessionID))
|
||||
@@ -232,6 +257,11 @@ func (a *Adapter) NewSession(ctx context.Context, mcpServers []types.McpServer)
|
||||
a.emitInitialModeState(resp.Modes)
|
||||
}
|
||||
|
||||
// Emit session models if the agent returned model state
|
||||
if resp.Models != nil {
|
||||
a.emitSessionModels(sessionID, resp.Models, resp.Meta)
|
||||
}
|
||||
|
||||
// Emit session status event to normalize with other adapters.
|
||||
// This eliminates the need for ReportsStatusViaStream flag.
|
||||
a.sendUpdate(AgentEvent{
|
||||
@@ -247,6 +277,28 @@ func (a *Adapter) NewSession(ctx context.Context, mcpServers []types.McpServer)
|
||||
return sessionID, nil
|
||||
}
|
||||
|
||||
// filterMcpServersByCapabilities removes MCP servers that the agent doesn't support.
|
||||
// Stdio servers are always allowed; SSE/HTTP servers require the corresponding capability.
|
||||
func filterMcpServersByCapabilities(servers []types.McpServer, caps acp.McpCapabilities, logger *logger.Logger) []types.McpServer {
|
||||
filtered := make([]types.McpServer, 0, len(servers))
|
||||
for _, s := range servers {
|
||||
switch s.Type {
|
||||
case "sse":
|
||||
if !caps.Sse {
|
||||
logger.Warn("filtering out SSE MCP server (agent does not support SSE)", zap.String("name", s.Name))
|
||||
continue
|
||||
}
|
||||
case "http":
|
||||
if !caps.Http {
|
||||
logger.Warn("filtering out HTTP MCP server (agent does not support HTTP)", zap.String("name", s.Name))
|
||||
continue
|
||||
}
|
||||
}
|
||||
filtered = append(filtered, s)
|
||||
}
|
||||
return filtered
|
||||
}
|
||||
|
||||
func toACPMcpServers(servers []types.McpServer) []acp.McpServer {
|
||||
if len(servers) == 0 {
|
||||
return []acp.McpServer{}
|
||||
@@ -290,6 +342,8 @@ func (a *Adapter) LoadSession(ctx context.Context, sessionID string) error {
|
||||
|
||||
// Check if the agent supports session loading
|
||||
if !supportsLoad {
|
||||
a.logger.Debug("session/load rejected: agent does not advertise LoadSession capability",
|
||||
zap.String("session_id", sessionID))
|
||||
return fmt.Errorf("agent does not support session loading (LoadSession capability is false)")
|
||||
}
|
||||
|
||||
@@ -318,6 +372,7 @@ func (a *Adapter) LoadSession(ctx context.Context, sessionID string) error {
|
||||
a.mu.Lock()
|
||||
a.sessionID = sessionID
|
||||
a.mu.Unlock()
|
||||
a.attachMgr.SetSessionID(sessionID)
|
||||
|
||||
span.SetAttributes(attribute.String("session_id", sessionID))
|
||||
a.logger.Info("loaded session", zap.String("session_id", sessionID))
|
||||
@@ -327,6 +382,11 @@ func (a *Adapter) LoadSession(ctx context.Context, sessionID string) error {
|
||||
a.emitInitialModeState(resp.Modes)
|
||||
}
|
||||
|
||||
// Emit session models if the agent returned model state
|
||||
if resp.Models != nil {
|
||||
a.emitSessionModels(sessionID, resp.Models, resp.Meta)
|
||||
}
|
||||
|
||||
// Emit session status event to normalize with other adapters.
|
||||
// This eliminates the need for ReportsStatusViaStream flag.
|
||||
a.sendUpdate(AgentEvent{
|
||||
@@ -342,6 +402,13 @@ func (a *Adapter) LoadSession(ctx context.Context, sessionID string) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// ResetSession creates a new session on the existing connection, effectively resetting
|
||||
// the agent's conversation context without restarting the subprocess. This is much faster
|
||||
// than a full process restart since the ACP protocol supports multiple sessions per connection.
|
||||
func (a *Adapter) ResetSession(ctx context.Context, mcpServers []types.McpServer) (string, error) {
|
||||
return a.NewSession(ctx, mcpServers)
|
||||
}
|
||||
|
||||
// Prompt sends a prompt to the agent.
|
||||
// If pending context is set (from SetPendingContext), it will be prepended to the message.
|
||||
// Attachments (images) are converted to ACP ImageBlocks and included in the prompt.
|
||||
@@ -370,10 +437,27 @@ func (a *Adapter) Prompt(ctx context.Context, message string, attachments []v1.M
|
||||
// Build content blocks: text first, then images
|
||||
contentBlocks := []acp.ContentBlock{acp.TextBlock(finalMessage)}
|
||||
|
||||
// Add image attachments as ImageBlocks
|
||||
// Add media attachments as typed content blocks
|
||||
for _, att := range attachments {
|
||||
if att.Type == "image" {
|
||||
switch att.Type {
|
||||
case contentTypeImage:
|
||||
contentBlocks = append(contentBlocks, acp.ImageBlock(att.Data, att.MimeType))
|
||||
case contentTypeAudio:
|
||||
contentBlocks = append(contentBlocks, acp.AudioBlock(att.Data, att.MimeType))
|
||||
case contentTypeResource:
|
||||
if a.capabilities.PromptCapabilities.EmbeddedContext {
|
||||
contentBlocks = append(contentBlocks, buildResourceBlock(att))
|
||||
} else {
|
||||
// Agent doesn't support embedded resources — save to workspace and reference in text
|
||||
saved, saveErr := a.attachMgr.SaveAttachments([]v1.MessageAttachment{att})
|
||||
if saveErr != nil || len(saved) == 0 {
|
||||
a.logger.Warn("failed to save attachment to workspace, falling back to resource block",
|
||||
zap.String("name", att.Name), zap.Error(saveErr))
|
||||
contentBlocks = append(contentBlocks, buildResourceBlock(att))
|
||||
} else {
|
||||
contentBlocks = append(contentBlocks, acp.TextBlock(shared.BuildAttachmentPrompt(saved)))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -432,8 +516,12 @@ func (a *Adapter) Prompt(ctx context.Context, message string, attachments []v1.M
|
||||
Type: streams.EventTypeComplete,
|
||||
SessionID: sessionID,
|
||||
Data: map[string]any{"stop_reason": stopReason},
|
||||
Usage: extractPromptUsage(resp.Meta),
|
||||
})
|
||||
|
||||
// Clean up saved attachments — agent has finished reading them
|
||||
a.attachMgr.Cleanup()
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -551,6 +639,9 @@ func (a *Adapter) Close() error {
|
||||
|
||||
a.logger.Info("closing ACP adapter")
|
||||
|
||||
// Clean up any saved attachments
|
||||
a.attachMgr.Cleanup()
|
||||
|
||||
// Close update channel
|
||||
close(a.updatesCh)
|
||||
|
||||
@@ -752,11 +843,98 @@ func (a *Adapter) convertAvailableCommands(sessionID string, update *acp.Session
|
||||
// emitInitialModeState emits a session_mode event from the session response's Modes field.
|
||||
// Called after session/new and session/load to provide the initial mode state.
|
||||
func (a *Adapter) emitInitialModeState(modes *acp.SessionModeState) {
|
||||
availModes := make([]streams.SessionModeInfo, 0, len(modes.AvailableModes))
|
||||
for _, m := range modes.AvailableModes {
|
||||
availModes = append(availModes, streams.SessionModeInfo{
|
||||
ID: string(m.Id),
|
||||
Name: m.Name,
|
||||
Description: derefStr(m.Description),
|
||||
})
|
||||
}
|
||||
a.sendUpdate(AgentEvent{
|
||||
Type: streams.EventTypeSessionMode,
|
||||
SessionID: a.sessionID,
|
||||
CurrentModeID: string(modes.CurrentModeId),
|
||||
AvailableModes: availModes,
|
||||
})
|
||||
}
|
||||
|
||||
// emitSessionModels emits a session_models event from the session response.
|
||||
func (a *Adapter) emitSessionModels(sessionID string, models *acp.SessionModelState, meta any) {
|
||||
a.sendUpdate(AgentEvent{
|
||||
Type: streams.EventTypeSessionModels,
|
||||
SessionID: sessionID,
|
||||
CurrentModelID: string(models.CurrentModelId),
|
||||
SessionModels: convertSessionModels(models.AvailableModels),
|
||||
ConfigOptions: extractConfigOptions(meta),
|
||||
})
|
||||
}
|
||||
|
||||
// SetMode changes the agent's session mode via ACP session/set_mode.
|
||||
func (a *Adapter) SetMode(ctx context.Context, modeID string) error {
|
||||
a.mu.RLock()
|
||||
conn := a.acpConn
|
||||
sessionID := a.sessionID
|
||||
a.mu.RUnlock()
|
||||
|
||||
if conn == nil {
|
||||
return fmt.Errorf("adapter not initialized")
|
||||
}
|
||||
|
||||
_, err := conn.SetSessionMode(ctx, acp.SetSessionModeRequest{
|
||||
SessionId: acp.SessionId(sessionID),
|
||||
ModeId: acp.SessionModeId(modeID),
|
||||
})
|
||||
if err != nil {
|
||||
return fmt.Errorf("set session mode failed: %w", err)
|
||||
}
|
||||
|
||||
a.sendUpdate(AgentEvent{
|
||||
Type: streams.EventTypeSessionMode,
|
||||
SessionID: a.sessionID,
|
||||
CurrentModeID: string(modes.CurrentModeId),
|
||||
SessionID: sessionID,
|
||||
CurrentModeID: modeID,
|
||||
})
|
||||
return nil
|
||||
}
|
||||
|
||||
// SetModel changes the agent's model via ACP session/set_model (unstable SDK method).
|
||||
func (a *Adapter) SetModel(ctx context.Context, modelID string) error {
|
||||
a.mu.RLock()
|
||||
conn := a.acpConn
|
||||
sessionID := a.sessionID
|
||||
a.mu.RUnlock()
|
||||
|
||||
if conn == nil {
|
||||
return fmt.Errorf("adapter not initialized")
|
||||
}
|
||||
|
||||
_, err := conn.SetSessionModel(ctx, acp.SetSessionModelRequest{
|
||||
SessionId: acp.SessionId(sessionID),
|
||||
ModelId: acp.ModelId(modelID),
|
||||
})
|
||||
if err != nil {
|
||||
return fmt.Errorf("set session model failed: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Authenticate triggers ACP session/authenticate for a given auth method.
|
||||
func (a *Adapter) Authenticate(ctx context.Context, methodID string) error {
|
||||
a.mu.RLock()
|
||||
conn := a.acpConn
|
||||
a.mu.RUnlock()
|
||||
|
||||
if conn == nil {
|
||||
return fmt.Errorf("adapter not initialized")
|
||||
}
|
||||
|
||||
_, err := conn.Authenticate(ctx, acp.AuthenticateRequest{
|
||||
MethodId: acp.AuthMethodId(methodID),
|
||||
})
|
||||
if err != nil {
|
||||
return fmt.Errorf("authenticate failed: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// derefStr safely dereferences a string pointer, returning empty string if nil.
|
||||
@@ -767,6 +945,49 @@ func derefStr(s *string) string {
|
||||
return ""
|
||||
}
|
||||
|
||||
// buildResourceBlock constructs an ACP ResourceBlock from a MessageAttachment.
|
||||
// Text-based MIME types use TextResourceContents; everything else uses BlobResourceContents.
|
||||
func buildResourceBlock(att v1.MessageAttachment) acp.ContentBlock {
|
||||
uri := att.Name // Use filename as URI if no explicit URI
|
||||
if uri == "" {
|
||||
uri = "attachment"
|
||||
}
|
||||
if isTextMimeType(att.MimeType) {
|
||||
text := att.Data
|
||||
if decoded, err := base64.StdEncoding.DecodeString(att.Data); err == nil {
|
||||
text = string(decoded)
|
||||
}
|
||||
return acp.ResourceBlock(acp.EmbeddedResourceResource{
|
||||
TextResourceContents: &acp.TextResourceContents{
|
||||
Uri: uri,
|
||||
Text: text,
|
||||
MimeType: acp.Ptr(att.MimeType),
|
||||
},
|
||||
})
|
||||
}
|
||||
return acp.ResourceBlock(acp.EmbeddedResourceResource{
|
||||
BlobResourceContents: &acp.BlobResourceContents{
|
||||
Uri: uri,
|
||||
Blob: att.Data,
|
||||
MimeType: acp.Ptr(att.MimeType),
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
// isTextMimeType returns true for MIME types that represent text content.
|
||||
func isTextMimeType(mimeType string) bool {
|
||||
if strings.HasPrefix(mimeType, "text/") {
|
||||
return true
|
||||
}
|
||||
switch mimeType {
|
||||
case "application/json", "application/xml", "application/javascript",
|
||||
"application/typescript", "application/x-yaml", "application/toml",
|
||||
"application/x-sh", "application/sql":
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// convertToolCallContents converts ACP ToolCallContent items to our protocol-agnostic type.
|
||||
func (a *Adapter) convertToolCallContents(contents []acp.ToolCallContent) []streams.ToolCallContentItem {
|
||||
if len(contents) == 0 {
|
||||
@@ -809,9 +1030,9 @@ func (a *Adapter) convertContentBlockToStreams(cb acp.ContentBlock) *streams.Con
|
||||
case cb.Text != nil:
|
||||
return &streams.ContentBlock{Type: "text", Text: cb.Text.Text}
|
||||
case cb.Image != nil:
|
||||
return &streams.ContentBlock{Type: "image", Data: cb.Image.Data, MimeType: cb.Image.MimeType, URI: derefStr(cb.Image.Uri)}
|
||||
return &streams.ContentBlock{Type: contentTypeImage, Data: cb.Image.Data, MimeType: cb.Image.MimeType, URI: derefStr(cb.Image.Uri)}
|
||||
case cb.Audio != nil:
|
||||
return &streams.ContentBlock{Type: "audio", Data: cb.Audio.Data, MimeType: cb.Audio.MimeType}
|
||||
return &streams.ContentBlock{Type: contentTypeAudio, Data: cb.Audio.Data, MimeType: cb.Audio.MimeType}
|
||||
case cb.ResourceLink != nil:
|
||||
return &streams.ContentBlock{
|
||||
Type: "resource_link", URI: cb.ResourceLink.Uri, Name: cb.ResourceLink.Name,
|
||||
|
||||
@@ -0,0 +1,229 @@
|
||||
package acp
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/coder/acp-go-sdk"
|
||||
"github.com/kandev/kandev/internal/agentctl/types/streams"
|
||||
)
|
||||
|
||||
// convertAuthMethods converts ACP auth methods to stream types,
|
||||
// normalizing known _meta patterns (terminal-auth) while preserving raw _meta.
|
||||
func convertAuthMethods(methods []acp.AuthMethod) []streams.AuthMethodInfo {
|
||||
if len(methods) == 0 {
|
||||
return nil
|
||||
}
|
||||
result := make([]streams.AuthMethodInfo, 0, len(methods))
|
||||
for _, m := range methods {
|
||||
info := streams.AuthMethodInfo{
|
||||
ID: string(m.Id),
|
||||
Name: m.Name,
|
||||
Description: derefStr(m.Description),
|
||||
Meta: toStringMap(m.Meta),
|
||||
}
|
||||
// Normalize _meta.terminal-auth → TerminalAuth
|
||||
info.TerminalAuth = extractTerminalAuth(info.Meta)
|
||||
result = append(result, info)
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// extractTerminalAuth normalizes the terminal-auth pattern from _meta.
|
||||
// Example _meta: {"terminal-auth": {"command": "copilot", "args": ["auth", "login"], "label": "Login with GitHub"}}
|
||||
func extractTerminalAuth(meta map[string]any) *streams.TerminalAuth {
|
||||
if meta == nil {
|
||||
return nil
|
||||
}
|
||||
raw, ok := meta["terminal-auth"]
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
m, ok := raw.(map[string]any)
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
ta := &streams.TerminalAuth{}
|
||||
if cmd, ok := m["command"].(string); ok {
|
||||
ta.Command = cmd
|
||||
}
|
||||
if label, ok := m["label"].(string); ok {
|
||||
ta.Label = label
|
||||
}
|
||||
if args, ok := m["args"].([]any); ok {
|
||||
for _, a := range args {
|
||||
if s, ok := a.(string); ok {
|
||||
ta.Args = append(ta.Args, s)
|
||||
}
|
||||
}
|
||||
}
|
||||
if ta.Command == "" {
|
||||
return nil
|
||||
}
|
||||
return ta
|
||||
}
|
||||
|
||||
// convertSessionModels converts ACP model info to stream types,
|
||||
// normalizing known _meta patterns (copilotUsage) while preserving raw _meta.
|
||||
func convertSessionModels(models []acp.ModelInfo) []streams.SessionModelInfo {
|
||||
if len(models) == 0 {
|
||||
return nil
|
||||
}
|
||||
result := make([]streams.SessionModelInfo, 0, len(models))
|
||||
for _, m := range models {
|
||||
info := streams.SessionModelInfo{
|
||||
ModelID: string(m.ModelId),
|
||||
Name: m.Name,
|
||||
Description: derefStr(m.Description),
|
||||
Meta: toStringMap(m.Meta),
|
||||
}
|
||||
// Normalize _meta.copilotUsage → UsageMultiplier
|
||||
info.UsageMultiplier = extractUsageMultiplier(info.Meta)
|
||||
result = append(result, info)
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// extractUsageMultiplier normalizes the copilotUsage pattern from model _meta.
|
||||
// Example _meta: {"copilotUsage": "3x"} or {"copilotUsage": 3}
|
||||
func extractUsageMultiplier(meta map[string]any) string {
|
||||
if meta == nil {
|
||||
return ""
|
||||
}
|
||||
raw, ok := meta["copilotUsage"]
|
||||
if !ok {
|
||||
return ""
|
||||
}
|
||||
switch v := raw.(type) {
|
||||
case string:
|
||||
return v
|
||||
case float64:
|
||||
if v == float64(int64(v)) {
|
||||
return fmt.Sprintf("%dx", int64(v))
|
||||
}
|
||||
return fmt.Sprintf("%.2fx", v)
|
||||
default:
|
||||
return fmt.Sprintf("%v", v)
|
||||
}
|
||||
}
|
||||
|
||||
// extractConfigOptions extracts config options from ACP session _meta.
|
||||
// Example _meta: {"configOptions": [{"type": "select", "id": "mode", "name": "Mode", ...}]}
|
||||
func extractConfigOptions(meta any) []streams.ConfigOption {
|
||||
m, ok := toAnyMap(meta)
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
raw, ok := m["configOptions"]
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
items, ok := raw.([]any)
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
result := make([]streams.ConfigOption, 0, len(items))
|
||||
for _, item := range items {
|
||||
opt, ok := item.(map[string]any)
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
co := streams.ConfigOption{
|
||||
Type: getString(opt, "type"),
|
||||
ID: getString(opt, "id"),
|
||||
Name: getString(opt, "name"),
|
||||
CurrentValue: getString(opt, "currentValue"),
|
||||
Category: getString(opt, "category"),
|
||||
}
|
||||
if options, ok := opt["options"].([]any); ok {
|
||||
for _, o := range options {
|
||||
if om, ok := o.(map[string]any); ok {
|
||||
co.Options = append(co.Options, streams.ConfigOptionValue{
|
||||
Value: getString(om, "value"),
|
||||
Name: getString(om, "name"),
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
result = append(result, co)
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// extractPromptUsage extracts token usage from ACP prompt response _meta.
|
||||
// Example _meta: {"usage": {"input_tokens": 100, "output_tokens": 50, "total_tokens": 150}}
|
||||
func extractPromptUsage(meta any) *streams.PromptUsage {
|
||||
m, ok := toAnyMap(meta)
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
raw, ok := m["usage"]
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
u, ok := raw.(map[string]any)
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
usage := &streams.PromptUsage{
|
||||
InputTokens: getInt64(u, "input_tokens"),
|
||||
OutputTokens: getInt64(u, "output_tokens"),
|
||||
CachedReadTokens: getInt64(u, "cached_read_tokens"),
|
||||
CachedWriteTokens: getInt64(u, "cached_write_tokens"),
|
||||
TotalTokens: getInt64(u, "total_tokens"),
|
||||
}
|
||||
// Also check camelCase variants
|
||||
if usage.InputTokens == 0 {
|
||||
usage.InputTokens = getInt64(u, "inputTokens")
|
||||
}
|
||||
if usage.OutputTokens == 0 {
|
||||
usage.OutputTokens = getInt64(u, "outputTokens")
|
||||
}
|
||||
if usage.TotalTokens == 0 {
|
||||
usage.TotalTokens = getInt64(u, "totalTokens")
|
||||
}
|
||||
if usage.CachedReadTokens == 0 {
|
||||
usage.CachedReadTokens = getInt64(u, "cachedReadTokens")
|
||||
}
|
||||
if usage.CachedWriteTokens == 0 {
|
||||
usage.CachedWriteTokens = getInt64(u, "cachedWriteTokens")
|
||||
}
|
||||
if usage.InputTokens == 0 && usage.OutputTokens == 0 && usage.TotalTokens == 0 {
|
||||
return nil
|
||||
}
|
||||
return usage
|
||||
}
|
||||
|
||||
// toStringMap converts any to map[string]any, handling the common JSON unmarshal case.
|
||||
func toStringMap(v any) map[string]any {
|
||||
m, _ := toAnyMap(v)
|
||||
return m
|
||||
}
|
||||
|
||||
// toAnyMap converts any to map[string]any.
|
||||
func toAnyMap(v any) (map[string]any, bool) {
|
||||
if v == nil {
|
||||
return nil, false
|
||||
}
|
||||
m, ok := v.(map[string]any)
|
||||
return m, ok
|
||||
}
|
||||
|
||||
// getString safely extracts a string from a map.
|
||||
func getString(m map[string]any, key string) string {
|
||||
v, _ := m[key].(string)
|
||||
return v
|
||||
}
|
||||
|
||||
// getInt64 safely extracts an int64 from a map (JSON numbers are float64).
|
||||
func getInt64(m map[string]any, key string) int64 {
|
||||
switch v := m[key].(type) {
|
||||
case float64:
|
||||
return int64(v)
|
||||
case int64:
|
||||
return v
|
||||
case int:
|
||||
return int64(v)
|
||||
default:
|
||||
return 0
|
||||
}
|
||||
}
|
||||
@@ -102,6 +102,9 @@ type Adapter struct {
|
||||
promptTraceCtx context.Context
|
||||
promptTraceMu sync.RWMutex
|
||||
|
||||
// Attachment management
|
||||
attachMgr *shared.AttachmentManager
|
||||
|
||||
// Synchronization
|
||||
mu sync.RWMutex
|
||||
closed bool
|
||||
@@ -117,14 +120,16 @@ type turnCompleteResult struct {
|
||||
// Call Connect() after starting the subprocess to wire up stdin/stdout.
|
||||
func NewAdapter(cfg *shared.Config, log *logger.Logger) *Adapter {
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
l := log.WithFields(zap.String("adapter", "codex"), zap.String("agent_id", cfg.AgentID))
|
||||
return &Adapter{
|
||||
cfg: cfg,
|
||||
logger: log.WithFields(zap.String("adapter", "codex"), zap.String("agent_id", cfg.AgentID)),
|
||||
logger: l,
|
||||
agentID: cfg.AgentID,
|
||||
normalizer: NewNormalizer(),
|
||||
ctx: ctx,
|
||||
cancel: cancel,
|
||||
updatesCh: make(chan AgentEvent, 100),
|
||||
attachMgr: shared.NewAttachmentManager(cfg.WorkDir, l.Zap()),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -154,6 +159,9 @@ func (a *Adapter) Close() error {
|
||||
|
||||
a.logger.Info("closing Codex adapter")
|
||||
|
||||
// Clean up any saved attachments
|
||||
a.attachMgr.Cleanup()
|
||||
|
||||
// Cancel the context to stop the read loop goroutine
|
||||
if a.cancel != nil {
|
||||
a.cancel()
|
||||
|
||||
@@ -2,14 +2,10 @@ package codex
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"github.com/kandev/kandev/internal/agentctl/server/adapter/transport/shared"
|
||||
"github.com/kandev/kandev/internal/agentctl/types/streams"
|
||||
v1 "github.com/kandev/kandev/pkg/api/v1"
|
||||
@@ -74,12 +70,22 @@ func (a *Adapter) buildPromptInputs(message string, attachments []v1.MessageAtta
|
||||
}
|
||||
|
||||
if len(attachments) > 0 {
|
||||
imagePaths, err := a.saveImageAttachments(a.cfg.WorkDir, attachments)
|
||||
saved, err := a.attachMgr.SaveAttachments(attachments)
|
||||
if err != nil {
|
||||
a.logger.Warn("failed to save image attachments", zap.Error(err))
|
||||
a.logger.Warn("failed to save attachments", zap.Error(err))
|
||||
} else {
|
||||
for _, imagePath := range imagePaths {
|
||||
inputs = append(inputs, codex.UserInput{Type: "localImage", Path: imagePath})
|
||||
var nonImageSaved []shared.SavedAttachment
|
||||
for _, s := range saved {
|
||||
if s.Type == "image" {
|
||||
// Codex supports localImage input type with absolute path
|
||||
inputs = append(inputs, codex.UserInput{Type: "localImage", Path: s.AbsPath})
|
||||
} else {
|
||||
nonImageSaved = append(nonImageSaved, s)
|
||||
}
|
||||
}
|
||||
// Non-image files are referenced in prompt text
|
||||
if prompt := shared.BuildAttachmentPrompt(nonImageSaved); prompt != "" {
|
||||
inputs = append([]codex.UserInput{{Type: "text", Text: prompt}}, inputs...)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -153,6 +159,9 @@ func (a *Adapter) waitForTurnCompletion(ctx context.Context, threadID, turnID st
|
||||
}
|
||||
a.logger.Info("turn completed", zap.String("turn_id", turnID), zap.Bool("success", completeResult.success))
|
||||
|
||||
// Clean up saved attachments — agent has finished reading them
|
||||
a.attachMgr.Cleanup()
|
||||
|
||||
// Emit complete event via the stream.
|
||||
// This normalizes Codex behavior to match other adapters.
|
||||
// All adapters now emit complete events, eliminating the need for protocol-specific flags.
|
||||
@@ -166,58 +175,6 @@ func (a *Adapter) waitForTurnCompletion(ctx context.Context, threadID, turnID st
|
||||
}
|
||||
}
|
||||
|
||||
// saveImageAttachments saves image attachments to temp files in the workspace.
|
||||
func (a *Adapter) saveImageAttachments(workDir string, attachments []v1.MessageAttachment) ([]string, error) {
|
||||
var imagePaths []string
|
||||
|
||||
if workDir == "" {
|
||||
return nil, fmt.Errorf("workDir is required to save attachments")
|
||||
}
|
||||
|
||||
tempDir := filepath.Join(workDir, ".kandev", "temp", "images")
|
||||
if err := os.MkdirAll(tempDir, 0755); err != nil {
|
||||
return nil, fmt.Errorf("failed to create temp dir: %w", err)
|
||||
}
|
||||
|
||||
for _, att := range attachments {
|
||||
if att.Type != "image" {
|
||||
continue
|
||||
}
|
||||
|
||||
imageData, err := base64.StdEncoding.DecodeString(att.Data)
|
||||
if err != nil {
|
||||
a.logger.Warn("failed to decode image attachment", zap.Error(err))
|
||||
continue
|
||||
}
|
||||
|
||||
ext := ".png"
|
||||
switch att.MimeType {
|
||||
case "image/jpeg":
|
||||
ext = ".jpg"
|
||||
case "image/gif":
|
||||
ext = ".gif"
|
||||
case "image/webp":
|
||||
ext = ".webp"
|
||||
case "image/png":
|
||||
ext = ".png"
|
||||
}
|
||||
|
||||
filename := fmt.Sprintf("image-%s%s", uuid.New().String()[:8], ext)
|
||||
filePath := filepath.Join(tempDir, filename)
|
||||
if err := os.WriteFile(filePath, imageData, 0644); err != nil {
|
||||
a.logger.Warn("failed to write image file", zap.Error(err), zap.String("path", filePath))
|
||||
continue
|
||||
}
|
||||
|
||||
imagePaths = append(imagePaths, filePath)
|
||||
a.logger.Info("saved image attachment",
|
||||
zap.String("path", filePath),
|
||||
zap.Int("size", len(imageData)))
|
||||
}
|
||||
|
||||
return imagePaths, nil
|
||||
}
|
||||
|
||||
// Cancel interrupts the current turn.
|
||||
func (a *Adapter) Cancel(ctx context.Context) error {
|
||||
a.mu.RLock()
|
||||
|
||||
@@ -61,6 +61,7 @@ func (a *Adapter) NewSession(ctx context.Context, _ []types.McpServer) (string,
|
||||
a.mu.Lock()
|
||||
a.threadID = result.Thread.ID
|
||||
a.mu.Unlock()
|
||||
a.attachMgr.SetSessionID(result.Thread.ID)
|
||||
|
||||
a.logger.Info("created new thread", zap.String("thread_id", a.threadID))
|
||||
|
||||
@@ -113,6 +114,7 @@ func (a *Adapter) LoadSession(ctx context.Context, sessionID string) error {
|
||||
a.mu.Lock()
|
||||
a.threadID = sessionID
|
||||
a.mu.Unlock()
|
||||
a.attachMgr.SetSessionID(sessionID)
|
||||
|
||||
a.logger.Info("resumed thread", zap.String("thread_id", a.threadID))
|
||||
|
||||
|
||||
@@ -112,6 +112,9 @@ type Adapter struct {
|
||||
promptTraceCtx context.Context
|
||||
promptTraceMu sync.RWMutex
|
||||
|
||||
// Attachment management
|
||||
attachMgr *shared.AttachmentManager
|
||||
|
||||
// Synchronization
|
||||
mu sync.RWMutex
|
||||
closed bool
|
||||
@@ -150,9 +153,10 @@ func NewAdapter(cfg *shared.Config, log *logger.Logger) *Adapter {
|
||||
log.Info("parsed model from AGENT_MODEL", zap.String("model", modelStr))
|
||||
}
|
||||
|
||||
l := log.WithFields(zap.String("adapter", "opencode"), zap.String("agent_id", agentID))
|
||||
return &Adapter{
|
||||
cfg: cfg,
|
||||
logger: log.WithFields(zap.String("adapter", "opencode"), zap.String("agent_id", agentID)),
|
||||
logger: l,
|
||||
agentID: agentID,
|
||||
normalizer: NewNormalizer(),
|
||||
model: modelSpec,
|
||||
@@ -164,6 +168,7 @@ func NewAdapter(cfg *shared.Config, log *logger.Logger) *Adapter {
|
||||
password: opencode.GenerateServerPassword(),
|
||||
directory: cfg.WorkDir,
|
||||
modelContextWindow: 200000, // Default
|
||||
attachMgr: shared.NewAttachmentManager(cfg.WorkDir, l.Zap()),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -343,6 +348,7 @@ func (a *Adapter) NewSession(ctx context.Context, _ []types.McpServer) (string,
|
||||
a.mu.Lock()
|
||||
a.sessionID = sessionID
|
||||
a.mu.Unlock()
|
||||
a.attachMgr.SetSessionID(sessionID)
|
||||
|
||||
a.logger.Info("created new session", zap.String("session_id", sessionID))
|
||||
|
||||
@@ -374,6 +380,7 @@ func (a *Adapter) LoadSession(ctx context.Context, sessionID string) error {
|
||||
a.mu.Lock()
|
||||
a.sessionID = newSessionID
|
||||
a.mu.Unlock()
|
||||
a.attachMgr.SetSessionID(newSessionID)
|
||||
|
||||
a.logger.Info("loaded session (forked)",
|
||||
zap.String("original_session_id", sessionID),
|
||||
@@ -394,8 +401,7 @@ func (a *Adapter) LoadSession(ctx context.Context, sessionID string) error {
|
||||
}
|
||||
|
||||
// Prompt sends a prompt to OpenCode and waits for completion.
|
||||
// Note: attachments are not yet supported in OpenCode protocol - they are ignored.
|
||||
func (a *Adapter) Prompt(ctx context.Context, message string, _ []v1.MessageAttachment) error {
|
||||
func (a *Adapter) Prompt(ctx context.Context, message string, attachments []v1.MessageAttachment) error {
|
||||
a.mu.Lock()
|
||||
client := a.client
|
||||
sessionID := a.sessionID
|
||||
@@ -405,6 +411,17 @@ func (a *Adapter) Prompt(ctx context.Context, message string, _ []v1.MessageAtta
|
||||
a.resultCh = make(chan resultComplete, 1)
|
||||
a.mu.Unlock()
|
||||
|
||||
// Save attachments to workspace and prepend references to message
|
||||
finalMessage := message
|
||||
if len(attachments) > 0 {
|
||||
saved, err := a.attachMgr.SaveAttachments(attachments)
|
||||
if err != nil {
|
||||
a.logger.Warn("failed to save attachments", zap.Error(err))
|
||||
} else if len(saved) > 0 {
|
||||
finalMessage = shared.BuildAttachmentPrompt(saved) + message
|
||||
}
|
||||
}
|
||||
|
||||
if client == nil {
|
||||
return fmt.Errorf("adapter not initialized")
|
||||
}
|
||||
@@ -413,12 +430,13 @@ func (a *Adapter) Prompt(ctx context.Context, message string, _ []v1.MessageAtta
|
||||
promptCtx, promptSpan := shared.TraceProtocolRequest(ctx, shared.ProtocolOpenCode, a.agentID, "prompt")
|
||||
promptSpan.SetAttributes(
|
||||
attribute.String("session_id", sessionID),
|
||||
attribute.Int("prompt_length", len(message)),
|
||||
attribute.Int("prompt_length", len(finalMessage)),
|
||||
)
|
||||
a.setPromptTraceCtx(promptCtx)
|
||||
defer func() {
|
||||
a.clearPromptTraceCtx()
|
||||
promptSpan.End()
|
||||
a.attachMgr.Cleanup()
|
||||
}()
|
||||
|
||||
a.logger.Info("sending prompt",
|
||||
@@ -431,7 +449,7 @@ func (a *Adapter) Prompt(ctx context.Context, message string, _ []v1.MessageAtta
|
||||
}
|
||||
|
||||
// Send prompt with model selection (blocks until OpenCode finishes)
|
||||
if err := client.SendPrompt(ctx, sessionID, message, a.model, "", ""); err != nil {
|
||||
if err := client.SendPrompt(ctx, sessionID, finalMessage, a.model, "", ""); err != nil {
|
||||
a.mu.Lock()
|
||||
a.resultCh = nil
|
||||
a.mu.Unlock()
|
||||
@@ -441,19 +459,21 @@ func (a *Adapter) Prompt(ctx context.Context, message string, _ []v1.MessageAtta
|
||||
a.logger.Info("prompt HTTP request completed, waiting for SSE idle signal",
|
||||
zap.String("session_id", sessionID))
|
||||
|
||||
// Wait for result via control channel or context cancellation
|
||||
return a.waitForPromptCompletion(ctx, client, sessionID)
|
||||
}
|
||||
|
||||
// waitForPromptCompletion blocks until the prompt completes via the SSE control channel.
|
||||
func (a *Adapter) waitForPromptCompletion(ctx context.Context, client *opencode.Client, sessionID string) error {
|
||||
controlCh := client.ControlChannel()
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
// Request cancellation
|
||||
_ = a.Cancel(context.Background())
|
||||
return ctx.Err()
|
||||
|
||||
case control, ok := <-controlCh:
|
||||
if !ok {
|
||||
// Channel closed
|
||||
a.sendUpdate(AgentEvent{
|
||||
Type: streams.EventTypeComplete,
|
||||
SessionID: sessionID,
|
||||
@@ -552,6 +572,9 @@ func (a *Adapter) Close() error {
|
||||
}
|
||||
a.closed = true
|
||||
|
||||
// Clean up any saved attachments
|
||||
a.attachMgr.Cleanup()
|
||||
|
||||
a.logger.Debug("OpenCode adapter: cancelling context")
|
||||
a.cancel()
|
||||
|
||||
|
||||
@@ -0,0 +1,171 @@
|
||||
package shared
|
||||
|
||||
import (
|
||||
"encoding/base64"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
v1 "github.com/kandev/kandev/pkg/api/v1"
|
||||
"go.uber.org/zap"
|
||||
)
|
||||
|
||||
// SavedAttachment represents an attachment saved to the workspace.
|
||||
type SavedAttachment struct {
|
||||
// RelPath is the path relative to workDir (e.g. ".kandev/attachments/{sid}/file.pdf").
|
||||
RelPath string
|
||||
// AbsPath is the absolute path to the saved file.
|
||||
AbsPath string
|
||||
// Name is the original filename.
|
||||
Name string
|
||||
// MimeType is the MIME type of the attachment.
|
||||
MimeType string
|
||||
// Type is the attachment type ("image" or "resource").
|
||||
Type string
|
||||
}
|
||||
|
||||
// AttachmentManager saves attachments to session-scoped directories and cleans up.
|
||||
// Each session gets its own subdirectory under .kandev/attachments/{sessionID}/
|
||||
// so concurrent agents sharing a workspace don't interfere with each other.
|
||||
type AttachmentManager struct {
|
||||
workDir string
|
||||
sessionID string
|
||||
logger *zap.Logger
|
||||
}
|
||||
|
||||
// NewAttachmentManager creates a new AttachmentManager.
|
||||
// sessionID can be empty initially and set later via SetSessionID.
|
||||
func NewAttachmentManager(workDir string, logger *zap.Logger) *AttachmentManager {
|
||||
return &AttachmentManager{
|
||||
workDir: workDir,
|
||||
logger: logger,
|
||||
}
|
||||
}
|
||||
|
||||
// SetSessionID updates the session ID used for the scoped subdirectory.
|
||||
func (m *AttachmentManager) SetSessionID(id string) {
|
||||
m.sessionID = id
|
||||
}
|
||||
|
||||
// SaveAttachments saves all attachments to .kandev/attachments/{sessionID}/.
|
||||
// Returns saved attachment metadata so the caller can decide how to reference them.
|
||||
func (m *AttachmentManager) SaveAttachments(attachments []v1.MessageAttachment) ([]SavedAttachment, error) {
|
||||
if len(attachments) == 0 {
|
||||
return nil, nil
|
||||
}
|
||||
if m.workDir == "" || m.sessionID == "" {
|
||||
return nil, fmt.Errorf("workDir or sessionID not set")
|
||||
}
|
||||
|
||||
dir := filepath.Join(m.workDir, ".kandev", "attachments", m.sessionID)
|
||||
if err := os.MkdirAll(dir, 0o755); err != nil {
|
||||
return nil, fmt.Errorf("create attachments dir: %w", err)
|
||||
}
|
||||
|
||||
var saved []SavedAttachment
|
||||
for _, att := range attachments {
|
||||
name := att.Name
|
||||
if name == "" {
|
||||
name = m.generateName(att)
|
||||
}
|
||||
// Sanitize: strip directory components to prevent path traversal attacks.
|
||||
name = filepath.Base(name)
|
||||
if name == "." || name == ".." || name == string(filepath.Separator) {
|
||||
m.logger.Warn("skipping attachment with invalid name", zap.String("original_name", att.Name))
|
||||
continue
|
||||
}
|
||||
|
||||
decoded, err := base64.StdEncoding.DecodeString(att.Data)
|
||||
if err != nil {
|
||||
m.logger.Warn("failed to decode attachment", zap.String("name", name), zap.Error(err))
|
||||
continue
|
||||
}
|
||||
|
||||
absPath := filepath.Join(dir, name)
|
||||
if err := os.WriteFile(absPath, decoded, 0o644); err != nil {
|
||||
m.logger.Warn("failed to write attachment", zap.String("path", absPath), zap.Error(err))
|
||||
continue
|
||||
}
|
||||
|
||||
relPath := filepath.Join(".kandev", "attachments", m.sessionID, name)
|
||||
saved = append(saved, SavedAttachment{
|
||||
RelPath: relPath,
|
||||
AbsPath: absPath,
|
||||
Name: name,
|
||||
MimeType: att.MimeType,
|
||||
Type: att.Type,
|
||||
})
|
||||
|
||||
m.logger.Debug("saved attachment", zap.String("path", relPath), zap.Int("size", len(decoded)))
|
||||
}
|
||||
|
||||
return saved, nil
|
||||
}
|
||||
|
||||
// Cleanup removes the session's attachment directory.
|
||||
// Safe to call multiple times or with empty sessionID (no-op).
|
||||
func (m *AttachmentManager) Cleanup() {
|
||||
if m.sessionID == "" || m.workDir == "" {
|
||||
return
|
||||
}
|
||||
dir := filepath.Join(m.workDir, ".kandev", "attachments", m.sessionID)
|
||||
if err := os.RemoveAll(dir); err != nil {
|
||||
m.logger.Debug("failed to clean attachments dir", zap.String("dir", dir), zap.Error(err))
|
||||
}
|
||||
}
|
||||
|
||||
// BuildAttachmentPrompt generates prompt text referencing saved attachment files.
|
||||
// Used by adapters that don't support native multimodal content.
|
||||
func BuildAttachmentPrompt(saved []SavedAttachment) string {
|
||||
if len(saved) == 0 {
|
||||
return ""
|
||||
}
|
||||
|
||||
var sb strings.Builder
|
||||
if len(saved) == 1 {
|
||||
s := saved[0]
|
||||
fmt.Fprintf(&sb, "The user attached a file: %s (saved to %s in the workspace). Use your file reading tools to access it.\n\n", s.Name, s.RelPath)
|
||||
} else {
|
||||
sb.WriteString("The user attached files that you should read and analyze:\n")
|
||||
for _, s := range saved {
|
||||
fmt.Fprintf(&sb, "- %s (saved to %s)\n", s.Name, s.RelPath)
|
||||
}
|
||||
sb.WriteString("\nUse your file reading tools to access them.\n\n")
|
||||
}
|
||||
return sb.String()
|
||||
}
|
||||
|
||||
// generateName creates a filename for attachments that don't have a Name field.
|
||||
func (m *AttachmentManager) generateName(att v1.MessageAttachment) string {
|
||||
ext := extensionFromMimeType(att.MimeType)
|
||||
return "attachment" + ext
|
||||
}
|
||||
|
||||
// extensionFromMimeType returns a file extension for common MIME types.
|
||||
func extensionFromMimeType(mimeType string) string {
|
||||
switch mimeType {
|
||||
case "image/png":
|
||||
return ".png"
|
||||
case "image/jpeg":
|
||||
return ".jpg"
|
||||
case "image/gif":
|
||||
return ".gif"
|
||||
case "image/webp":
|
||||
return ".webp"
|
||||
case "application/pdf":
|
||||
return ".pdf"
|
||||
case "text/plain":
|
||||
return ".txt"
|
||||
case "application/json":
|
||||
return ".json"
|
||||
case "text/csv":
|
||||
return ".csv"
|
||||
case "text/html":
|
||||
return ".html"
|
||||
case "text/markdown":
|
||||
return ".md"
|
||||
default:
|
||||
return ""
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,381 @@
|
||||
package shared
|
||||
|
||||
import (
|
||||
"encoding/base64"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
|
||||
v1 "github.com/kandev/kandev/pkg/api/v1"
|
||||
"go.uber.org/zap"
|
||||
)
|
||||
|
||||
func testLogger() *zap.Logger {
|
||||
return zap.NewNop()
|
||||
}
|
||||
|
||||
func TestNewAttachmentManager(t *testing.T) {
|
||||
mgr := NewAttachmentManager("/tmp/work", testLogger())
|
||||
if mgr == nil {
|
||||
t.Fatal("expected non-nil manager")
|
||||
}
|
||||
if mgr.workDir != "/tmp/work" {
|
||||
t.Errorf("workDir = %q, want %q", mgr.workDir, "/tmp/work")
|
||||
}
|
||||
if mgr.sessionID != "" {
|
||||
t.Errorf("sessionID = %q, want empty", mgr.sessionID)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSetSessionID(t *testing.T) {
|
||||
mgr := NewAttachmentManager("/tmp/work", testLogger())
|
||||
mgr.SetSessionID("sess-123")
|
||||
if mgr.sessionID != "sess-123" {
|
||||
t.Errorf("sessionID = %q, want %q", mgr.sessionID, "sess-123")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaveAttachments_EmptyList(t *testing.T) {
|
||||
mgr := NewAttachmentManager("/tmp/work", testLogger())
|
||||
mgr.SetSessionID("sess-1")
|
||||
|
||||
saved, err := mgr.SaveAttachments(nil)
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if saved != nil {
|
||||
t.Errorf("expected nil, got %v", saved)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaveAttachments_MissingSessionID(t *testing.T) {
|
||||
mgr := NewAttachmentManager("/tmp/work", testLogger())
|
||||
|
||||
_, err := mgr.SaveAttachments([]v1.MessageAttachment{{Type: "image", Data: "abc"}})
|
||||
if err == nil {
|
||||
t.Fatal("expected error when sessionID is empty")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaveAttachments_MissingWorkDir(t *testing.T) {
|
||||
mgr := NewAttachmentManager("", testLogger())
|
||||
mgr.SetSessionID("sess-1")
|
||||
|
||||
_, err := mgr.SaveAttachments([]v1.MessageAttachment{{Type: "image", Data: "abc"}})
|
||||
if err == nil {
|
||||
t.Fatal("expected error when workDir is empty")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaveAttachments_ImageAttachment(t *testing.T) {
|
||||
workDir := t.TempDir()
|
||||
mgr := NewAttachmentManager(workDir, testLogger())
|
||||
mgr.SetSessionID("sess-img")
|
||||
|
||||
content := []byte{0x89, 0x50, 0x4E, 0x47} // PNG header bytes
|
||||
encoded := base64.StdEncoding.EncodeToString(content)
|
||||
|
||||
saved, err := mgr.SaveAttachments([]v1.MessageAttachment{
|
||||
{Type: "image", Data: encoded, MimeType: "image/png", Name: "screenshot.png"},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if len(saved) != 1 {
|
||||
t.Fatalf("expected 1 saved, got %d", len(saved))
|
||||
}
|
||||
|
||||
s := saved[0]
|
||||
if s.Name != "screenshot.png" {
|
||||
t.Errorf("Name = %q, want %q", s.Name, "screenshot.png")
|
||||
}
|
||||
if s.Type != "image" {
|
||||
t.Errorf("Type = %q, want %q", s.Type, "image")
|
||||
}
|
||||
if s.MimeType != "image/png" {
|
||||
t.Errorf("MimeType = %q, want %q", s.MimeType, "image/png")
|
||||
}
|
||||
expectedRel := filepath.Join(".kandev", "attachments", "sess-img", "screenshot.png")
|
||||
if s.RelPath != expectedRel {
|
||||
t.Errorf("RelPath = %q, want %q", s.RelPath, expectedRel)
|
||||
}
|
||||
|
||||
// Verify file was written
|
||||
data, err := os.ReadFile(s.AbsPath)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to read saved file: %v", err)
|
||||
}
|
||||
if len(data) != len(content) {
|
||||
t.Errorf("file size = %d, want %d", len(data), len(content))
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaveAttachments_ResourceAttachment(t *testing.T) {
|
||||
workDir := t.TempDir()
|
||||
mgr := NewAttachmentManager(workDir, testLogger())
|
||||
mgr.SetSessionID("sess-res")
|
||||
|
||||
content := []byte("Hello, PDF content")
|
||||
encoded := base64.StdEncoding.EncodeToString(content)
|
||||
|
||||
saved, err := mgr.SaveAttachments([]v1.MessageAttachment{
|
||||
{Type: "resource", Data: encoded, MimeType: "application/pdf", Name: "report.pdf"},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if len(saved) != 1 {
|
||||
t.Fatalf("expected 1 saved, got %d", len(saved))
|
||||
}
|
||||
|
||||
s := saved[0]
|
||||
if s.Name != "report.pdf" {
|
||||
t.Errorf("Name = %q, want %q", s.Name, "report.pdf")
|
||||
}
|
||||
if s.Type != "resource" {
|
||||
t.Errorf("Type = %q, want %q", s.Type, "resource")
|
||||
}
|
||||
|
||||
data, err := os.ReadFile(s.AbsPath)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to read saved file: %v", err)
|
||||
}
|
||||
if string(data) != string(content) {
|
||||
t.Errorf("file content = %q, want %q", string(data), string(content))
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaveAttachments_MultipleAttachments(t *testing.T) {
|
||||
workDir := t.TempDir()
|
||||
mgr := NewAttachmentManager(workDir, testLogger())
|
||||
mgr.SetSessionID("sess-multi")
|
||||
|
||||
img := base64.StdEncoding.EncodeToString([]byte("image-data"))
|
||||
pdf := base64.StdEncoding.EncodeToString([]byte("pdf-data"))
|
||||
|
||||
saved, err := mgr.SaveAttachments([]v1.MessageAttachment{
|
||||
{Type: "image", Data: img, MimeType: "image/jpeg", Name: "photo.jpg"},
|
||||
{Type: "resource", Data: pdf, MimeType: "application/pdf", Name: "doc.pdf"},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if len(saved) != 2 {
|
||||
t.Fatalf("expected 2 saved, got %d", len(saved))
|
||||
}
|
||||
|
||||
if saved[0].Name != "photo.jpg" {
|
||||
t.Errorf("first Name = %q, want %q", saved[0].Name, "photo.jpg")
|
||||
}
|
||||
if saved[1].Name != "doc.pdf" {
|
||||
t.Errorf("second Name = %q, want %q", saved[1].Name, "doc.pdf")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaveAttachments_NoName_GeneratesFromMime(t *testing.T) {
|
||||
workDir := t.TempDir()
|
||||
mgr := NewAttachmentManager(workDir, testLogger())
|
||||
mgr.SetSessionID("sess-noname")
|
||||
|
||||
encoded := base64.StdEncoding.EncodeToString([]byte("data"))
|
||||
|
||||
saved, err := mgr.SaveAttachments([]v1.MessageAttachment{
|
||||
{Type: "image", Data: encoded, MimeType: "image/jpeg"},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if len(saved) != 1 {
|
||||
t.Fatalf("expected 1 saved, got %d", len(saved))
|
||||
}
|
||||
if saved[0].Name != "attachment.jpg" {
|
||||
t.Errorf("Name = %q, want %q", saved[0].Name, "attachment.jpg")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaveAttachments_InvalidBase64_Skipped(t *testing.T) {
|
||||
workDir := t.TempDir()
|
||||
mgr := NewAttachmentManager(workDir, testLogger())
|
||||
mgr.SetSessionID("sess-invalid")
|
||||
|
||||
saved, err := mgr.SaveAttachments([]v1.MessageAttachment{
|
||||
{Type: "resource", Data: "not-valid-base64!!!", MimeType: "text/plain", Name: "bad.txt"},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if len(saved) != 0 {
|
||||
t.Errorf("expected 0 saved (invalid base64 skipped), got %d", len(saved))
|
||||
}
|
||||
}
|
||||
|
||||
func TestCleanup(t *testing.T) {
|
||||
workDir := t.TempDir()
|
||||
mgr := NewAttachmentManager(workDir, testLogger())
|
||||
mgr.SetSessionID("sess-cleanup")
|
||||
|
||||
// Save an attachment
|
||||
encoded := base64.StdEncoding.EncodeToString([]byte("cleanup-test"))
|
||||
saved, err := mgr.SaveAttachments([]v1.MessageAttachment{
|
||||
{Type: "resource", Data: encoded, MimeType: "text/plain", Name: "temp.txt"},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
|
||||
// Verify file exists
|
||||
if _, err := os.Stat(saved[0].AbsPath); err != nil {
|
||||
t.Fatalf("file should exist before cleanup: %v", err)
|
||||
}
|
||||
|
||||
// Cleanup
|
||||
mgr.Cleanup()
|
||||
|
||||
// Verify directory is gone
|
||||
dir := filepath.Join(workDir, ".kandev", "attachments", "sess-cleanup")
|
||||
if _, err := os.Stat(dir); !os.IsNotExist(err) {
|
||||
t.Errorf("directory should not exist after cleanup, got err: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCleanup_EmptySessionID_NoOp(t *testing.T) {
|
||||
mgr := NewAttachmentManager("/tmp/work", testLogger())
|
||||
// Should not panic
|
||||
mgr.Cleanup()
|
||||
}
|
||||
|
||||
func TestCleanup_EmptyWorkDir_NoOp(t *testing.T) {
|
||||
mgr := NewAttachmentManager("", testLogger())
|
||||
mgr.SetSessionID("sess-1")
|
||||
// Should not panic
|
||||
mgr.Cleanup()
|
||||
}
|
||||
|
||||
func TestCleanup_Idempotent(t *testing.T) {
|
||||
workDir := t.TempDir()
|
||||
mgr := NewAttachmentManager(workDir, testLogger())
|
||||
mgr.SetSessionID("sess-idem")
|
||||
|
||||
encoded := base64.StdEncoding.EncodeToString([]byte("data"))
|
||||
_, _ = mgr.SaveAttachments([]v1.MessageAttachment{
|
||||
{Type: "resource", Data: encoded, MimeType: "text/plain", Name: "f.txt"},
|
||||
})
|
||||
|
||||
// Cleanup twice — second call should not panic
|
||||
mgr.Cleanup()
|
||||
mgr.Cleanup()
|
||||
}
|
||||
|
||||
func TestCleanup_SessionIsolation(t *testing.T) {
|
||||
workDir := t.TempDir()
|
||||
mgr1 := NewAttachmentManager(workDir, testLogger())
|
||||
mgr1.SetSessionID("sess-A")
|
||||
mgr2 := NewAttachmentManager(workDir, testLogger())
|
||||
mgr2.SetSessionID("sess-B")
|
||||
|
||||
encoded := base64.StdEncoding.EncodeToString([]byte("data"))
|
||||
|
||||
saved1, _ := mgr1.SaveAttachments([]v1.MessageAttachment{
|
||||
{Type: "resource", Data: encoded, MimeType: "text/plain", Name: "a.txt"},
|
||||
})
|
||||
saved2, _ := mgr2.SaveAttachments([]v1.MessageAttachment{
|
||||
{Type: "resource", Data: encoded, MimeType: "text/plain", Name: "b.txt"},
|
||||
})
|
||||
|
||||
// Cleanup session A
|
||||
mgr1.Cleanup()
|
||||
|
||||
// Session A file gone
|
||||
if _, err := os.Stat(saved1[0].AbsPath); !os.IsNotExist(err) {
|
||||
t.Error("session A file should be deleted after cleanup")
|
||||
}
|
||||
|
||||
// Session B file still exists
|
||||
if _, err := os.Stat(saved2[0].AbsPath); err != nil {
|
||||
t.Errorf("session B file should still exist: %v", err)
|
||||
}
|
||||
|
||||
// Cleanup session B
|
||||
mgr2.Cleanup()
|
||||
if _, err := os.Stat(saved2[0].AbsPath); !os.IsNotExist(err) {
|
||||
t.Error("session B file should be deleted after cleanup")
|
||||
}
|
||||
}
|
||||
|
||||
func TestBuildAttachmentPrompt_Empty(t *testing.T) {
|
||||
result := BuildAttachmentPrompt(nil)
|
||||
if result != "" {
|
||||
t.Errorf("expected empty string, got %q", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBuildAttachmentPrompt_SingleFile(t *testing.T) {
|
||||
saved := []SavedAttachment{
|
||||
{RelPath: ".kandev/attachments/s1/report.pdf", Name: "report.pdf"},
|
||||
}
|
||||
result := BuildAttachmentPrompt(saved)
|
||||
if result == "" {
|
||||
t.Fatal("expected non-empty result")
|
||||
}
|
||||
// Should mention the file name and path
|
||||
if !contains(result, "report.pdf") {
|
||||
t.Errorf("result should contain filename, got: %q", result)
|
||||
}
|
||||
if !contains(result, ".kandev/attachments/s1/report.pdf") {
|
||||
t.Errorf("result should contain path, got: %q", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBuildAttachmentPrompt_MultipleFiles(t *testing.T) {
|
||||
saved := []SavedAttachment{
|
||||
{RelPath: ".kandev/attachments/s1/a.pdf", Name: "a.pdf"},
|
||||
{RelPath: ".kandev/attachments/s1/b.png", Name: "b.png"},
|
||||
}
|
||||
result := BuildAttachmentPrompt(saved)
|
||||
if !contains(result, "a.pdf") {
|
||||
t.Errorf("result should contain a.pdf, got: %q", result)
|
||||
}
|
||||
if !contains(result, "b.png") {
|
||||
t.Errorf("result should contain b.png, got: %q", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestExtensionFromMimeType(t *testing.T) {
|
||||
tests := []struct {
|
||||
mimeType string
|
||||
want string
|
||||
}{
|
||||
{"image/png", ".png"},
|
||||
{"image/jpeg", ".jpg"},
|
||||
{"image/gif", ".gif"},
|
||||
{"image/webp", ".webp"},
|
||||
{"application/pdf", ".pdf"},
|
||||
{"text/plain", ".txt"},
|
||||
{"application/json", ".json"},
|
||||
{"text/csv", ".csv"},
|
||||
{"text/html", ".html"},
|
||||
{"text/markdown", ".md"},
|
||||
{"application/octet-stream", ""},
|
||||
{"video/mp4", ""},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
got := extensionFromMimeType(tt.mimeType)
|
||||
if got != tt.want {
|
||||
t.Errorf("extensionFromMimeType(%q) = %q, want %q", tt.mimeType, got, tt.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func contains(s, substr string) bool {
|
||||
return len(s) >= len(substr) && (s == substr || len(s) > 0 && containsStr(s, substr))
|
||||
}
|
||||
|
||||
func containsStr(s, substr string) bool {
|
||||
for i := 0; i <= len(s)-len(substr); i++ {
|
||||
if s[i:i+len(substr)] == substr {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
@@ -118,6 +118,9 @@ type Adapter struct {
|
||||
promptTraceCtx context.Context
|
||||
promptTraceMu sync.RWMutex
|
||||
|
||||
// Attachment management
|
||||
attachMgr *shared.AttachmentManager
|
||||
|
||||
// Synchronization
|
||||
mu sync.RWMutex
|
||||
closed bool
|
||||
@@ -141,9 +144,10 @@ type resultComplete struct {
|
||||
// cfg.AgentID is required for debug file naming.
|
||||
func NewAdapter(cfg *shared.Config, log *logger.Logger) *Adapter {
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
l := log.WithFields(zap.String("adapter", "stream-json"), zap.String("agent_id", cfg.AgentID))
|
||||
return &Adapter{
|
||||
cfg: cfg,
|
||||
logger: log.WithFields(zap.String("adapter", "stream-json"), zap.String("agent_id", cfg.AgentID)),
|
||||
logger: l,
|
||||
agentID: cfg.AgentID,
|
||||
normalizer: NewNormalizer(),
|
||||
ctx: ctx,
|
||||
@@ -151,6 +155,7 @@ func NewAdapter(cfg *shared.Config, log *logger.Logger) *Adapter {
|
||||
updatesCh: make(chan AgentEvent, 100),
|
||||
mainModelContextWindow: defaultContextWindow,
|
||||
pendingToolCalls: make(map[string]*streams.NormalizedPayload),
|
||||
attachMgr: shared.NewAttachmentManager(cfg.WorkDir, l.Zap()),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -180,6 +185,9 @@ func (a *Adapter) Close() error {
|
||||
|
||||
a.logger.Info("closing stream-json adapter")
|
||||
|
||||
// Clean up any saved attachments
|
||||
a.attachMgr.Cleanup()
|
||||
|
||||
// Cancel the context to stop the read loop
|
||||
if a.cancel != nil {
|
||||
a.cancel()
|
||||
|
||||
+7
-92
@@ -2,11 +2,7 @@ package streamjson
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"github.com/kandev/kandev/internal/agentctl/server/adapter/transport/shared"
|
||||
@@ -26,7 +22,6 @@ func (a *Adapter) Prompt(ctx context.Context, message string, attachments []v1.M
|
||||
sessionID := a.sessionID
|
||||
operationID := uuid.New().String()
|
||||
a.operationID = operationID
|
||||
workDir := a.cfg.WorkDir
|
||||
// Create channel to wait for result
|
||||
a.resultCh = make(chan resultComplete, 1)
|
||||
a.mu.Unlock()
|
||||
@@ -35,14 +30,14 @@ func (a *Adapter) Prompt(ctx context.Context, message string, attachments []v1.M
|
||||
return fmt.Errorf("adapter not initialized")
|
||||
}
|
||||
|
||||
// Handle image attachments by saving to temp files
|
||||
// Handle attachments by saving to workspace and referencing in prompt
|
||||
finalMessage := message
|
||||
if len(attachments) > 0 {
|
||||
imagePaths, err := a.saveImageAttachments(workDir, attachments)
|
||||
saved, err := a.attachMgr.SaveAttachments(attachments)
|
||||
if err != nil {
|
||||
a.logger.Warn("failed to save image attachments", zap.Error(err))
|
||||
} else if len(imagePaths) > 0 {
|
||||
finalMessage = a.buildMessageWithImages(message, imagePaths)
|
||||
a.logger.Warn("failed to save attachments", zap.Error(err))
|
||||
} else if len(saved) > 0 {
|
||||
finalMessage = shared.BuildAttachmentPrompt(saved) + message
|
||||
}
|
||||
}
|
||||
|
||||
@@ -98,92 +93,12 @@ func (a *Adapter) Prompt(ctx context.Context, message string, attachments []v1.M
|
||||
a.logger.Info("prompt completed",
|
||||
zap.String("operation_id", operationID),
|
||||
zap.Bool("success", result.success))
|
||||
// Clean up saved attachments — agent has finished reading them
|
||||
a.attachMgr.Cleanup()
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
// saveImageAttachments saves image attachments to temp files in the workspace.
|
||||
// Returns the relative paths to the saved files.
|
||||
func (a *Adapter) saveImageAttachments(workDir string, attachments []v1.MessageAttachment) ([]string, error) {
|
||||
var imagePaths []string
|
||||
|
||||
// Create temp directory for images
|
||||
tempDir := filepath.Join(workDir, ".kandev", "temp", "images")
|
||||
if err := os.MkdirAll(tempDir, 0755); err != nil {
|
||||
return nil, fmt.Errorf("failed to create temp directory: %w", err)
|
||||
}
|
||||
|
||||
for _, att := range attachments {
|
||||
if att.Type != "image" {
|
||||
continue
|
||||
}
|
||||
|
||||
// Decode base64 data
|
||||
imageData, err := base64.StdEncoding.DecodeString(att.Data)
|
||||
if err != nil {
|
||||
a.logger.Warn("failed to decode image attachment", zap.Error(err))
|
||||
continue
|
||||
}
|
||||
|
||||
// Determine file extension from mime type
|
||||
ext := ".png" // default
|
||||
switch att.MimeType {
|
||||
case "image/jpeg":
|
||||
ext = ".jpg"
|
||||
case "image/gif":
|
||||
ext = ".gif"
|
||||
case "image/webp":
|
||||
ext = ".webp"
|
||||
case "image/png":
|
||||
ext = ".png"
|
||||
}
|
||||
|
||||
// Generate unique filename
|
||||
filename := fmt.Sprintf("image-%s%s", uuid.New().String()[:8], ext)
|
||||
filePath := filepath.Join(tempDir, filename)
|
||||
|
||||
// Write image to file
|
||||
if err := os.WriteFile(filePath, imageData, 0644); err != nil {
|
||||
a.logger.Warn("failed to write image file", zap.Error(err), zap.String("path", filePath))
|
||||
continue
|
||||
}
|
||||
|
||||
// Store relative path from workspace root
|
||||
relPath, err := filepath.Rel(workDir, filePath)
|
||||
if err != nil {
|
||||
relPath = filePath // Fall back to absolute path
|
||||
}
|
||||
|
||||
imagePaths = append(imagePaths, relPath)
|
||||
a.logger.Info("saved image attachment",
|
||||
zap.String("path", relPath),
|
||||
zap.Int("size", len(imageData)))
|
||||
}
|
||||
|
||||
return imagePaths, nil
|
||||
}
|
||||
|
||||
// buildMessageWithImages prepends image file references to the user's message.
|
||||
func (a *Adapter) buildMessageWithImages(message string, imagePaths []string) string {
|
||||
var sb strings.Builder
|
||||
|
||||
// Add image references at the beginning
|
||||
if len(imagePaths) == 1 {
|
||||
sb.WriteString(fmt.Sprintf("I've attached an image file that you should read and analyze: %s\n\n", imagePaths[0]))
|
||||
} else {
|
||||
sb.WriteString("I've attached image files that you should read and analyze:\n")
|
||||
for _, path := range imagePaths {
|
||||
sb.WriteString(fmt.Sprintf("- %s\n", path))
|
||||
}
|
||||
sb.WriteString("\n")
|
||||
}
|
||||
|
||||
// Add the original message
|
||||
sb.WriteString(message)
|
||||
|
||||
return sb.String()
|
||||
}
|
||||
|
||||
// Cancel interrupts the current operation.
|
||||
func (a *Adapter) Cancel(ctx context.Context) error {
|
||||
a.mu.RLock()
|
||||
|
||||
+2
@@ -43,6 +43,7 @@ func (a *Adapter) NewSession(ctx context.Context, _ []types.McpServer) (string,
|
||||
pendingCommands := a.takePendingCommands()
|
||||
a.mu.Unlock()
|
||||
|
||||
a.attachMgr.SetSessionID(sessionID)
|
||||
a.logger.Info("created new session placeholder", zap.String("session_id", sessionID))
|
||||
a.emitPendingCommands(sessionID, pendingCommands)
|
||||
|
||||
@@ -57,6 +58,7 @@ func (a *Adapter) LoadSession(ctx context.Context, sessionID string) error {
|
||||
pendingCommands := a.takePendingCommands()
|
||||
a.mu.Unlock()
|
||||
|
||||
a.attachMgr.SetSessionID(sessionID)
|
||||
a.logger.Info("loaded session", zap.String("session_id", sessionID))
|
||||
a.emitPendingCommands(sessionID, pendingCommands)
|
||||
|
||||
|
||||
@@ -248,6 +248,14 @@ func (s *Server) handleAgentStreamRequest(ctx context.Context, msg *ws.Message)
|
||||
return s.handleWSPermissionRespond(ctx, msg)
|
||||
case "agent.stderr":
|
||||
return s.handleWSStderr(ctx, msg)
|
||||
case "agent.session.set_mode":
|
||||
return s.handleWSSetMode(ctx, msg)
|
||||
case "agent.session.set_model":
|
||||
return s.handleWSSetModel(ctx, msg)
|
||||
case "agent.session.authenticate":
|
||||
return s.handleWSAuthenticate(ctx, msg)
|
||||
case "agent.session.reset":
|
||||
return s.handleWSResetSession(ctx, msg)
|
||||
default:
|
||||
resp, _ := ws.NewError(msg.ID, msg.Action, ws.ErrorCodeUnknownAction, fmt.Sprintf("unknown action: %s", msg.Action), nil)
|
||||
return resp
|
||||
@@ -476,3 +484,105 @@ func (s *Server) handleWSStderr(_ context.Context, msg *ws.Message) *ws.Message
|
||||
resp, _ := ws.NewResponse(msg.ID, msg.Action, AgentStderrResponse{Lines: lines})
|
||||
return resp
|
||||
}
|
||||
|
||||
func (s *Server) handleWSSetMode(ctx context.Context, msg *ws.Message) *ws.Message {
|
||||
var req struct {
|
||||
SessionID string `json:"session_id"`
|
||||
ModeID string `json:"mode_id"`
|
||||
}
|
||||
return s.adapterAction(ctx, msg, &req, func(a adapter.AgentAdapter) error {
|
||||
ms, ok := a.(adapter.ModeSettableAdapter)
|
||||
if !ok {
|
||||
return fmt.Errorf("agent does not support mode switching")
|
||||
}
|
||||
return ms.SetMode(ctx, req.ModeID)
|
||||
})
|
||||
}
|
||||
|
||||
// adapterAction extracts common boilerplate for WS handlers that operate on the agent adapter:
|
||||
// parse payload, get adapter, assert interface, call action.
|
||||
func (s *Server) adapterAction(
|
||||
ctx context.Context,
|
||||
msg *ws.Message,
|
||||
payload any,
|
||||
action func(agentAdapter adapter.AgentAdapter) error,
|
||||
) *ws.Message {
|
||||
if err := msg.ParsePayload(payload); err != nil {
|
||||
resp, _ := ws.NewError(msg.ID, msg.Action, ws.ErrorCodeBadRequest, "invalid request: "+err.Error(), nil)
|
||||
return resp
|
||||
}
|
||||
|
||||
agentAdapter := s.procMgr.GetAdapter()
|
||||
if agentAdapter == nil {
|
||||
resp, _ := ws.NewError(msg.ID, msg.Action, ws.ErrorCodeInternalError, "agent not running", nil)
|
||||
return resp
|
||||
}
|
||||
|
||||
if err := action(agentAdapter); err != nil {
|
||||
s.logger.Error(msg.Action+" failed", zap.Error(err))
|
||||
resp, _ := ws.NewError(msg.ID, msg.Action, ws.ErrorCodeInternalError, err.Error(), nil)
|
||||
return resp
|
||||
}
|
||||
|
||||
resp, _ := ws.NewResponse(msg.ID, msg.Action, map[string]any{"success": true})
|
||||
return resp
|
||||
}
|
||||
|
||||
func (s *Server) handleWSSetModel(ctx context.Context, msg *ws.Message) *ws.Message {
|
||||
var req struct {
|
||||
ModelID string `json:"model_id"`
|
||||
}
|
||||
return s.adapterAction(ctx, msg, &req, func(a adapter.AgentAdapter) error {
|
||||
ms, ok := a.(adapter.ModelSettableAdapter)
|
||||
if !ok {
|
||||
return fmt.Errorf("agent does not support model switching")
|
||||
}
|
||||
return ms.SetModel(ctx, req.ModelID)
|
||||
})
|
||||
}
|
||||
|
||||
func (s *Server) handleWSAuthenticate(ctx context.Context, msg *ws.Message) *ws.Message {
|
||||
var req struct {
|
||||
MethodID string `json:"method_id"`
|
||||
}
|
||||
return s.adapterAction(ctx, msg, &req, func(a adapter.AgentAdapter) error {
|
||||
aa, ok := a.(adapter.AuthenticatableAdapter)
|
||||
if !ok {
|
||||
return fmt.Errorf("agent does not support authenticate")
|
||||
}
|
||||
return aa.Authenticate(ctx, req.MethodID)
|
||||
})
|
||||
}
|
||||
|
||||
func (s *Server) handleWSResetSession(ctx context.Context, msg *ws.Message) *ws.Message {
|
||||
var req NewSessionRequest
|
||||
if err := msg.ParsePayload(&req); err != nil {
|
||||
resp, _ := ws.NewError(msg.ID, msg.Action, ws.ErrorCodeBadRequest, "invalid request: "+err.Error(), nil)
|
||||
return resp
|
||||
}
|
||||
|
||||
agentAdapter := s.procMgr.GetAdapter()
|
||||
if agentAdapter == nil {
|
||||
resp, _ := ws.NewError(msg.ID, msg.Action, ws.ErrorCodeInternalError, "agent not running", nil)
|
||||
return resp
|
||||
}
|
||||
|
||||
sr, ok := agentAdapter.(adapter.SessionResettableAdapter)
|
||||
if !ok {
|
||||
resp, _ := ws.NewError(msg.ID, msg.Action, ws.ErrorCodeInternalError, "agent does not support session reset", nil)
|
||||
return resp
|
||||
}
|
||||
|
||||
sessionID, err := sr.ResetSession(ctx, req.McpServers)
|
||||
if err != nil {
|
||||
s.logger.Error("session reset failed", zap.Error(err))
|
||||
resp, _ := ws.NewError(msg.ID, msg.Action, ws.ErrorCodeInternalError, err.Error(), nil)
|
||||
return resp
|
||||
}
|
||||
|
||||
resp, _ := ws.NewResponse(msg.ID, msg.Action, NewSessionResponse{
|
||||
Success: true,
|
||||
SessionID: sessionID,
|
||||
})
|
||||
return resp
|
||||
}
|
||||
|
||||
@@ -50,10 +50,12 @@ type WorkspaceTracker struct {
|
||||
gitPollInterval time.Duration
|
||||
|
||||
// Control
|
||||
stopCh chan struct{}
|
||||
wg sync.WaitGroup
|
||||
started bool
|
||||
stopOnce sync.Once
|
||||
stopCh chan struct{}
|
||||
wg sync.WaitGroup
|
||||
started bool
|
||||
stopOnce sync.Once
|
||||
cancelCtx context.Context // Cancellable context for killing in-flight git commands on Stop
|
||||
cancelFunc context.CancelFunc // Cancel function called during Stop
|
||||
}
|
||||
|
||||
// NewWorkspaceTracker creates a new workspace tracker
|
||||
@@ -63,6 +65,8 @@ func NewWorkspaceTracker(workDir string, log *logger.Logger) *WorkspaceTracker {
|
||||
// Cache validated git index path (works with worktrees where .git is a file)
|
||||
gitIndexPath := resolveGitIndexPath(resolvedWorkDir)
|
||||
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
|
||||
return &WorkspaceTracker{
|
||||
workDir: resolvedWorkDir,
|
||||
gitIndexPath: gitIndexPath,
|
||||
@@ -70,6 +74,8 @@ func NewWorkspaceTracker(workDir string, log *logger.Logger) *WorkspaceTracker {
|
||||
workspaceStreamSubscribers: make(map[types.WorkspaceStreamSubscriber]struct{}),
|
||||
gitPollInterval: DefaultGitPollInterval,
|
||||
stopCh: make(chan struct{}),
|
||||
cancelCtx: ctx,
|
||||
cancelFunc: cancel,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -101,7 +107,9 @@ func resolveGitIndexPath(workDir string) string {
|
||||
// Start begins monitoring the workspace using polling (no fsnotify).
|
||||
// File changes are detected via git status polling, which is efficient and
|
||||
// doesn't consume file descriptors like fsnotify/kqueue does on macOS.
|
||||
func (wt *WorkspaceTracker) Start(ctx context.Context) {
|
||||
// The passed context is ignored — the tracker uses its own cancellable context
|
||||
// so that Stop() can kill in-flight git commands immediately.
|
||||
func (wt *WorkspaceTracker) Start(_ context.Context) {
|
||||
wt.mu.Lock()
|
||||
if wt.started {
|
||||
wt.mu.Unlock()
|
||||
@@ -113,18 +121,35 @@ func (wt *WorkspaceTracker) Start(ctx context.Context) {
|
||||
|
||||
// Start file change monitoring (uses git status polling)
|
||||
wt.wg.Add(1)
|
||||
go wt.monitorLoop(ctx)
|
||||
go wt.monitorLoop(wt.cancelCtx)
|
||||
|
||||
// Start git polling for detecting manual git operations (commits, resets, etc.)
|
||||
wt.wg.Add(1)
|
||||
go wt.pollGitChanges(ctx)
|
||||
go wt.pollGitChanges(wt.cancelCtx)
|
||||
}
|
||||
|
||||
// Stop stops the workspace tracker
|
||||
// stopTimeout is the maximum time Stop() will wait for goroutines to exit.
|
||||
const stopTimeout = 5 * time.Second
|
||||
|
||||
// Stop stops the workspace tracker. It cancels in-flight git commands and waits
|
||||
// up to 5 seconds for goroutines to exit before proceeding.
|
||||
func (wt *WorkspaceTracker) Stop() {
|
||||
wt.stopOnce.Do(func() {
|
||||
wt.cancelFunc() // Kill in-flight git commands immediately
|
||||
close(wt.stopCh)
|
||||
wt.wg.Wait()
|
||||
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
wt.wg.Wait()
|
||||
close(done)
|
||||
}()
|
||||
select {
|
||||
case <-done:
|
||||
// Clean shutdown
|
||||
case <-time.After(stopTimeout):
|
||||
wt.logger.Warn("workspace tracker stop timed out, proceeding anyway",
|
||||
zap.Duration("timeout", stopTimeout))
|
||||
}
|
||||
wt.logger.Info("workspace tracker stopped")
|
||||
})
|
||||
}
|
||||
|
||||
@@ -45,6 +45,12 @@ const (
|
||||
|
||||
// EventTypeRateLimit indicates the agent is being rate-limited by the API.
|
||||
EventTypeRateLimit = "rate_limit"
|
||||
|
||||
// EventTypeAgentCapabilities indicates agent capabilities from ACP initialize.
|
||||
EventTypeAgentCapabilities = "agent_capabilities"
|
||||
|
||||
// EventTypeSessionModels indicates available models from ACP session/new.
|
||||
EventTypeSessionModels = "session_models"
|
||||
)
|
||||
|
||||
// Session status constants for EventTypeSessionStatus events.
|
||||
@@ -195,6 +201,39 @@ type AgentEvent struct {
|
||||
|
||||
// CurrentModeID is the active session mode identifier (e.g., "code", "ask", "architect").
|
||||
CurrentModeID string `json:"current_mode_id,omitempty"`
|
||||
|
||||
// AvailableModes lists the modes the agent supports.
|
||||
AvailableModes []SessionModeInfo `json:"available_modes,omitempty"`
|
||||
|
||||
// --- Agent capabilities fields (for "agent_capabilities" type) ---
|
||||
|
||||
// SupportsImage indicates the agent natively supports image content blocks.
|
||||
SupportsImage bool `json:"supports_image"`
|
||||
|
||||
// SupportsAudio indicates the agent natively supports audio content blocks.
|
||||
SupportsAudio bool `json:"supports_audio"`
|
||||
|
||||
// SupportsEmbeddedContext indicates the agent supports embedded context.
|
||||
SupportsEmbeddedContext bool `json:"supports_embedded_context"`
|
||||
|
||||
// AuthMethods lists authentication methods from ACP initialize.
|
||||
AuthMethods []AuthMethodInfo `json:"auth_methods,omitempty"`
|
||||
|
||||
// --- Session models fields (for "session_models" type) ---
|
||||
|
||||
// CurrentModelID is the active model identifier.
|
||||
CurrentModelID string `json:"current_model_id,omitempty"`
|
||||
|
||||
// SessionModels lists models available in the ACP session.
|
||||
SessionModels []SessionModelInfo `json:"session_models,omitempty"`
|
||||
|
||||
// ConfigOptions lists session configuration options from ACP _meta.
|
||||
ConfigOptions []ConfigOption `json:"config_options,omitempty"`
|
||||
|
||||
// --- Usage fields (attached to "complete" event) ---
|
||||
|
||||
// Usage contains token usage stats from the prompt response.
|
||||
Usage *PromptUsage `json:"usage,omitempty"`
|
||||
}
|
||||
|
||||
// PlanEntry represents an entry in the agent's execution plan.
|
||||
@@ -252,6 +291,105 @@ type ContentBlock struct {
|
||||
Size *int `json:"size,omitempty"`
|
||||
}
|
||||
|
||||
// SessionModeInfo represents an available session mode from ACP.
|
||||
type SessionModeInfo struct {
|
||||
// ID is the mode identifier (e.g., "code", "ask", "architect").
|
||||
ID string `json:"id"`
|
||||
|
||||
// Name is a human-readable name for the mode.
|
||||
Name string `json:"name"`
|
||||
|
||||
// Description provides additional context about the mode.
|
||||
Description string `json:"description,omitempty"`
|
||||
}
|
||||
|
||||
// SessionModelInfo represents a model available in an ACP session.
|
||||
type SessionModelInfo struct {
|
||||
// ModelID is the model identifier.
|
||||
ModelID string `json:"model_id"`
|
||||
|
||||
// Name is a human-readable model name.
|
||||
Name string `json:"name"`
|
||||
|
||||
// Description provides additional context about the model.
|
||||
Description string `json:"description,omitempty"`
|
||||
|
||||
// UsageMultiplier is the normalized pricing multiplier (e.g., "1x", "3x").
|
||||
UsageMultiplier string `json:"usage_multiplier,omitempty"`
|
||||
|
||||
// Meta contains raw _meta from the agent for agent-specific rendering.
|
||||
Meta map[string]any `json:"meta,omitempty"`
|
||||
}
|
||||
|
||||
// AuthMethodInfo represents an authentication method from ACP initialize.
|
||||
type AuthMethodInfo struct {
|
||||
// ID is the auth method identifier.
|
||||
ID string `json:"id"`
|
||||
|
||||
// Name is a human-readable name for the auth method.
|
||||
Name string `json:"name"`
|
||||
|
||||
// Description provides additional context.
|
||||
Description string `json:"description,omitempty"`
|
||||
|
||||
// TerminalAuth contains normalized terminal-based auth info from _meta.
|
||||
TerminalAuth *TerminalAuth `json:"terminal_auth,omitempty"`
|
||||
|
||||
// Meta contains raw _meta from the agent.
|
||||
Meta map[string]any `json:"meta,omitempty"`
|
||||
}
|
||||
|
||||
// TerminalAuth contains normalized terminal-based authentication info.
|
||||
type TerminalAuth struct {
|
||||
// Command is the CLI command to run (e.g., "copilot").
|
||||
Command string `json:"command"`
|
||||
|
||||
// Args are the command arguments (e.g., ["auth", "login"]).
|
||||
Args []string `json:"args,omitempty"`
|
||||
|
||||
// Label is a human-readable description of the auth action.
|
||||
Label string `json:"label,omitempty"`
|
||||
}
|
||||
|
||||
// ConfigOption represents a session configuration option from ACP _meta.
|
||||
type ConfigOption struct {
|
||||
// Type is the option type: "select", "toggle", etc.
|
||||
Type string `json:"type"`
|
||||
|
||||
// ID is the option identifier (e.g., "mode", "model", "reasoning_effort").
|
||||
ID string `json:"id"`
|
||||
|
||||
// Name is a human-readable name.
|
||||
Name string `json:"name"`
|
||||
|
||||
// CurrentValue is the currently selected value.
|
||||
CurrentValue string `json:"current_value"`
|
||||
|
||||
// Category groups related options.
|
||||
Category string `json:"category,omitempty"`
|
||||
|
||||
// Options lists the selectable values.
|
||||
Options []ConfigOptionValue `json:"options,omitempty"`
|
||||
}
|
||||
|
||||
// ConfigOptionValue represents a selectable value for a ConfigOption.
|
||||
type ConfigOptionValue struct {
|
||||
// Value is the option value.
|
||||
Value string `json:"value"`
|
||||
|
||||
// Name is a human-readable label.
|
||||
Name string `json:"name"`
|
||||
}
|
||||
|
||||
// PromptUsage contains token usage info from an ACP prompt response.
|
||||
type PromptUsage struct {
|
||||
InputTokens int64 `json:"input_tokens"`
|
||||
OutputTokens int64 `json:"output_tokens"`
|
||||
CachedReadTokens int64 `json:"cached_read_tokens,omitempty"`
|
||||
CachedWriteTokens int64 `json:"cached_write_tokens,omitempty"`
|
||||
TotalTokens int64 `json:"total_tokens"`
|
||||
}
|
||||
|
||||
// ToolCallContentItem represents a content item produced by a tool call.
|
||||
// This is a discriminated union: exactly one of Content, Diff, or Terminal fields will be set.
|
||||
type ToolCallContentItem struct {
|
||||
|
||||
@@ -164,6 +164,21 @@ const (
|
||||
SessionModeChanged = "session_mode.changed" // Agent session mode changed
|
||||
)
|
||||
|
||||
// Event types for ACP capabilities and models
|
||||
const (
|
||||
AgentCapabilitiesUpdated = "agent_capabilities.updated" // Agent capabilities received
|
||||
SessionModelsUpdated = "session_models.updated" // Session models received
|
||||
)
|
||||
|
||||
// Event types for session todos (ACP plan entries)
|
||||
const (
|
||||
SessionTodosUpdated = "session_todos.updated" // Agent plan/todo entries updated
|
||||
)
|
||||
|
||||
const (
|
||||
SessionPromptUsageUpdated = "session_prompt_usage.updated" // Prompt token usage updated
|
||||
)
|
||||
|
||||
// Event types for GitHub integration
|
||||
const (
|
||||
GitHubPRFeedback = "github.pr_feedback" // PR has new feedback (UI notification only)
|
||||
@@ -293,3 +308,43 @@ func BuildSessionModeSubject(sessionID string) string {
|
||||
func BuildSessionModeWildcardSubject() string {
|
||||
return SessionModeChanged + ".*"
|
||||
}
|
||||
|
||||
// BuildAgentCapabilitiesSubject creates an agent capabilities subject for a specific session
|
||||
func BuildAgentCapabilitiesSubject(sessionID string) string {
|
||||
return AgentCapabilitiesUpdated + "." + sessionID
|
||||
}
|
||||
|
||||
// BuildAgentCapabilitiesWildcardSubject creates a wildcard subscription for all agent capabilities events
|
||||
func BuildAgentCapabilitiesWildcardSubject() string {
|
||||
return AgentCapabilitiesUpdated + ".*"
|
||||
}
|
||||
|
||||
// BuildSessionModelsSubject creates a session models subject for a specific session
|
||||
func BuildSessionModelsSubject(sessionID string) string {
|
||||
return SessionModelsUpdated + "." + sessionID
|
||||
}
|
||||
|
||||
// BuildSessionModelsWildcardSubject creates a wildcard subscription for all session models events
|
||||
func BuildSessionModelsWildcardSubject() string {
|
||||
return SessionModelsUpdated + ".*"
|
||||
}
|
||||
|
||||
// BuildSessionTodosSubject creates a session todos subject for a specific session
|
||||
func BuildSessionTodosSubject(sessionID string) string {
|
||||
return SessionTodosUpdated + "." + sessionID
|
||||
}
|
||||
|
||||
// BuildSessionTodosWildcardSubject creates a wildcard subscription for all session todos events
|
||||
func BuildSessionTodosWildcardSubject() string {
|
||||
return SessionTodosUpdated + ".*"
|
||||
}
|
||||
|
||||
// BuildSessionPromptUsageSubject creates a prompt usage subject for a specific session
|
||||
func BuildSessionPromptUsageSubject(sessionID string) string {
|
||||
return SessionPromptUsageUpdated + "." + sessionID
|
||||
}
|
||||
|
||||
// BuildSessionPromptUsageWildcardSubject creates a wildcard subscription for all prompt usage events
|
||||
func BuildSessionPromptUsageWildcardSubject() string {
|
||||
return SessionPromptUsageUpdated + ".*"
|
||||
}
|
||||
|
||||
@@ -49,6 +49,10 @@ func RegisterSessionStreamNotifications(ctx context.Context, eventBus bus.EventB
|
||||
b.subscribe(eventBus, events.BuildProcessStatusWildcardSubject(), ws.ActionSessionProcessStatus)
|
||||
b.subscribe(eventBus, events.BuildAvailableCommandsWildcardSubject(), ws.ActionSessionAvailableCommands)
|
||||
b.subscribe(eventBus, events.BuildSessionModeWildcardSubject(), ws.ActionSessionModeChanged)
|
||||
b.subscribe(eventBus, events.BuildAgentCapabilitiesWildcardSubject(), ws.ActionSessionAgentCapabilities)
|
||||
b.subscribe(eventBus, events.BuildSessionModelsWildcardSubject(), ws.ActionSessionModelsUpdated)
|
||||
b.subscribe(eventBus, events.BuildSessionTodosWildcardSubject(), ws.ActionSessionTodosUpdated)
|
||||
b.subscribe(eventBus, events.BuildSessionPromptUsageWildcardSubject(), ws.ActionSessionPromptUsage)
|
||||
|
||||
go func() {
|
||||
<-ctx.Done()
|
||||
|
||||
@@ -406,6 +406,14 @@ func (s *SimulatedAgentManagerClient) RestartAgentProcess(ctx context.Context, a
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *SimulatedAgentManagerClient) ResetAgentContext(ctx context.Context, agentExecutionID string) error {
|
||||
return s.RestartAgentProcess(ctx, agentExecutionID)
|
||||
}
|
||||
|
||||
func (s *SimulatedAgentManagerClient) SetSessionModelBySessionID(_ context.Context, _, _ string) error {
|
||||
return fmt.Errorf("not supported")
|
||||
}
|
||||
|
||||
func (s *SimulatedAgentManagerClient) WasSessionInitialized(_ string) bool { return false }
|
||||
func (s *SimulatedAgentManagerClient) IsPassthroughSession(ctx context.Context, sessionID string) bool {
|
||||
return false
|
||||
|
||||
@@ -198,6 +198,7 @@ func (a *testMessageCreatorAdapter) CreateThinkingMessageStreaming(ctx context.C
|
||||
func (a *testMessageCreatorAdapter) AppendThinkingMessage(ctx context.Context, messageID, additionalContent string) error {
|
||||
return a.svc.AppendThinkingContent(ctx, messageID, additionalContent)
|
||||
}
|
||||
func (a *testMessageCreatorAdapter) InvalidateModelCache(string) {}
|
||||
|
||||
// testTurnServiceAdapter adapts the task service to the orchestrator.TurnService interface for tests
|
||||
type testTurnServiceAdapter struct {
|
||||
|
||||
@@ -7,6 +7,7 @@ import (
|
||||
"go.uber.org/zap"
|
||||
|
||||
"github.com/kandev/kandev/internal/agent/lifecycle"
|
||||
"github.com/kandev/kandev/internal/agentctl/types/streams"
|
||||
"github.com/kandev/kandev/internal/events"
|
||||
"github.com/kandev/kandev/internal/events/bus"
|
||||
"github.com/kandev/kandev/internal/task/models"
|
||||
@@ -62,6 +63,15 @@ func (s *Service) handleAgentStreamEvent(ctx context.Context, payload *lifecycle
|
||||
case "session_mode":
|
||||
s.handleSessionModeEvent(ctx, payload)
|
||||
|
||||
case "agent_capabilities":
|
||||
s.handleAgentCapabilitiesEvent(ctx, payload)
|
||||
|
||||
case "session_models":
|
||||
s.handleSessionModelsEvent(ctx, payload)
|
||||
|
||||
case "plan":
|
||||
s.handleSessionTodosEvent(ctx, payload)
|
||||
|
||||
case "permission_cancelled":
|
||||
s.handlePermissionCancelledEvent(ctx, payload)
|
||||
|
||||
@@ -451,6 +461,7 @@ func (s *Service) handleCompleteStreamEvent(ctx context.Context, payload *lifecy
|
||||
|
||||
s.saveAgentTextIfPresent(ctx, payload)
|
||||
s.publishAgentPlanIfPresent(ctx, payload)
|
||||
s.publishPromptUsage(ctx, payload)
|
||||
s.completeTurnForSession(ctx, payload.SessionID)
|
||||
|
||||
// Cancel any pending clarifications for this session so WaitForResponse
|
||||
@@ -502,6 +513,23 @@ func (s *Service) publishAgentPlanIfPresent(ctx context.Context, payload *lifecy
|
||||
}
|
||||
}
|
||||
|
||||
// publishPromptUsage broadcasts prompt token usage to the WebSocket for the frontend.
|
||||
func (s *Service) publishPromptUsage(ctx context.Context, payload *lifecycle.AgentStreamEventPayload) {
|
||||
sessionID := payload.SessionID
|
||||
if sessionID == "" || s.eventBus == nil || payload.Data.Usage == nil {
|
||||
return
|
||||
}
|
||||
eventPayload := lifecycle.SessionPromptUsageEventPayload{
|
||||
TaskID: payload.TaskID,
|
||||
SessionID: sessionID,
|
||||
AgentID: payload.AgentID,
|
||||
Usage: payload.Data.Usage,
|
||||
Timestamp: time.Now().UTC().Format(time.RFC3339),
|
||||
}
|
||||
subject := events.BuildSessionPromptUsageSubject(sessionID)
|
||||
_ = s.eventBus.Publish(ctx, subject, bus.NewEvent(events.SessionPromptUsageUpdated, "orchestrator", eventPayload))
|
||||
}
|
||||
|
||||
// handleAvailableCommandsEvent broadcasts available_commands events to the WebSocket for the frontend.
|
||||
func (s *Service) handleAvailableCommandsEvent(ctx context.Context, payload *lifecycle.AgentStreamEventPayload) {
|
||||
sessionID := payload.SessionID
|
||||
@@ -525,21 +553,135 @@ func (s *Service) handleSessionModeEvent(ctx context.Context, payload *lifecycle
|
||||
if sessionID == "" || s.eventBus == nil {
|
||||
return
|
||||
}
|
||||
// Don't broadcast "default" mode — it's the baseline state, not worth sending.
|
||||
if payload.Data.CurrentModeID == "default" {
|
||||
return
|
||||
}
|
||||
eventPayload := lifecycle.SessionModeEventPayload{
|
||||
TaskID: payload.TaskID,
|
||||
SessionID: sessionID,
|
||||
AgentID: payload.AgentID,
|
||||
CurrentModeID: payload.Data.CurrentModeID,
|
||||
Timestamp: time.Now().UTC().Format(time.RFC3339),
|
||||
TaskID: payload.TaskID,
|
||||
SessionID: sessionID,
|
||||
AgentID: payload.AgentID,
|
||||
CurrentModeID: payload.Data.CurrentModeID,
|
||||
AvailableModes: payload.Data.AvailableModes,
|
||||
Timestamp: time.Now().UTC().Format(time.RFC3339),
|
||||
}
|
||||
subject := events.BuildSessionModeSubject(sessionID)
|
||||
_ = s.eventBus.Publish(ctx, subject, bus.NewEvent(events.SessionModeChanged, "orchestrator", eventPayload))
|
||||
}
|
||||
|
||||
// handleAgentCapabilitiesEvent broadcasts agent_capabilities events to the WebSocket.
|
||||
func (s *Service) handleAgentCapabilitiesEvent(ctx context.Context, payload *lifecycle.AgentStreamEventPayload) {
|
||||
sessionID := payload.SessionID
|
||||
if sessionID == "" || s.eventBus == nil {
|
||||
return
|
||||
}
|
||||
eventPayload := lifecycle.AgentCapabilitiesEventPayload{
|
||||
TaskID: payload.TaskID,
|
||||
SessionID: sessionID,
|
||||
AgentID: payload.AgentID,
|
||||
SupportsImage: payload.Data.SupportsImage,
|
||||
SupportsAudio: payload.Data.SupportsAudio,
|
||||
SupportsEmbeddedContext: payload.Data.SupportsEmbeddedContext,
|
||||
AuthMethods: payload.Data.AuthMethods,
|
||||
Timestamp: time.Now().UTC().Format(time.RFC3339),
|
||||
}
|
||||
subject := events.BuildAgentCapabilitiesSubject(sessionID)
|
||||
_ = s.eventBus.Publish(ctx, subject, bus.NewEvent(events.AgentCapabilitiesUpdated, "orchestrator", eventPayload))
|
||||
}
|
||||
|
||||
// handleSessionModelsEvent broadcasts session_models events to the WebSocket
|
||||
// and persists the current model to the session snapshot so it survives page refresh.
|
||||
func (s *Service) handleSessionModelsEvent(ctx context.Context, payload *lifecycle.AgentStreamEventPayload) {
|
||||
sessionID := payload.SessionID
|
||||
if sessionID == "" || s.eventBus == nil {
|
||||
return
|
||||
}
|
||||
|
||||
// Persist the ACP-reported current model to the session snapshot so it's
|
||||
// available after page refresh (SSR reads from the DB, not runtime state).
|
||||
if currentModel := payload.Data.CurrentModelID; currentModel != "" {
|
||||
s.persistSessionModel(ctx, sessionID, currentModel)
|
||||
}
|
||||
|
||||
eventPayload := lifecycle.SessionModelsEventPayload{
|
||||
TaskID: payload.TaskID,
|
||||
SessionID: sessionID,
|
||||
AgentID: payload.AgentID,
|
||||
CurrentModelID: payload.Data.CurrentModelID,
|
||||
Models: payload.Data.SessionModels,
|
||||
ConfigOptions: payload.Data.ConfigOptions,
|
||||
Timestamp: time.Now().UTC().Format(time.RFC3339),
|
||||
}
|
||||
subject := events.BuildSessionModelsSubject(sessionID)
|
||||
_ = s.eventBus.Publish(ctx, subject, bus.NewEvent(events.SessionModelsUpdated, "orchestrator", eventPayload))
|
||||
}
|
||||
|
||||
// persistSessionModel updates the session's AgentProfileSnapshot with the current model.
|
||||
func (s *Service) persistSessionModel(ctx context.Context, sessionID, model string) {
|
||||
session, err := s.repo.GetTaskSession(ctx, sessionID)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
if session.AgentProfileSnapshot == nil {
|
||||
session.AgentProfileSnapshot = make(map[string]interface{})
|
||||
}
|
||||
existing, _ := session.AgentProfileSnapshot["model"].(string)
|
||||
if existing == model {
|
||||
return
|
||||
}
|
||||
session.AgentProfileSnapshot["model"] = model
|
||||
_ = s.repo.UpdateTaskSession(ctx, session)
|
||||
// Invalidate the message creator's model cache so subsequent messages use the new model.
|
||||
if s.messageCreator != nil {
|
||||
s.messageCreator.InvalidateModelCache(sessionID)
|
||||
}
|
||||
}
|
||||
|
||||
// handleSessionTodosEvent broadcasts plan/todo entries to the WebSocket and persists
|
||||
// them as a chat message so they survive page refresh and appear in the chat timeline.
|
||||
func (s *Service) handleSessionTodosEvent(ctx context.Context, payload *lifecycle.AgentStreamEventPayload) {
|
||||
sessionID := payload.SessionID
|
||||
if sessionID == "" || s.eventBus == nil {
|
||||
return
|
||||
}
|
||||
entries := payload.Data.PlanEntries
|
||||
|
||||
// Broadcast real-time update via event bus (updates the store's sessionTodos)
|
||||
eventPayload := lifecycle.SessionTodosEventPayload{
|
||||
TaskID: payload.TaskID,
|
||||
SessionID: sessionID,
|
||||
AgentID: payload.AgentID,
|
||||
Entries: entries,
|
||||
Timestamp: time.Now().UTC().Format(time.RFC3339),
|
||||
}
|
||||
subject := events.BuildSessionTodosSubject(sessionID)
|
||||
_ = s.eventBus.Publish(ctx, subject, bus.NewEvent(events.SessionTodosUpdated, "orchestrator", eventPayload))
|
||||
|
||||
// Persist as a chat message so todos appear in the timeline and survive refresh
|
||||
s.persistTodoMessage(ctx, payload.TaskID, sessionID, entries)
|
||||
}
|
||||
|
||||
// persistTodoMessage creates a "todo" message with the todo entries as metadata.
|
||||
// Empty entries are persisted too — they represent the agent clearing all todos.
|
||||
func (s *Service) persistTodoMessage(ctx context.Context, taskID, sessionID string, entries []streams.PlanEntry) {
|
||||
if s.messageCreator == nil {
|
||||
return
|
||||
}
|
||||
todos := make([]map[string]interface{}, len(entries))
|
||||
for i, e := range entries {
|
||||
todos[i] = map[string]interface{}{
|
||||
"text": e.Description,
|
||||
"status": e.Status,
|
||||
"done": e.Status == "completed",
|
||||
}
|
||||
}
|
||||
metadata := map[string]interface{}{"todos": todos}
|
||||
if err := s.messageCreator.CreateSessionMessage(
|
||||
ctx, taskID, "Updated Todos", sessionID,
|
||||
string(models.MessageTypeTodo), s.getActiveTurnID(sessionID), metadata, false,
|
||||
); err != nil {
|
||||
s.logger.Warn("failed to create todo message",
|
||||
zap.String("session_id", sessionID),
|
||||
zap.Error(err))
|
||||
}
|
||||
}
|
||||
|
||||
// handlePermissionCancelledEvent marks the pending permission message as expired.
|
||||
func (s *Service) handlePermissionCancelledEvent(ctx context.Context, payload *lifecycle.AgentStreamEventPayload) {
|
||||
sessionID := payload.SessionID
|
||||
|
||||
@@ -8,6 +8,7 @@ import (
|
||||
"github.com/stretchr/testify/require"
|
||||
|
||||
"github.com/kandev/kandev/internal/agent/lifecycle"
|
||||
"github.com/kandev/kandev/internal/agentctl/types/streams"
|
||||
"github.com/kandev/kandev/internal/events/bus"
|
||||
)
|
||||
|
||||
@@ -52,7 +53,7 @@ func TestHandleSessionModeEvent(t *testing.T) {
|
||||
require.Len(t, eb.events, 1)
|
||||
})
|
||||
|
||||
t.Run("skips default mode", func(t *testing.T) {
|
||||
t.Run("publishes default mode without available modes (mode exit)", func(t *testing.T) {
|
||||
eb := &recordingEventBus{}
|
||||
svc := &Service{logger: testLogger(), eventBus: eb}
|
||||
|
||||
@@ -63,7 +64,27 @@ func TestHandleSessionModeEvent(t *testing.T) {
|
||||
Data: &lifecycle.AgentStreamEventData{CurrentModeID: "default"},
|
||||
})
|
||||
|
||||
require.Empty(t, eb.events)
|
||||
require.Len(t, eb.events, 1)
|
||||
})
|
||||
|
||||
t.Run("publishes default mode with available modes (initial state)", func(t *testing.T) {
|
||||
eb := &recordingEventBus{}
|
||||
svc := &Service{logger: testLogger(), eventBus: eb}
|
||||
|
||||
svc.handleSessionModeEvent(context.Background(), &lifecycle.AgentStreamEventPayload{
|
||||
TaskID: "t1",
|
||||
SessionID: "s1",
|
||||
AgentID: "a1",
|
||||
Data: &lifecycle.AgentStreamEventData{
|
||||
CurrentModeID: "default",
|
||||
AvailableModes: []streams.SessionModeInfo{
|
||||
{ID: "default", Name: "Default"},
|
||||
{ID: "plan", Name: "Plan"},
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
require.Len(t, eb.events, 1)
|
||||
})
|
||||
|
||||
t.Run("publishes empty mode (mode exit)", func(t *testing.T) {
|
||||
|
||||
@@ -165,9 +165,15 @@ func (m *mockAgentManager) RestartAgentProcess(_ context.Context, agentExecution
|
||||
m.restartProcessCalls = append(m.restartProcessCalls, agentExecutionID)
|
||||
return m.restartProcessErr
|
||||
}
|
||||
func (m *mockAgentManager) ResetAgentContext(ctx context.Context, agentExecutionID string) error {
|
||||
return m.RestartAgentProcess(ctx, agentExecutionID)
|
||||
}
|
||||
func (m *mockAgentManager) SetExecutionDescription(_ context.Context, _, _ string) error {
|
||||
return nil
|
||||
}
|
||||
func (m *mockAgentManager) SetSessionModelBySessionID(_ context.Context, _, _ string) error {
|
||||
return fmt.Errorf("not supported")
|
||||
}
|
||||
func (m *mockAgentManager) WasSessionInitialized(_ string) bool { return false }
|
||||
func (m *mockAgentManager) IsPassthroughSession(_ context.Context, _ string) bool {
|
||||
return m.isPassthrough
|
||||
|
||||
@@ -662,7 +662,7 @@ func (s *Service) resetAgentContext(ctx context.Context, taskID string, session
|
||||
s.setSessionResetInProgress(sessionID, true)
|
||||
defer s.setSessionResetInProgress(sessionID, false)
|
||||
|
||||
if err := s.agentManager.RestartAgentProcess(ctx, session.AgentExecutionID); err != nil {
|
||||
if err := s.agentManager.ResetAgentContext(ctx, session.AgentExecutionID); err != nil {
|
||||
s.logger.Error("failed to reset agent context",
|
||||
zap.String("task_id", taskID),
|
||||
zap.String("session_id", sessionID),
|
||||
|
||||
@@ -100,6 +100,15 @@ type AgentManagerClient interface {
|
||||
// clearing the agent's conversation context. The execution environment (container/agentctl) is preserved.
|
||||
RestartAgentProcess(ctx context.Context, agentExecutionID string) error
|
||||
|
||||
// ResetAgentContext resets the agent's conversation context using the fastest available strategy.
|
||||
// For ACP agents, this creates a new session without restarting the process.
|
||||
// For other agents, this falls back to RestartAgentProcess.
|
||||
ResetAgentContext(ctx context.Context, agentExecutionID string) error
|
||||
|
||||
// SetSessionModelBySessionID attempts an in-place model switch via ACP session/set_model.
|
||||
// Returns an error if the agent doesn't support in-place model switching.
|
||||
SetSessionModelBySessionID(ctx context.Context, sessionID, modelID string) error
|
||||
|
||||
// WasSessionInitialized reports whether the given execution completed session initialization.
|
||||
// Used to distinguish launch-phase failures from normal prompt failures.
|
||||
WasSessionInitialized(executionID string) bool
|
||||
|
||||
@@ -145,15 +145,27 @@ func (e *Executor) Prompt(ctx context.Context, taskID, sessionID string, prompt
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// SwitchModel stops the current agent, restarts it with a new model, and sends the prompt.
|
||||
// For agents that support session resume (can_recover: true), it attempts to resume context.
|
||||
// For agents that don't support resume (can_recover: false), a fresh session is started.
|
||||
// SwitchModel switches the model for a running session. It first attempts an in-place switch
|
||||
// via ACP session/set_model (instant, no process restart). If the agent doesn't support
|
||||
// in-place switching, it falls back to stopping and restarting the agent with the new model.
|
||||
func (e *Executor) SwitchModel(ctx context.Context, taskID, sessionID, newModel, prompt string) (*PromptResult, error) {
|
||||
e.logger.Info("switching model for session",
|
||||
zap.String("task_id", taskID),
|
||||
zap.String("session_id", sessionID),
|
||||
zap.String("new_model", newModel))
|
||||
|
||||
// Try in-place model switch first (ACP agents support session/set_model)
|
||||
if err := e.agentManager.SetSessionModelBySessionID(ctx, sessionID, newModel); err == nil {
|
||||
e.logger.Info("model switched in-place via ACP session/set_model",
|
||||
zap.String("session_id", sessionID),
|
||||
zap.String("new_model", newModel))
|
||||
e.persistInPlaceModelSwitch(ctx, sessionID, newModel)
|
||||
return &PromptResult{StopReason: "model_switched_in_place"}, nil
|
||||
}
|
||||
|
||||
e.logger.Debug("in-place model switch not available, falling back to agent restart",
|
||||
zap.String("session_id", sessionID))
|
||||
|
||||
session, task, acpSessionID, existingRunning, err := e.prepareModelSwitch(ctx, taskID, sessionID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
@@ -360,6 +372,27 @@ func (e *Executor) persistModelSwitchState(ctx context.Context, taskID, sessionI
|
||||
}
|
||||
}
|
||||
|
||||
// persistInPlaceModelSwitch updates the session snapshot model after a successful
|
||||
// in-place model switch (no agent restart). Only the model field changes.
|
||||
func (e *Executor) persistInPlaceModelSwitch(ctx context.Context, sessionID, newModel string) {
|
||||
session, err := e.repo.GetTaskSession(ctx, sessionID)
|
||||
if err != nil {
|
||||
e.logger.Warn("failed to get session for in-place model switch persistence",
|
||||
zap.String("session_id", sessionID),
|
||||
zap.Error(err))
|
||||
return
|
||||
}
|
||||
if session.AgentProfileSnapshot == nil {
|
||||
session.AgentProfileSnapshot = make(map[string]interface{})
|
||||
}
|
||||
session.AgentProfileSnapshot["model"] = newModel
|
||||
if err := e.repo.UpdateTaskSession(ctx, session); err != nil {
|
||||
e.logger.Warn("failed to persist in-place model switch",
|
||||
zap.String("session_id", sessionID),
|
||||
zap.Error(err))
|
||||
}
|
||||
}
|
||||
|
||||
// RespondToPermission sends a response to a permission request for a session
|
||||
func (e *Executor) RespondToPermission(ctx context.Context, sessionID, pendingID, optionID string, cancelled bool) error {
|
||||
e.logger.Debug("responding to permission request",
|
||||
|
||||
@@ -74,6 +74,13 @@ func (m *mockAgentManager) RespondToPermissionBySessionID(ctx context.Context, s
|
||||
func (m *mockAgentManager) RestartAgentProcess(ctx context.Context, agentExecutionID string) error {
|
||||
return nil
|
||||
}
|
||||
func (m *mockAgentManager) ResetAgentContext(ctx context.Context, agentExecutionID string) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *mockAgentManager) SetSessionModelBySessionID(ctx context.Context, sessionID, modelID string) error {
|
||||
return fmt.Errorf("not supported")
|
||||
}
|
||||
|
||||
func (m *mockAgentManager) IsAgentRunningForSession(ctx context.Context, sessionID string) bool {
|
||||
return false
|
||||
|
||||
@@ -2,6 +2,7 @@ package scheduler
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"path/filepath"
|
||||
"sync"
|
||||
"testing"
|
||||
@@ -72,6 +73,12 @@ func (m *mockAgentManager) RespondToPermissionBySessionID(ctx context.Context, s
|
||||
func (m *mockAgentManager) RestartAgentProcess(ctx context.Context, agentExecutionID string) error {
|
||||
return nil
|
||||
}
|
||||
func (m *mockAgentManager) ResetAgentContext(ctx context.Context, agentExecutionID string) error {
|
||||
return nil
|
||||
}
|
||||
func (m *mockAgentManager) SetSessionModelBySessionID(_ context.Context, _, _ string) error {
|
||||
return errors.New("not supported")
|
||||
}
|
||||
|
||||
func (m *mockAgentManager) IsAgentRunningForSession(ctx context.Context, sessionID string) bool {
|
||||
return false
|
||||
|
||||
@@ -79,6 +79,9 @@ type MessageCreator interface {
|
||||
CreateThinkingMessageStreaming(ctx context.Context, messageID, taskID, content, agentSessionID, turnID string) error
|
||||
// AppendThinkingMessage appends additional content to an existing streaming thinking message
|
||||
AppendThinkingMessage(ctx context.Context, messageID, additionalContent string) error
|
||||
// InvalidateModelCache clears any cached model for a session, forcing the next
|
||||
// message to re-read the model from the DB. Called after model switches.
|
||||
InvalidateModelCache(sessionID string)
|
||||
}
|
||||
|
||||
// TurnService is an interface for managing session turns
|
||||
|
||||
@@ -1262,12 +1262,20 @@ func (s *Service) trySwitchModel(ctx context.Context, taskID, sessionID, model,
|
||||
zap.String("session_id", sessionID),
|
||||
zap.String("from", currentModel),
|
||||
zap.String("to", model))
|
||||
s.startTurnForSession(ctx, sessionID)
|
||||
switchCtx := context.WithoutCancel(ctx)
|
||||
switchResult, err := s.executor.SwitchModel(switchCtx, taskID, sessionID, model, effectivePrompt)
|
||||
if err != nil {
|
||||
return nil, true, fmt.Errorf("model switch failed: %w", err)
|
||||
}
|
||||
if switchResult.StopReason == "model_switched_in_place" {
|
||||
// Agent is still running with the new model — let PromptTask send the prompt normally.
|
||||
// Invalidate the message creator's model cache so the next message picks up the new model.
|
||||
if s.messageCreator != nil {
|
||||
s.messageCreator.InvalidateModelCache(sessionID)
|
||||
}
|
||||
return nil, false, nil
|
||||
}
|
||||
s.startTurnForSession(ctx, sessionID)
|
||||
s.setSessionRunning(ctx, taskID, sessionID, session)
|
||||
return &PromptResult{
|
||||
StopReason: switchResult.StopReason,
|
||||
|
||||
@@ -218,6 +218,7 @@ func (m *mockMessageCreator) CreateThinkingMessageStreaming(context.Context, str
|
||||
func (m *mockMessageCreator) AppendThinkingMessage(context.Context, string, string) error {
|
||||
return nil
|
||||
}
|
||||
func (m *mockMessageCreator) InvalidateModelCache(string) {}
|
||||
|
||||
func TestRecordInitialMessage_DoesNotChangeSessionState(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
|
||||
@@ -59,6 +59,12 @@ func RegisterProcessRoutes(
|
||||
processes.POST("/:processId/stop", handlers.httpStopProcessByID)
|
||||
processes.GET("", handlers.httpListProcesses)
|
||||
processes.GET("/:processId", handlers.httpGetProcess)
|
||||
|
||||
// Session-level ACP operations (mode/model switching)
|
||||
session := api.Group("/task-sessions/:id")
|
||||
session.POST("/set-mode", handlers.httpSetSessionMode)
|
||||
session.POST("/set-model", handlers.httpSetSessionModel)
|
||||
session.POST("/authenticate", handlers.httpAuthenticate)
|
||||
}
|
||||
|
||||
type httpStartProcessRequest struct {
|
||||
@@ -470,3 +476,66 @@ func resolveScriptCommand(
|
||||
return "", "", "", fmt.Errorf("invalid script kind")
|
||||
}
|
||||
}
|
||||
|
||||
// httpSetSessionMode sets the session mode for a running agent.
|
||||
func (h *ProcessHandlers) httpSetSessionMode(c *gin.Context) {
|
||||
sessionID := c.Param("id")
|
||||
var req struct {
|
||||
ModeID string `json:"mode_id"`
|
||||
}
|
||||
if err := c.ShouldBindJSON(&req); err != nil {
|
||||
c.JSON(400, gin.H{"error": "invalid request: " + err.Error()})
|
||||
return
|
||||
}
|
||||
if err := h.lifecycleMgr.SetSessionModeBySessionID(c.Request.Context(), sessionID, req.ModeID); err != nil {
|
||||
h.logger.Error("failed to set session mode",
|
||||
zap.String("session_id", sessionID),
|
||||
zap.String("mode_id", req.ModeID),
|
||||
zap.Error(err))
|
||||
c.JSON(500, gin.H{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
c.JSON(200, gin.H{"ok": true})
|
||||
}
|
||||
|
||||
// httpSetSessionModel sets the session model for a running agent.
|
||||
func (h *ProcessHandlers) httpSetSessionModel(c *gin.Context) {
|
||||
sessionID := c.Param("id")
|
||||
var req struct {
|
||||
ModelID string `json:"model_id"`
|
||||
}
|
||||
if err := c.ShouldBindJSON(&req); err != nil {
|
||||
c.JSON(400, gin.H{"error": "invalid request: " + err.Error()})
|
||||
return
|
||||
}
|
||||
if err := h.lifecycleMgr.SetSessionModelBySessionID(c.Request.Context(), sessionID, req.ModelID); err != nil {
|
||||
h.logger.Error("failed to set session model",
|
||||
zap.String("session_id", sessionID),
|
||||
zap.String("model_id", req.ModelID),
|
||||
zap.Error(err))
|
||||
c.JSON(500, gin.H{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
c.JSON(200, gin.H{"ok": true})
|
||||
}
|
||||
|
||||
// httpAuthenticate triggers authentication for a given auth method on a running agent.
|
||||
func (h *ProcessHandlers) httpAuthenticate(c *gin.Context) {
|
||||
sessionID := c.Param("id")
|
||||
var req struct {
|
||||
MethodID string `json:"method_id"`
|
||||
}
|
||||
if err := c.ShouldBindJSON(&req); err != nil {
|
||||
c.JSON(400, gin.H{"error": "invalid request: " + err.Error()})
|
||||
return
|
||||
}
|
||||
if err := h.lifecycleMgr.AuthenticateBySessionID(c.Request.Context(), sessionID, req.MethodID); err != nil {
|
||||
h.logger.Error("failed to authenticate",
|
||||
zap.String("session_id", sessionID),
|
||||
zap.String("method_id", req.MethodID),
|
||||
zap.Error(err))
|
||||
c.JSON(500, gin.H{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
c.JSON(200, gin.H{"ok": true})
|
||||
}
|
||||
|
||||
@@ -116,6 +116,8 @@ const (
|
||||
MessageTypeThinking MessageType = "thinking"
|
||||
// MessageTypeAgentPlan is for agent native plan content (e.g. ExitPlanMode)
|
||||
MessageTypeAgentPlan MessageType = "agent_plan"
|
||||
// MessageTypeTodo is for agent todo/task list updates
|
||||
MessageTypeTodo MessageType = "todo"
|
||||
)
|
||||
|
||||
// Message represents a message in a task session
|
||||
|
||||
@@ -120,11 +120,14 @@ type TaskEvent struct {
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
}
|
||||
|
||||
// MessageAttachment represents an attachment (image, file, etc.) to a message
|
||||
// MessageAttachment represents an attachment (image, file, etc.) to a message.
|
||||
// Type determines the ACP content block: "image" → ImageBlock, "audio" → AudioBlock,
|
||||
// "resource" → ResourceBlock (text or blob based on MIME type).
|
||||
type MessageAttachment struct {
|
||||
Type string `json:"type"` // "image"
|
||||
Data string `json:"data"` // Base64-encoded data
|
||||
MimeType string `json:"mime_type"` // MIME type (e.g., "image/png")
|
||||
Type string `json:"type"` // "image", "audio", "resource"
|
||||
Data string `json:"data,omitempty"` // Base64-encoded data
|
||||
MimeType string `json:"mime_type,omitempty"` // MIME type (e.g., "image/png")
|
||||
Name string `json:"name,omitempty"` // Display name (e.g., filename)
|
||||
}
|
||||
|
||||
// ContextFileMeta represents a context file reference attached to a message
|
||||
|
||||
@@ -167,6 +167,11 @@ const (
|
||||
ActionSessionTurnCompleted = "session.turn.completed"
|
||||
ActionSessionAvailableCommands = "session.available_commands"
|
||||
ActionSessionModeChanged = "session.mode_changed"
|
||||
ActionSessionAgentCapabilities = "session.agent_capabilities"
|
||||
ActionSessionModelsUpdated = "session.models_updated"
|
||||
ActionSessionSetMode = "session.set_mode"
|
||||
ActionSessionTodosUpdated = "session.todos_updated"
|
||||
ActionSessionPromptUsage = "session.prompt_usage"
|
||||
ActionInputRequested = "input.requested"
|
||||
ActionRepositoryCreated = "repository.created"
|
||||
ActionRepositoryUpdated = "repository.updated"
|
||||
|
||||
@@ -35,6 +35,59 @@ interface ComboboxProps {
|
||||
triggerClassName?: string;
|
||||
showSearch?: boolean;
|
||||
testId?: string;
|
||||
popoverSide?: "top" | "right" | "bottom" | "left";
|
||||
popoverAlign?: "start" | "center" | "end";
|
||||
/** When true, the trigger always renders the plain label text instead of renderLabel. */
|
||||
plainTrigger?: boolean;
|
||||
}
|
||||
|
||||
function TriggerLabel({
|
||||
selectedOption,
|
||||
plainTrigger,
|
||||
placeholder,
|
||||
}: {
|
||||
selectedOption: ComboboxOption | undefined;
|
||||
plainTrigger: boolean;
|
||||
placeholder: string;
|
||||
}) {
|
||||
if (!plainTrigger && selectedOption?.renderLabel) {
|
||||
return selectedOption.renderLabel();
|
||||
}
|
||||
return <span className="truncate">{selectedOption?.label || placeholder}</span>;
|
||||
}
|
||||
|
||||
function OptionsList({
|
||||
options,
|
||||
value,
|
||||
onSelect,
|
||||
}: {
|
||||
options: ComboboxOption[];
|
||||
value: string;
|
||||
onSelect: (value: string) => void;
|
||||
}) {
|
||||
return (
|
||||
<CommandGroup>
|
||||
{options.map((option) => (
|
||||
<CommandItem
|
||||
key={option.value}
|
||||
value={option.value}
|
||||
keywords={[option.label, option.description ?? ""]}
|
||||
onSelect={() => onSelect(option.value)}
|
||||
className="relative pr-7"
|
||||
>
|
||||
<div className="flex min-w-0 flex-1 items-center">
|
||||
{option.renderLabel ? option.renderLabel() : option.label}
|
||||
</div>
|
||||
<IconCheck
|
||||
className={cn(
|
||||
"absolute right-2 h-4 w-4",
|
||||
value === option.value ? "opacity-100" : "opacity-0",
|
||||
)}
|
||||
/>
|
||||
</CommandItem>
|
||||
))}
|
||||
</CommandGroup>
|
||||
);
|
||||
}
|
||||
|
||||
export const Combobox = memo(function Combobox({
|
||||
@@ -50,6 +103,9 @@ export const Combobox = memo(function Combobox({
|
||||
triggerClassName,
|
||||
showSearch = true,
|
||||
testId,
|
||||
popoverSide,
|
||||
popoverAlign = "start",
|
||||
plainTrigger = false,
|
||||
}: ComboboxProps) {
|
||||
const [open, setOpen] = useState(false);
|
||||
// Track the highlighted item. Defaults to the selected value so the current
|
||||
@@ -76,11 +132,11 @@ export const Combobox = memo(function Combobox({
|
||||
data-testid={testId}
|
||||
>
|
||||
<div className="flex min-w-0 flex-1 items-center">
|
||||
{selectedOption?.renderLabel ? (
|
||||
selectedOption.renderLabel()
|
||||
) : (
|
||||
<span className="truncate">{selectedOption?.label || placeholder}</span>
|
||||
)}
|
||||
<TriggerLabel
|
||||
selectedOption={selectedOption}
|
||||
plainTrigger={plainTrigger}
|
||||
placeholder={placeholder}
|
||||
/>
|
||||
</div>
|
||||
<IconChevronDown className="ml-2 h-4 w-4 shrink-0 opacity-50" />
|
||||
</Button>
|
||||
@@ -91,7 +147,8 @@ export const Combobox = memo(function Combobox({
|
||||
"w-[var(--radix-popover-trigger-width)] min-w-[300px] max-w-none p-0 max-h-[var(--radix-popover-content-available-height)]",
|
||||
className,
|
||||
)}
|
||||
align="start"
|
||||
side={popoverSide}
|
||||
align={popoverAlign}
|
||||
>
|
||||
<Command value={highlighted} onValueChange={setHighlighted}>
|
||||
{dropdownLabel ? (
|
||||
@@ -102,29 +159,14 @@ export const Combobox = memo(function Combobox({
|
||||
{showSearch && <CommandInput placeholder={searchPlaceholder} className="h-9" />}
|
||||
<CommandList>
|
||||
<CommandEmpty>{emptyMessage}</CommandEmpty>
|
||||
<CommandGroup>
|
||||
{options.map((option) => (
|
||||
<CommandItem
|
||||
key={option.value}
|
||||
value={option.value}
|
||||
onSelect={() => {
|
||||
onValueChange(option.value === value ? "" : option.value);
|
||||
setOpen(false);
|
||||
}}
|
||||
className="relative pr-7"
|
||||
>
|
||||
<div className="flex min-w-0 flex-1 items-center">
|
||||
{option.renderLabel ? option.renderLabel() : option.label}
|
||||
</div>
|
||||
<IconCheck
|
||||
className={cn(
|
||||
"absolute right-2 h-4 w-4",
|
||||
value === option.value ? "opacity-100" : "opacity-0",
|
||||
)}
|
||||
/>
|
||||
</CommandItem>
|
||||
))}
|
||||
</CommandGroup>
|
||||
<OptionsList
|
||||
options={options}
|
||||
value={value}
|
||||
onSelect={(v) => {
|
||||
onValueChange(v === value ? "" : v);
|
||||
setOpen(false);
|
||||
}}
|
||||
/>
|
||||
</CommandList>
|
||||
</Command>
|
||||
</PopoverContent>
|
||||
|
||||
@@ -0,0 +1,82 @@
|
||||
"use client";
|
||||
|
||||
import { memo, useCallback } from "react";
|
||||
import { IconKey, IconTerminal2 } from "@tabler/icons-react";
|
||||
import { Button } from "@kandev/ui/button";
|
||||
import { Popover, PopoverContent, PopoverTrigger } from "@kandev/ui/popover";
|
||||
import { useAppStore } from "@/components/state-provider";
|
||||
import { authenticateSession } from "@/lib/api/domains/session-api";
|
||||
|
||||
type AuthMethodsIndicatorProps = {
|
||||
sessionId: string | null;
|
||||
};
|
||||
|
||||
export const AuthMethodsIndicator = memo(function AuthMethodsIndicator({
|
||||
sessionId,
|
||||
}: AuthMethodsIndicatorProps) {
|
||||
const authMethods = useAppStore((state) => {
|
||||
if (!sessionId) return undefined;
|
||||
return state.agentCapabilities.bySessionId[sessionId]?.authMethods;
|
||||
});
|
||||
|
||||
const handleAuthenticate = useCallback(
|
||||
async (methodId: string) => {
|
||||
if (!sessionId) return;
|
||||
try {
|
||||
await authenticateSession(sessionId, methodId);
|
||||
} catch {
|
||||
// Auth call failed — agent will report via events if successful
|
||||
}
|
||||
},
|
||||
[sessionId],
|
||||
);
|
||||
|
||||
if (!sessionId || !authMethods || authMethods.length === 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return (
|
||||
<Popover>
|
||||
<PopoverTrigger asChild>
|
||||
<Button
|
||||
variant="ghost"
|
||||
size="sm"
|
||||
className="h-7 gap-1 px-2 cursor-pointer hover:bg-muted/40"
|
||||
>
|
||||
<IconKey className="h-3.5 w-3.5 text-muted-foreground" />
|
||||
</Button>
|
||||
</PopoverTrigger>
|
||||
<PopoverContent align="end" side="top" className="w-72 p-3">
|
||||
<div className="space-y-2">
|
||||
<div className="text-xs font-medium text-muted-foreground">Authentication</div>
|
||||
{authMethods.map((method) => (
|
||||
<div key={method.id} className="space-y-1">
|
||||
<div className="text-sm">{method.name}</div>
|
||||
{method.description && (
|
||||
<div className="text-xs text-muted-foreground">{method.description}</div>
|
||||
)}
|
||||
{method.terminalAuth ? (
|
||||
<div className="flex items-center gap-1.5 text-xs text-muted-foreground bg-muted/50 rounded px-2 py-1">
|
||||
<IconTerminal2 className="h-3 w-3 shrink-0" />
|
||||
<code className="text-[11px]">
|
||||
{method.terminalAuth.command}
|
||||
{method.terminalAuth.args ? ` ${method.terminalAuth.args.join(" ")}` : ""}
|
||||
</code>
|
||||
</div>
|
||||
) : (
|
||||
<Button
|
||||
variant="outline"
|
||||
size="sm"
|
||||
className="h-6 text-xs cursor-pointer"
|
||||
onClick={() => handleAuthenticate(method.id)}
|
||||
>
|
||||
Login
|
||||
</Button>
|
||||
)}
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
</PopoverContent>
|
||||
</Popover>
|
||||
);
|
||||
});
|
||||
@@ -2,6 +2,7 @@
|
||||
|
||||
import { useCallback, useState } from "react";
|
||||
import { IconBrain, IconGitMerge, IconX } from "@tabler/icons-react";
|
||||
import { TodoIndicator } from "./todo-indicator";
|
||||
import { getWebSocketClient } from "@/lib/ws/connection";
|
||||
import { useKeyboardShortcut } from "@/hooks/use-keyboard-shortcut";
|
||||
import { SHORTCUTS } from "@/lib/keyboard/constants";
|
||||
@@ -292,15 +293,32 @@ function PRMergedBanner({ taskId }: { taskId: string }) {
|
||||
);
|
||||
}
|
||||
|
||||
type TodoDisplayItem = {
|
||||
text: string;
|
||||
done?: boolean;
|
||||
status?: "pending" | "in_progress" | "completed" | "failed";
|
||||
};
|
||||
|
||||
function SessionStatusBar({ todoItems }: { todoItems: TodoDisplayItem[] }) {
|
||||
const showTodos = todoItems.length > 0;
|
||||
if (!showTodos) return null;
|
||||
return (
|
||||
<div className="flex items-center gap-1.5 px-3 py-1 text-xs text-muted-foreground">
|
||||
<TodoIndicator todos={todoItems} />
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
function AgentModeIndicator({ sessionId }: { sessionId: string | null }) {
|
||||
const agentMode = useAppStore((state) =>
|
||||
const modeState = useAppStore((state) =>
|
||||
sessionId ? state.sessionMode.bySessionId[sessionId] : undefined,
|
||||
);
|
||||
if (!agentMode || agentMode === "default") return null;
|
||||
const modeId = modeState?.currentModeId;
|
||||
if (!modeId || modeId === "default") return null;
|
||||
return (
|
||||
<div className="flex items-center gap-1.5 px-3 py-1 text-xs text-muted-foreground">
|
||||
<IconBrain className="h-3 w-3" />
|
||||
<span className="capitalize">{agentMode} mode</span>
|
||||
<span className="capitalize">{modeId} mode</span>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -374,6 +392,7 @@ export function ChatInputArea({
|
||||
);
|
||||
return (
|
||||
<div className="bg-card flex-shrink-0 px-2 pb-2 pt-1">
|
||||
<SessionStatusBar todoItems={todoItems} />
|
||||
<AgentModeIndicator sessionId={resolvedSessionId} />
|
||||
{taskId && <PRMergedBanner key={taskId} taskId={taskId} />}
|
||||
<ChatInputContainer
|
||||
@@ -410,7 +429,6 @@ export function ChatInputArea({
|
||||
contextFiles={contextFiles}
|
||||
onToggleContextFile={handleToggleContextFile}
|
||||
onAddContextFile={handleAddContextFile}
|
||||
todoItems={todoItems}
|
||||
onImplementPlan={handleImplementPlan}
|
||||
hideSessionsDropdown={hideSessionsDropdown}
|
||||
/>
|
||||
|
||||
@@ -1,18 +1,16 @@
|
||||
"use client";
|
||||
|
||||
import { useState, useCallback } from "react";
|
||||
import { Tooltip, TooltipContent, TooltipTrigger } from "@kandev/ui/tooltip";
|
||||
import { cn } from "@/lib/utils";
|
||||
import { TipTapInput } from "./tiptap-input";
|
||||
import { ChatInputFocusHint } from "./chat-input-focus-hint";
|
||||
import { ResizeHandle } from "./resize-handle";
|
||||
import { TodoSummary } from "./todo-summary";
|
||||
import { ChatInputToolbar } from "./chat-input-toolbar";
|
||||
import { ContextZone } from "./context-items/context-zone";
|
||||
import type { ContextItem } from "@/lib/types/context";
|
||||
import type { ContextFile } from "@/lib/state/context-files-store";
|
||||
|
||||
type TodoItem = { text: string; done?: boolean };
|
||||
|
||||
export type ChatInputEditorAreaProps = {
|
||||
inputRef: React.RefObject<import("./tiptap-input").TipTapInputHandle | null>;
|
||||
value: string;
|
||||
@@ -32,7 +30,8 @@ export type ChatInputEditorAreaProps = {
|
||||
onToggleContextFile?: (file: ContextFile) => void;
|
||||
planContextEnabled: boolean;
|
||||
handleAgentCommand: (command: string) => void;
|
||||
handleImagePaste: (files: File[]) => Promise<void>;
|
||||
addFiles: (files: File[]) => Promise<void>;
|
||||
fileInputRef: React.RefObject<HTMLInputElement | null>;
|
||||
showRequestChangesTooltip: boolean;
|
||||
hideSessionsDropdown?: boolean;
|
||||
isAgentBusy: boolean;
|
||||
@@ -50,71 +49,163 @@ export type ChatInputEditorAreaProps = {
|
||||
isEnhancingPrompt?: boolean;
|
||||
};
|
||||
|
||||
export function ChatInputEditorArea({ inputRef, ...p }: ChatInputEditorAreaProps) {
|
||||
const wrappedSubmit = p.isEnhancingPrompt ? () => {} : p.handleSubmitWithReset;
|
||||
const inputDisabled = p.isDisabled || p.hasClarification;
|
||||
function EditorWithTooltip({
|
||||
showTooltip,
|
||||
isEnhancingPrompt,
|
||||
children,
|
||||
}: {
|
||||
showTooltip: boolean;
|
||||
isEnhancingPrompt?: boolean;
|
||||
children: React.ReactNode;
|
||||
}) {
|
||||
return (
|
||||
<Tooltip open={showTooltip}>
|
||||
<TooltipTrigger asChild>
|
||||
<div
|
||||
className={cn(
|
||||
"flex-1 min-h-0 transition-opacity",
|
||||
isEnhancingPrompt && "opacity-50 pointer-events-none",
|
||||
)}
|
||||
>
|
||||
{children}
|
||||
</div>
|
||||
</TooltipTrigger>
|
||||
<TooltipContent side="top" className="bg-orange-600 text-white border-orange-700">
|
||||
<p className="font-medium">Write your changes here</p>
|
||||
</TooltipContent>
|
||||
</Tooltip>
|
||||
);
|
||||
}
|
||||
|
||||
function FileInput({
|
||||
fileInputRef,
|
||||
addFiles,
|
||||
}: {
|
||||
fileInputRef: React.RefObject<HTMLInputElement | null>;
|
||||
addFiles: (files: File[]) => Promise<void>;
|
||||
}) {
|
||||
const handleChange = useCallback(
|
||||
(e: React.ChangeEvent<HTMLInputElement>) => {
|
||||
const files = e.target.files;
|
||||
if (files && files.length > 0) {
|
||||
void addFiles(Array.from(files));
|
||||
}
|
||||
// Reset so re-selecting the same file triggers onChange
|
||||
e.target.value = "";
|
||||
},
|
||||
[addFiles],
|
||||
);
|
||||
|
||||
return (
|
||||
<input
|
||||
ref={fileInputRef}
|
||||
type="file"
|
||||
multiple
|
||||
className="hidden"
|
||||
onChange={handleChange}
|
||||
tabIndex={-1}
|
||||
/>
|
||||
);
|
||||
}
|
||||
|
||||
export function ChatInputEditorArea({
|
||||
inputRef,
|
||||
value,
|
||||
handleChange,
|
||||
handleSubmitWithReset,
|
||||
inputPlaceholder,
|
||||
isDisabled,
|
||||
hasClarification,
|
||||
planModeEnabled,
|
||||
planModeAvailable,
|
||||
mcpServers,
|
||||
submitKey,
|
||||
setIsInputFocused,
|
||||
sessionId,
|
||||
taskId,
|
||||
onAddContextFile,
|
||||
onToggleContextFile,
|
||||
planContextEnabled,
|
||||
handleAgentCommand,
|
||||
addFiles,
|
||||
fileInputRef,
|
||||
showRequestChangesTooltip,
|
||||
isAgentBusy,
|
||||
onPlanModeChange,
|
||||
taskTitle,
|
||||
taskDescription,
|
||||
isSending,
|
||||
onCancel,
|
||||
contextCount,
|
||||
contextPopoverOpen,
|
||||
setContextPopoverOpen,
|
||||
contextFiles,
|
||||
onImplementPlan,
|
||||
onEnhancePrompt,
|
||||
isEnhancingPrompt,
|
||||
hideSessionsDropdown,
|
||||
}: ChatInputEditorAreaProps) {
|
||||
// Block submit while enhancing prompt, but keep editor editable for programmatic updates
|
||||
const wrappedSubmit = isEnhancingPrompt ? () => {} : handleSubmitWithReset;
|
||||
|
||||
const handleAttachFiles = useCallback(() => {
|
||||
fileInputRef.current?.click();
|
||||
}, [fileInputRef]);
|
||||
|
||||
return (
|
||||
<div className="flex flex-col flex-1 min-h-0 overflow-hidden">
|
||||
<Tooltip open={p.showRequestChangesTooltip}>
|
||||
<TooltipTrigger asChild>
|
||||
<div
|
||||
className={cn(
|
||||
"flex-1 min-h-0 transition-opacity",
|
||||
p.isEnhancingPrompt && "opacity-50 pointer-events-none",
|
||||
)}
|
||||
>
|
||||
<TipTapInput
|
||||
ref={inputRef}
|
||||
value={p.value}
|
||||
onChange={p.handleChange}
|
||||
onSubmit={wrappedSubmit}
|
||||
placeholder={p.inputPlaceholder}
|
||||
disabled={inputDisabled}
|
||||
planModeEnabled={p.planModeEnabled}
|
||||
submitKey={p.submitKey}
|
||||
onFocus={() => p.setIsInputFocused(true)}
|
||||
onBlur={() => p.setIsInputFocused(false)}
|
||||
sessionId={p.sessionId}
|
||||
taskId={p.taskId}
|
||||
onAddContextFile={p.onAddContextFile}
|
||||
onToggleContextFile={p.onToggleContextFile}
|
||||
planContextEnabled={p.planContextEnabled}
|
||||
onAgentCommand={p.handleAgentCommand}
|
||||
onImagePaste={p.handleImagePaste}
|
||||
onPlanModeChange={p.onPlanModeChange}
|
||||
/>
|
||||
</div>
|
||||
</TooltipTrigger>
|
||||
<TooltipContent side="top" className="bg-orange-600 text-white border-orange-700">
|
||||
<p className="font-medium">Write your changes here</p>
|
||||
</TooltipContent>
|
||||
</Tooltip>
|
||||
<EditorWithTooltip
|
||||
showTooltip={showRequestChangesTooltip}
|
||||
isEnhancingPrompt={isEnhancingPrompt}
|
||||
>
|
||||
<TipTapInput
|
||||
ref={inputRef}
|
||||
value={value}
|
||||
onChange={handleChange}
|
||||
onSubmit={wrappedSubmit}
|
||||
placeholder={inputPlaceholder}
|
||||
disabled={isDisabled || hasClarification}
|
||||
planModeEnabled={planModeEnabled}
|
||||
submitKey={submitKey}
|
||||
onFocus={() => setIsInputFocused(true)}
|
||||
onBlur={() => setIsInputFocused(false)}
|
||||
sessionId={sessionId}
|
||||
taskId={taskId}
|
||||
onAddContextFile={onAddContextFile}
|
||||
onToggleContextFile={onToggleContextFile}
|
||||
planContextEnabled={planContextEnabled}
|
||||
onAgentCommand={handleAgentCommand}
|
||||
onImagePaste={addFiles}
|
||||
onPlanModeChange={onPlanModeChange}
|
||||
/>
|
||||
</EditorWithTooltip>
|
||||
<FileInput fileInputRef={fileInputRef} addFiles={addFiles} />
|
||||
<ChatInputToolbar
|
||||
planModeEnabled={p.planModeEnabled}
|
||||
planModeAvailable={p.planModeAvailable}
|
||||
mcpServers={p.mcpServers}
|
||||
onPlanModeChange={p.onPlanModeChange}
|
||||
sessionId={p.sessionId}
|
||||
taskId={p.taskId}
|
||||
taskTitle={p.taskTitle}
|
||||
taskDescription={p.taskDescription}
|
||||
isAgentBusy={p.isAgentBusy}
|
||||
isDisabled={p.isDisabled}
|
||||
isSending={p.isSending}
|
||||
onCancel={p.onCancel}
|
||||
planModeEnabled={planModeEnabled}
|
||||
planModeAvailable={planModeAvailable}
|
||||
mcpServers={mcpServers}
|
||||
onPlanModeChange={onPlanModeChange}
|
||||
sessionId={sessionId}
|
||||
taskId={taskId}
|
||||
taskTitle={taskTitle}
|
||||
taskDescription={taskDescription}
|
||||
isAgentBusy={isAgentBusy}
|
||||
isDisabled={isDisabled}
|
||||
isSending={isSending}
|
||||
onCancel={onCancel}
|
||||
onSubmit={wrappedSubmit}
|
||||
submitKey={p.submitKey}
|
||||
contextCount={p.contextCount}
|
||||
contextPopoverOpen={p.contextPopoverOpen}
|
||||
onContextPopoverOpenChange={p.setContextPopoverOpen}
|
||||
planContextEnabled={p.planContextEnabled}
|
||||
contextFiles={p.contextFiles}
|
||||
onToggleFile={p.onToggleContextFile}
|
||||
onImplementPlan={p.onImplementPlan}
|
||||
onEnhancePrompt={p.onEnhancePrompt}
|
||||
isEnhancingPrompt={p.isEnhancingPrompt}
|
||||
hideSessionsDropdown={p.hideSessionsDropdown}
|
||||
submitKey={submitKey}
|
||||
contextCount={contextCount}
|
||||
contextPopoverOpen={contextPopoverOpen}
|
||||
onContextPopoverOpenChange={setContextPopoverOpen}
|
||||
planContextEnabled={planContextEnabled}
|
||||
contextFiles={contextFiles}
|
||||
onToggleFile={onToggleContextFile}
|
||||
onImplementPlan={onImplementPlan}
|
||||
onEnhancePrompt={onEnhancePrompt}
|
||||
isEnhancingPrompt={isEnhancingPrompt}
|
||||
onAttachFiles={handleAttachFiles}
|
||||
hideSessionsDropdown={hideSessionsDropdown}
|
||||
/>
|
||||
</div>
|
||||
);
|
||||
@@ -124,20 +215,15 @@ export type ChatInputContextAreaProps = {
|
||||
hasContextZone: boolean;
|
||||
allItems: ContextItem[];
|
||||
sessionId: string | null;
|
||||
hasTodos: boolean;
|
||||
todoItems: TodoItem[];
|
||||
};
|
||||
|
||||
export function ChatInputContextArea({
|
||||
hasContextZone,
|
||||
allItems,
|
||||
sessionId,
|
||||
hasTodos,
|
||||
todoItems,
|
||||
}: ChatInputContextAreaProps) {
|
||||
if (!hasContextZone) return null;
|
||||
const todoSlot = hasTodos ? <TodoSummary todos={todoItems} /> : undefined;
|
||||
return <ContextZone items={allItems} sessionId={sessionId} todoSlot={todoSlot} />;
|
||||
return <ContextZone items={allItems} sessionId={sessionId} />;
|
||||
}
|
||||
|
||||
export type ChatInputBodyProps = {
|
||||
@@ -152,6 +238,7 @@ export type ChatInputBodyProps = {
|
||||
planModeEnabled: boolean;
|
||||
showFocusHint: boolean;
|
||||
needsRecovery: boolean;
|
||||
addFiles: (files: File[]) => Promise<void>;
|
||||
contextAreaProps: ChatInputContextAreaProps;
|
||||
editorAreaProps: ChatInputEditorAreaProps;
|
||||
};
|
||||
@@ -168,9 +255,54 @@ export function ChatInputBody({
|
||||
planModeEnabled,
|
||||
showFocusHint,
|
||||
needsRecovery,
|
||||
addFiles,
|
||||
contextAreaProps,
|
||||
editorAreaProps,
|
||||
}: ChatInputBodyProps) {
|
||||
const [isDragging, setIsDragging] = useState(false);
|
||||
|
||||
const handleDragOver = useCallback((e: React.DragEvent) => {
|
||||
e.preventDefault();
|
||||
e.stopPropagation();
|
||||
}, []);
|
||||
|
||||
const handleDragEnter = useCallback((e: React.DragEvent) => {
|
||||
e.preventDefault();
|
||||
e.stopPropagation();
|
||||
if (e.dataTransfer.types.includes("Files")) {
|
||||
setIsDragging(true);
|
||||
}
|
||||
}, []);
|
||||
|
||||
const handleDragLeave = useCallback((e: React.DragEvent) => {
|
||||
e.preventDefault();
|
||||
e.stopPropagation();
|
||||
// Only set false when leaving the container (not entering a child)
|
||||
const rect = e.currentTarget.getBoundingClientRect();
|
||||
const { clientX, clientY } = e;
|
||||
if (
|
||||
clientX <= rect.left ||
|
||||
clientX >= rect.right ||
|
||||
clientY <= rect.top ||
|
||||
clientY >= rect.bottom
|
||||
) {
|
||||
setIsDragging(false);
|
||||
}
|
||||
}, []);
|
||||
|
||||
const handleDrop = useCallback(
|
||||
(e: React.DragEvent) => {
|
||||
e.preventDefault();
|
||||
e.stopPropagation();
|
||||
setIsDragging(false);
|
||||
const files = Array.from(e.dataTransfer.files).filter((f) => f.size > 0 || f.type !== "");
|
||||
if (files.length > 0) {
|
||||
void addFiles(files);
|
||||
}
|
||||
},
|
||||
[addFiles],
|
||||
);
|
||||
|
||||
return (
|
||||
<div className="relative">
|
||||
<ResizeHandle
|
||||
@@ -192,8 +324,13 @@ export function ChatInputBody({
|
||||
hasClarification && "border-sky-400/50",
|
||||
showRequestChangesTooltip && "animate-pulse border-orange-500",
|
||||
hasPendingComments && "border-amber-500/50",
|
||||
isDragging && "border-primary ring-1 ring-primary/30",
|
||||
)}
|
||||
style={{ height }}
|
||||
onDragOver={handleDragOver}
|
||||
onDragEnter={handleDragEnter}
|
||||
onDragLeave={handleDragLeave}
|
||||
onDrop={handleDrop}
|
||||
>
|
||||
<ChatInputFocusHint visible={showFocusHint} />
|
||||
<ChatInputContextArea {...contextAreaProps} />
|
||||
|
||||
@@ -22,9 +22,10 @@ export type { ImageAttachment } from "./image-attachment-preview";
|
||||
|
||||
// Type for message attachments sent to backend
|
||||
export type MessageAttachment = {
|
||||
type: "image";
|
||||
type: "image" | "audio" | "resource";
|
||||
data: string;
|
||||
mime_type: string;
|
||||
name?: string;
|
||||
};
|
||||
|
||||
export type ChatInputContainerHandle = {
|
||||
@@ -36,8 +37,6 @@ export type ChatInputContainerHandle = {
|
||||
clear: () => void;
|
||||
};
|
||||
|
||||
type TodoItem = { text: string; done?: boolean };
|
||||
|
||||
type ChatInputContainerProps = {
|
||||
onSubmit: (
|
||||
message: string,
|
||||
@@ -73,7 +72,6 @@ type ChatInputContainerProps = {
|
||||
contextFiles?: ContextFile[];
|
||||
onToggleContextFile?: (file: ContextFile) => void;
|
||||
onAddContextFile?: (file: ContextFile) => void;
|
||||
todoItems?: TodoItem[];
|
||||
onImplementPlan?: () => void;
|
||||
hideSessionsDropdown?: boolean;
|
||||
};
|
||||
@@ -135,8 +133,6 @@ function buildContextAreaProps(
|
||||
hasContextZone: s.hasContextZone,
|
||||
allItems: s.allItems,
|
||||
sessionId: p.sessionId,
|
||||
hasTodos: s.hasTodos,
|
||||
todoItems: p.todoItems ?? [],
|
||||
};
|
||||
}
|
||||
|
||||
@@ -169,7 +165,8 @@ function buildEditorAreaProps(
|
||||
onToggleContextFile: p.onToggleContextFile,
|
||||
planContextEnabled: p.planContextEnabled ?? false,
|
||||
handleAgentCommand: s.handleAgentCommand,
|
||||
handleImagePaste: s.handleImagePaste,
|
||||
addFiles: s.addFiles,
|
||||
fileInputRef: s.fileInputRef,
|
||||
showRequestChangesTooltip: p.showRequestChangesTooltip ?? false,
|
||||
isAgentBusy: p.isAgentBusy,
|
||||
onPlanModeChange: p.onPlanModeChange,
|
||||
@@ -210,7 +207,6 @@ export const ChatInputContainer = forwardRef<ChatInputContainerHandle, ChatInput
|
||||
planContextEnabled: props.planContextEnabled ?? false,
|
||||
contextFiles: props.contextFiles ?? [],
|
||||
contextItems: props.contextItems ?? [],
|
||||
todoItems: props.todoItems ?? [],
|
||||
showRequestChangesTooltip,
|
||||
} as const;
|
||||
|
||||
@@ -229,7 +225,6 @@ export const ChatInputContainer = forwardRef<ChatInputContainerHandle, ChatInput
|
||||
onClarificationResolved: props.onClarificationResolved,
|
||||
pendingCommentsByFile: props.pendingCommentsByFile,
|
||||
hasContextComments: props.hasContextComments ?? false,
|
||||
todoItems: p.todoItems,
|
||||
showRequestChangesTooltip,
|
||||
onRequestChangesTooltipDismiss: props.onRequestChangesTooltipDismiss,
|
||||
onSubmit: props.onSubmit,
|
||||
@@ -276,6 +271,7 @@ export const ChatInputContainer = forwardRef<ChatInputContainerHandle, ChatInput
|
||||
planModeEnabled={props.planModeEnabled}
|
||||
showFocusHint={s.showFocusHint}
|
||||
needsRecovery={props.needsRecovery ?? false}
|
||||
addFiles={s.addFiles}
|
||||
contextAreaProps={buildContextAreaProps(s, p)}
|
||||
editorAreaProps={buildEditorAreaProps(
|
||||
s,
|
||||
|
||||
@@ -8,6 +8,7 @@ import {
|
||||
IconAt,
|
||||
IconPlugConnected,
|
||||
IconPlugConnectedX,
|
||||
IconPaperclip,
|
||||
IconRocket,
|
||||
IconRotateClockwise2,
|
||||
IconSparkles,
|
||||
@@ -32,6 +33,8 @@ import { KeyboardShortcutTooltip } from "@/components/keyboard-shortcut-tooltip"
|
||||
import { TokenUsageDisplay } from "@/components/task/chat/token-usage-display";
|
||||
import { SessionsDropdown } from "@/components/task/sessions-dropdown";
|
||||
import { ModelSelector } from "@/components/task/model-selector";
|
||||
import { ModeSelector } from "@/components/task/mode-selector";
|
||||
import { ConfigOptionsDisplay } from "@/components/task/config-options-display";
|
||||
import { ContextPopover } from "./context-popover";
|
||||
import type { ContextFile } from "@/lib/state/context-files-store";
|
||||
|
||||
@@ -62,6 +65,8 @@ export type ChatInputToolbarProps = {
|
||||
onEnhancePrompt?: () => void;
|
||||
/** Whether prompt enhancement is in progress */
|
||||
isEnhancingPrompt?: boolean;
|
||||
/** Callback to open file picker for attaching files */
|
||||
onAttachFiles?: () => void;
|
||||
/** Hide the sessions dropdown (for quick chat) */
|
||||
hideSessionsDropdown?: boolean;
|
||||
};
|
||||
@@ -339,7 +344,10 @@ function ToolbarRightSection({
|
||||
/>
|
||||
)}
|
||||
<TokenUsageDisplay sessionId={sessionId} />
|
||||
<ModeSelector sessionId={sessionId} />
|
||||
<ModelSelector sessionId={sessionId} />
|
||||
<ConfigOptionsDisplay sessionId={sessionId} />
|
||||
{/* AuthMethodsIndicator hidden — UX needs rethinking */}
|
||||
{showEnhance && (
|
||||
<EnhancePromptButton onClick={onEnhancePrompt} isLoading={isEnhancingPrompt ?? false} />
|
||||
)}
|
||||
@@ -383,6 +391,7 @@ export const ChatInputToolbar = memo(function ChatInputToolbar({
|
||||
onImplementPlan,
|
||||
onEnhancePrompt,
|
||||
isEnhancingPrompt = false,
|
||||
onAttachFiles,
|
||||
hideSessionsDropdown,
|
||||
}: ChatInputToolbarProps) {
|
||||
const submitShortcut = submitKey === "enter" ? SHORTCUTS.SUBMIT_ENTER : SHORTCUTS.SUBMIT;
|
||||
@@ -398,6 +407,23 @@ export const ChatInputToolbar = memo(function ChatInputToolbar({
|
||||
|
||||
<McpIndicator mcpServers={mcpServers} />
|
||||
|
||||
{onAttachFiles && (
|
||||
<Tooltip>
|
||||
<TooltipTrigger asChild>
|
||||
<Button
|
||||
type="button"
|
||||
variant="ghost"
|
||||
size="sm"
|
||||
className="h-7 gap-1.5 px-2 cursor-pointer hover:bg-muted/40"
|
||||
onClick={onAttachFiles}
|
||||
>
|
||||
<IconPaperclip className="h-4 w-4" />
|
||||
</Button>
|
||||
</TooltipTrigger>
|
||||
<TooltipContent>Attach files</TooltipContent>
|
||||
</Tooltip>
|
||||
)}
|
||||
|
||||
<ContextPopover
|
||||
open={contextPopoverOpen}
|
||||
onOpenChange={onContextPopoverOpenChange ?? (() => {})}
|
||||
|
||||
@@ -21,6 +21,7 @@ const ICON_BY_KIND: Record<ContextItemKind, TablerIcon> = {
|
||||
comment: IconMessageDots,
|
||||
"plan-comment": IconMessageDots,
|
||||
image: IconPhoto,
|
||||
"file-attachment": IconFile,
|
||||
prompt: IconAt,
|
||||
"pr-feedback": IconGitPullRequest,
|
||||
};
|
||||
|
||||
@@ -7,6 +7,7 @@ import { PromptItem } from "./prompt-item";
|
||||
import { CommentItem } from "./comment-item";
|
||||
import { PlanCommentItem } from "./plan-comment-item";
|
||||
import { ImageItem } from "./image-item";
|
||||
import { FileAttachmentItem } from "./file-attachment-item";
|
||||
import { PRFeedbackItem } from "./pr-feedback-item";
|
||||
|
||||
export function ContextItemRenderer({
|
||||
@@ -29,6 +30,8 @@ export function ContextItemRenderer({
|
||||
return <PlanCommentItem item={item} />;
|
||||
case "image":
|
||||
return <ImageItem item={item} />;
|
||||
case "file-attachment":
|
||||
return <FileAttachmentItem item={item} />;
|
||||
case "pr-feedback":
|
||||
return <PRFeedbackItem item={item} />;
|
||||
}
|
||||
|
||||
@@ -1,30 +1,24 @@
|
||||
"use client";
|
||||
|
||||
import type { ReactNode } from "react";
|
||||
import type { ContextItem } from "@/lib/types/context";
|
||||
import { ContextItemRenderer } from "./context-item-renderer";
|
||||
|
||||
type ContextZoneProps = {
|
||||
items: ContextItem[];
|
||||
sessionId?: string | null;
|
||||
todoSlot?: ReactNode;
|
||||
};
|
||||
|
||||
export function ContextZone({ items, sessionId, todoSlot }: ContextZoneProps) {
|
||||
const hasContent = !!todoSlot || items.length > 0;
|
||||
if (!hasContent) return null;
|
||||
export function ContextZone({ items, sessionId }: ContextZoneProps) {
|
||||
if (items.length === 0) return null;
|
||||
|
||||
return (
|
||||
<div className="overflow-y-auto max-h-[40%] border-b border-border/50 shrink-0">
|
||||
<div className="px-2 pt-2 pb-1 space-y-1.5">
|
||||
{todoSlot}
|
||||
{items.length > 0 && (
|
||||
<div className="flex items-center gap-1 flex-wrap px-0 py-0.5">
|
||||
{items.map((item) => (
|
||||
<ContextItemRenderer key={item.id} item={item} sessionId={sessionId} />
|
||||
))}
|
||||
</div>
|
||||
)}
|
||||
<div className="flex items-center gap-1 flex-wrap px-0 py-0.5">
|
||||
{items.map((item) => (
|
||||
<ContextItemRenderer key={item.id} item={item} sessionId={sessionId} />
|
||||
))}
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
);
|
||||
|
||||
@@ -0,0 +1,20 @@
|
||||
"use client";
|
||||
|
||||
import { memo } from "react";
|
||||
import type { FileAttachmentContextItem } from "@/lib/types/context";
|
||||
import { formatBytes } from "../file-attachment";
|
||||
import { ContextChip } from "./context-chip";
|
||||
|
||||
export const FileAttachmentItem = memo(function FileAttachmentItem({
|
||||
item,
|
||||
}: {
|
||||
item: FileAttachmentContextItem;
|
||||
}) {
|
||||
const preview = (
|
||||
<div className="text-xs text-muted-foreground">
|
||||
{item.attachment.fileName} ({formatBytes(item.attachment.size)})
|
||||
</div>
|
||||
);
|
||||
|
||||
return <ContextChip kind="file" label={item.label} preview={preview} onRemove={item.onRemove} />;
|
||||
});
|
||||
@@ -20,9 +20,6 @@ export const ImageItem = memo(function ImageItem({ item }: { item: ImageContextI
|
||||
alt="Preview"
|
||||
className="max-w-full max-h-48 rounded object-contain"
|
||||
/>
|
||||
<div className="text-xs text-muted-foreground">
|
||||
{item.attachment.width} × {item.attachment.height}
|
||||
</div>
|
||||
</div>
|
||||
);
|
||||
|
||||
|
||||
@@ -0,0 +1,72 @@
|
||||
"use client";
|
||||
|
||||
import { memo } from "react";
|
||||
import { IconFile, IconX } from "@tabler/icons-react";
|
||||
import { cn } from "@/lib/utils";
|
||||
import { formatBytes, type FileAttachment } from "./file-attachment";
|
||||
|
||||
type FileAttachmentPreviewProps = {
|
||||
attachments: FileAttachment[];
|
||||
onRemove: (id: string) => void;
|
||||
disabled?: boolean;
|
||||
};
|
||||
|
||||
export const FileAttachmentPreview = memo(function FileAttachmentPreview({
|
||||
attachments,
|
||||
onRemove,
|
||||
disabled = false,
|
||||
}: FileAttachmentPreviewProps) {
|
||||
if (attachments.length === 0) return null;
|
||||
|
||||
return (
|
||||
<div className="flex gap-1.5 px-3 pt-2 flex-wrap">
|
||||
{attachments.map((attachment) => (
|
||||
<div
|
||||
key={attachment.id}
|
||||
className={cn(
|
||||
"relative group rounded-md overflow-hidden border border-border bg-muted/30",
|
||||
disabled && "opacity-50",
|
||||
)}
|
||||
>
|
||||
{attachment.isImage && attachment.preview ? (
|
||||
/* eslint-disable-next-line @next/next/no-img-element -- base64/blob preview URLs are not compatible with next/image */
|
||||
<img
|
||||
src={attachment.preview}
|
||||
alt="Attachment preview"
|
||||
className="h-10 w-10 object-cover"
|
||||
/>
|
||||
) : (
|
||||
<div className="h-10 flex items-center gap-1 px-2">
|
||||
<IconFile className="h-3.5 w-3.5 text-muted-foreground shrink-0" />
|
||||
<div className="flex flex-col min-w-0">
|
||||
<span className="text-[10px] leading-tight text-foreground truncate max-w-24">
|
||||
{attachment.fileName}
|
||||
</span>
|
||||
<span className="text-[9px] leading-tight text-muted-foreground">
|
||||
{formatBytes(attachment.size)}
|
||||
</span>
|
||||
</div>
|
||||
</div>
|
||||
)}
|
||||
|
||||
{!disabled && (
|
||||
<button
|
||||
type="button"
|
||||
onClick={() => onRemove(attachment.id)}
|
||||
className={cn(
|
||||
"absolute top-0.5 right-0.5 p-0.5 rounded-full",
|
||||
"bg-black/70 text-white",
|
||||
"opacity-0 group-hover:opacity-100 transition-opacity",
|
||||
"hover:bg-black/90 cursor-pointer",
|
||||
"focus:outline-none focus:ring-1 focus:ring-white/50",
|
||||
)}
|
||||
aria-label={`Remove ${attachment.isImage ? "image" : "file"}`}
|
||||
>
|
||||
<IconX className="h-2.5 w-2.5" />
|
||||
</button>
|
||||
)}
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
);
|
||||
});
|
||||
@@ -0,0 +1,101 @@
|
||||
/**
|
||||
* Unified file attachment type and processing utilities.
|
||||
* Handles both images (with preview) and arbitrary files (code, docs, etc.).
|
||||
*/
|
||||
|
||||
export type FileAttachment = {
|
||||
id: string;
|
||||
data: string; // Base64-encoded content (without data: prefix)
|
||||
mimeType: string; // MIME type
|
||||
fileName: string; // Original file name
|
||||
size: number; // File size in bytes
|
||||
preview?: string; // Data URL for image preview (only for images)
|
||||
isImage: boolean; // Whether this is a previewable image
|
||||
};
|
||||
|
||||
export const PREVIEWABLE_IMAGE_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
|
||||
|
||||
export const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB per file
|
||||
export const MAX_TOTAL_SIZE = 20 * 1024 * 1024; // 20MB total
|
||||
export const MAX_FILES = 10;
|
||||
|
||||
export function formatBytes(bytes: number): string {
|
||||
if (bytes === 0) return "0 B";
|
||||
const k = 1024;
|
||||
const sizes = ["B", "KB", "MB", "GB"];
|
||||
const i = Math.floor(Math.log(bytes) / Math.log(k));
|
||||
return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${sizes[i]}`;
|
||||
}
|
||||
|
||||
function isPreviewableImage(mimeType: string): boolean {
|
||||
return PREVIEWABLE_IMAGE_TYPES.includes(mimeType);
|
||||
}
|
||||
|
||||
/**
|
||||
* Process a file into a FileAttachment.
|
||||
* Images get a preview data URL; other files just get base64 data.
|
||||
* Returns null if the file is invalid (too large, etc.)
|
||||
*/
|
||||
export function processFile(file: File): Promise<FileAttachment | null> {
|
||||
return new Promise((resolve) => {
|
||||
if (file.size > MAX_FILE_SIZE) {
|
||||
console.warn(
|
||||
`File too large: ${formatBytes(file.size)} (max: ${formatBytes(MAX_FILE_SIZE)})`,
|
||||
);
|
||||
resolve(null);
|
||||
return;
|
||||
}
|
||||
|
||||
// Skip directories and empty files
|
||||
if (file.size === 0 && file.type === "") {
|
||||
resolve(null);
|
||||
return;
|
||||
}
|
||||
|
||||
const reader = new FileReader();
|
||||
reader.onload = (event) => {
|
||||
const dataUrl = event.target?.result as string;
|
||||
if (!dataUrl) {
|
||||
resolve(null);
|
||||
return;
|
||||
}
|
||||
|
||||
const base64 = dataUrl.split(",")[1];
|
||||
const mimeType =
|
||||
file.type || dataUrl.split(";")[0].split(":")[1] || "application/octet-stream";
|
||||
const isImage = isPreviewableImage(mimeType);
|
||||
|
||||
if (isImage) {
|
||||
// For images, load to verify and generate preview
|
||||
const img = new Image();
|
||||
img.onload = () => {
|
||||
resolve({
|
||||
id: crypto.randomUUID(),
|
||||
data: base64,
|
||||
mimeType,
|
||||
fileName: file.name,
|
||||
size: file.size,
|
||||
preview: dataUrl,
|
||||
isImage: true,
|
||||
});
|
||||
};
|
||||
img.onerror = () => resolve(null);
|
||||
img.src = dataUrl;
|
||||
} else {
|
||||
resolve({
|
||||
id: crypto.randomUUID(),
|
||||
data: base64,
|
||||
mimeType,
|
||||
fileName: file.name,
|
||||
size: file.size,
|
||||
isImage: false,
|
||||
});
|
||||
}
|
||||
};
|
||||
reader.onerror = () => {
|
||||
console.error("Failed to read file:", file.name);
|
||||
resolve(null);
|
||||
};
|
||||
reader.readAsDataURL(file);
|
||||
});
|
||||
}
|
||||
@@ -99,7 +99,7 @@ type UserMessageProps = {
|
||||
};
|
||||
|
||||
type UserMessageMetadata = {
|
||||
attachments?: Array<{ type: string; data: string; mime_type: string }>;
|
||||
attachments?: Array<{ type: string; data: string; mime_type: string; name?: string }>;
|
||||
plan_mode?: boolean;
|
||||
has_review_comments?: boolean;
|
||||
has_hidden_prompts?: boolean;
|
||||
@@ -109,14 +109,16 @@ type UserMessageMetadata = {
|
||||
function parseUserMessageMetadata(comment: Message) {
|
||||
const metadata = comment.metadata as UserMessageMetadata | undefined;
|
||||
const imageAttachments = (metadata?.attachments || []).filter((att) => att.type === "image");
|
||||
const fileAttachments = (metadata?.attachments || []).filter((att) => att.type === "resource");
|
||||
const contextFiles = metadata?.context_files || [];
|
||||
const hasPlanMode = !!metadata?.plan_mode;
|
||||
const hasReviewComments = !!metadata?.has_review_comments;
|
||||
const hasHiddenPrompts = !!metadata?.has_hidden_prompts;
|
||||
const hasContent = !!(comment.content && comment.content.trim() !== "");
|
||||
const hasAttachments = imageAttachments.length > 0;
|
||||
const hasAttachments = imageAttachments.length > 0 || fileAttachments.length > 0;
|
||||
return {
|
||||
imageAttachments,
|
||||
fileAttachments,
|
||||
contextFiles,
|
||||
hasPlanMode,
|
||||
hasReviewComments,
|
||||
@@ -179,6 +181,7 @@ function UserMessageContent({
|
||||
const userNavigation = useMessageNavigation(allMessages || [], comment.id, "user");
|
||||
const {
|
||||
imageAttachments,
|
||||
fileAttachments,
|
||||
contextFiles,
|
||||
hasPlanMode,
|
||||
hasReviewComments,
|
||||
@@ -208,6 +211,15 @@ function UserMessageContent({
|
||||
onClick={() => openImageInWindow(att.mime_type, att.data)}
|
||||
/>
|
||||
))}
|
||||
{fileAttachments.map((att, index) => (
|
||||
<span
|
||||
key={`file-${index}`}
|
||||
className="inline-flex items-center gap-1.5 rounded-full bg-muted/40 px-2.5 py-1 text-xs text-muted-foreground"
|
||||
>
|
||||
<IconFile size={12} />
|
||||
{att.name || "Attachment"}
|
||||
</span>
|
||||
))}
|
||||
</div>
|
||||
)}
|
||||
{renderUserMessageBody(
|
||||
|
||||
@@ -1,16 +1,10 @@
|
||||
"use client";
|
||||
|
||||
import {
|
||||
IconBrain,
|
||||
IconCode,
|
||||
IconExternalLink,
|
||||
IconListCheck,
|
||||
IconPhoto,
|
||||
} from "@tabler/icons-react";
|
||||
import { cn } from "@/lib/utils";
|
||||
import { IconBrain, IconCode, IconExternalLink, IconPhoto } from "@tabler/icons-react";
|
||||
import type { Message } from "@/lib/types/http";
|
||||
import type { ContentBlock, RichMetadata } from "@/components/task/chat/types";
|
||||
import { DiffViewBlock } from "@/components/task/chat/messages/diff-view-block";
|
||||
import { TodoMessage } from "@/components/task/chat/messages/todo-message";
|
||||
import { normalizeDiffString } from "@/lib/diff";
|
||||
import type { FileDiffData } from "@/lib/diff/types";
|
||||
|
||||
@@ -79,10 +73,7 @@ export function RichBlocks({ comment }: { comment: Message }) {
|
||||
const metadata = comment.metadata as RichMetadata | undefined;
|
||||
if (!metadata) return null;
|
||||
|
||||
const todos = metadata.todos ?? [];
|
||||
const todoItems = todos
|
||||
.map((item) => (typeof item === "string" ? { text: item, done: false } : item))
|
||||
.filter((item) => item.text);
|
||||
const hasTodos = (metadata.todos ?? []).length > 0;
|
||||
const diffData = resolveDiffPayload(metadata.diff);
|
||||
const diffText = typeof metadata.diff === "string" ? metadata.diff : null;
|
||||
const contentBlocks = (metadata.content_blocks ?? []).filter(
|
||||
@@ -100,27 +91,9 @@ export function RichBlocks({ comment }: { comment: Message }) {
|
||||
<div className="whitespace-pre-wrap text-foreground/80">{metadata.thinking}</div>
|
||||
</div>
|
||||
)}
|
||||
{todoItems.length > 0 && (
|
||||
<div className="mt-3 rounded-md border border-border/49 bg-background/60 px-3 py-2 text-xs">
|
||||
<div className="flex items-center gap-2 text-muted-foreground mb-1 uppercase tracking-wide">
|
||||
<IconListCheck className="h-3.5 w-3.5" />
|
||||
<span>Todos</span>
|
||||
</div>
|
||||
<div className="space-y-1">
|
||||
{todoItems.map((todo) => (
|
||||
<div key={todo.text} className="flex items-center gap-2">
|
||||
<span
|
||||
className={cn(
|
||||
"h-1.5 w-1.5 rounded-full",
|
||||
todo.done ? "bg-green-500" : "bg-muted-foreground/60",
|
||||
)}
|
||||
/>
|
||||
<span className={cn(todo.done && "line-through text-muted-foreground")}>
|
||||
{todo.text}
|
||||
</span>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
{hasTodos && (
|
||||
<div className="mt-3">
|
||||
<TodoMessage comment={comment} />
|
||||
</div>
|
||||
)}
|
||||
{diffData && <DiffViewBlock data={diffData} />}
|
||||
|
||||
@@ -1,59 +1,73 @@
|
||||
"use client";
|
||||
|
||||
import { useState } from "react";
|
||||
import { IconListCheck } from "@tabler/icons-react";
|
||||
import { cn } from "@/lib/utils";
|
||||
import type { Message } from "@/lib/types/http";
|
||||
import type { RichMetadata } from "@/components/task/chat/types";
|
||||
import { ExpandableRow } from "./expandable-row";
|
||||
import { StatusIcon, resolveStatus } from "../todo-indicator";
|
||||
|
||||
export function TodoMessage({ comment }: { comment: Message }) {
|
||||
type TodoItem = {
|
||||
text: string;
|
||||
done?: boolean;
|
||||
status?: "pending" | "in_progress" | "completed" | "failed";
|
||||
};
|
||||
|
||||
function parseTodos(comment: Message): TodoItem[] {
|
||||
const metadata = comment.metadata as RichMetadata | undefined;
|
||||
const todos = metadata?.todos ?? [];
|
||||
const todoItems = todos
|
||||
return todos
|
||||
.map((item) => (typeof item === "string" ? { text: item, done: false } : item))
|
||||
.filter((item) => item.text);
|
||||
}
|
||||
|
||||
if (!todoItems.length) {
|
||||
return null;
|
||||
}
|
||||
export function TodoMessage({
|
||||
comment,
|
||||
defaultExpanded = false,
|
||||
}: {
|
||||
comment: Message;
|
||||
defaultExpanded?: boolean;
|
||||
}) {
|
||||
const todoItems = parseTodos(comment);
|
||||
const [isExpanded, setIsExpanded] = useState(defaultExpanded);
|
||||
|
||||
const completed = todoItems.filter((todo) => todo.done).length;
|
||||
const progress = Math.round((completed / todoItems.length) * 100);
|
||||
if (!todoItems.length) return null;
|
||||
|
||||
const completed = todoItems.filter((t) => resolveStatus(t) === "completed").length;
|
||||
|
||||
return (
|
||||
<div className="w-full rounded-lg border border-border/60 bg-background/60 px-4 py-3 text-xs">
|
||||
<div className="flex items-center gap-2 text-muted-foreground mb-2 uppercase tracking-wide text-[11px]">
|
||||
<IconListCheck className="h-3.5 w-3.5" />
|
||||
<span>Todos</span>
|
||||
</div>
|
||||
<div className="mb-2">
|
||||
<div className="flex items-center justify-between text-[11px] text-muted-foreground mb-1">
|
||||
<span>
|
||||
{completed} of {todoItems.length} done
|
||||
</span>
|
||||
<span>{progress}%</span>
|
||||
</div>
|
||||
<div className="h-1.5 rounded-full bg-muted/70">
|
||||
<div
|
||||
className="h-full rounded-full bg-primary/80 transition-[width]"
|
||||
style={{ width: `${progress}%` }}
|
||||
/>
|
||||
</div>
|
||||
</div>
|
||||
<div className="space-y-1 text-xs">
|
||||
{todoItems.map((todo) => (
|
||||
<div key={todo.text} className="flex items-center gap-2">
|
||||
<span
|
||||
className={cn(
|
||||
"h-1.5 w-1.5 rounded-full",
|
||||
todo.done ? "bg-green-500" : "bg-muted-foreground/60",
|
||||
)}
|
||||
/>
|
||||
<span className={cn(todo.done && "line-through text-muted-foreground")}>
|
||||
{todo.text}
|
||||
<div className="w-full rounded-lg border border-border/60 bg-background/60 text-xs">
|
||||
<ExpandableRow
|
||||
icon={<IconListCheck className="h-4 w-4 text-muted-foreground" />}
|
||||
header={
|
||||
<div className="flex items-center justify-between w-full">
|
||||
<span className="text-muted-foreground text-[11px] uppercase tracking-wide">
|
||||
Updated Todos
|
||||
</span>
|
||||
<span className="text-muted-foreground text-[11px]">
|
||||
{completed}/{todoItems.length}
|
||||
</span>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
}
|
||||
hasExpandableContent={todoItems.length > 0}
|
||||
isExpanded={isExpanded}
|
||||
onToggle={() => setIsExpanded((prev) => !prev)}
|
||||
>
|
||||
<div className="space-y-1.5 pb-2">
|
||||
{todoItems.map((todo, idx) => {
|
||||
const s = resolveStatus(todo);
|
||||
return (
|
||||
<div key={idx} className="flex items-start gap-2">
|
||||
<StatusIcon status={s} className="mt-0.5 shrink-0 h-3.5 w-3.5" />
|
||||
<span className={cn(s === "completed" && "line-through text-muted-foreground")}>
|
||||
{todo.text}
|
||||
</span>
|
||||
</div>
|
||||
);
|
||||
})}
|
||||
</div>
|
||||
</ExpandableRow>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
@@ -120,10 +120,10 @@ export function parseCodeFences(text: string): FenceSegment[] {
|
||||
|
||||
// ── Paste handler ───────────────────────────────────────────────────
|
||||
|
||||
function extractImageFiles(items: DataTransferItemList): File[] {
|
||||
function extractFiles(items: DataTransferItemList): File[] {
|
||||
const files: File[] = [];
|
||||
for (const item of items) {
|
||||
if (item.type.startsWith("image/")) {
|
||||
if (item.kind === "file") {
|
||||
const file = item.getAsFile();
|
||||
if (file) files.push(file);
|
||||
}
|
||||
@@ -167,13 +167,13 @@ export function handleEditorPaste(
|
||||
event: ClipboardEvent,
|
||||
onImagePasteRef: React.RefObject<((files: File[]) => void) | undefined>,
|
||||
): boolean {
|
||||
// 1. Image paste
|
||||
// 1. File paste (images and other files)
|
||||
const items = event.clipboardData?.items;
|
||||
if (items) {
|
||||
const imageFiles = extractImageFiles(items);
|
||||
if (imageFiles.length > 0) {
|
||||
const files = extractFiles(items);
|
||||
if (files.length > 0) {
|
||||
event.preventDefault();
|
||||
onImagePasteRef.current?.(imageFiles);
|
||||
onImagePasteRef.current?.(files);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,92 @@
|
||||
"use client";
|
||||
|
||||
import { IconCheck, IconCircle, IconCircleFilled, IconListCheck, IconX } from "@tabler/icons-react";
|
||||
import { HoverCard, HoverCardTrigger, HoverCardContent } from "@kandev/ui/hover-card";
|
||||
import { cn } from "@/lib/utils";
|
||||
|
||||
type TodoDisplayItem = {
|
||||
text: string;
|
||||
done?: boolean;
|
||||
status?: "pending" | "in_progress" | "completed" | "failed";
|
||||
};
|
||||
|
||||
type TodoIndicatorProps = {
|
||||
todos: TodoDisplayItem[];
|
||||
};
|
||||
|
||||
function resolveStatus(todo: TodoDisplayItem): "pending" | "in_progress" | "completed" | "failed" {
|
||||
if (todo.status) return todo.status;
|
||||
return todo.done ? "completed" : "pending";
|
||||
}
|
||||
|
||||
function StatusIcon({ status, className }: { status: string; className?: string }) {
|
||||
switch (status) {
|
||||
case "completed":
|
||||
return <IconCheck className={cn("h-3.5 w-3.5 text-green-500", className)} />;
|
||||
case "in_progress":
|
||||
return <IconCircleFilled className={cn("h-3.5 w-3.5 text-blue-500", className)} />;
|
||||
case "failed":
|
||||
return <IconX className={cn("h-3.5 w-3.5 text-red-500", className)} />;
|
||||
default:
|
||||
return <IconCircle className={cn("h-3.5 w-3.5 text-muted-foreground/40", className)} />;
|
||||
}
|
||||
}
|
||||
|
||||
export function TodoIndicator({ todos }: TodoIndicatorProps) {
|
||||
if (!todos.length) return null;
|
||||
|
||||
const completed = todos.filter((t) => resolveStatus(t) === "completed").length;
|
||||
const allComplete = completed === todos.length;
|
||||
const progress = Math.round((completed / todos.length) * 100);
|
||||
|
||||
return (
|
||||
<HoverCard openDelay={200} closeDelay={100}>
|
||||
<HoverCardTrigger asChild>
|
||||
<button
|
||||
type="button"
|
||||
className={cn(
|
||||
"flex items-center gap-1.5 px-2 py-0.5 text-xs transition-colors rounded cursor-pointer",
|
||||
allComplete
|
||||
? "text-green-500 hover:text-green-400"
|
||||
: "text-muted-foreground hover:text-foreground",
|
||||
)}
|
||||
>
|
||||
{allComplete ? <IconCheck className="h-3 w-3" /> : <IconListCheck className="h-3 w-3" />}
|
||||
<span>
|
||||
{completed}/{todos.length}
|
||||
</span>
|
||||
</button>
|
||||
</HoverCardTrigger>
|
||||
<HoverCardContent side="top" align="start" className="w-72 p-3">
|
||||
<div className="flex items-center justify-between text-xs mb-2">
|
||||
<span className="font-medium text-foreground">Todos</span>
|
||||
<span className="text-muted-foreground">
|
||||
{completed}/{todos.length} completed
|
||||
</span>
|
||||
</div>
|
||||
<div className="h-1.5 rounded-full bg-muted/70 mb-3">
|
||||
<div
|
||||
className="h-full rounded-full bg-primary/80 transition-[width]"
|
||||
style={{ width: `${progress}%` }}
|
||||
/>
|
||||
</div>
|
||||
<div className="space-y-1.5 max-h-48 overflow-y-auto">
|
||||
{todos.map((todo, idx) => {
|
||||
const s = resolveStatus(todo);
|
||||
return (
|
||||
<div key={idx} className="flex items-start gap-2 text-xs">
|
||||
<StatusIcon status={s} className="mt-0.5 shrink-0 h-3 w-3" />
|
||||
<span className={cn(s === "completed" && "line-through text-muted-foreground")}>
|
||||
{todo.text}
|
||||
</span>
|
||||
</div>
|
||||
);
|
||||
})}
|
||||
</div>
|
||||
</HoverCardContent>
|
||||
</HoverCard>
|
||||
);
|
||||
}
|
||||
|
||||
export { StatusIcon, resolveStatus };
|
||||
export type { TodoDisplayItem };
|
||||
@@ -1,45 +0,0 @@
|
||||
"use client";
|
||||
|
||||
import { IconCheck, IconChevronDown } from "@tabler/icons-react";
|
||||
import { cn } from "@/lib/utils";
|
||||
|
||||
type TodoItem = {
|
||||
text: string;
|
||||
done?: boolean;
|
||||
};
|
||||
|
||||
type TodoSummaryProps = {
|
||||
todos: TodoItem[];
|
||||
};
|
||||
|
||||
export function TodoSummary({ todos }: TodoSummaryProps) {
|
||||
if (!todos.length) return null;
|
||||
|
||||
const completed = todos.filter((todo) => todo.done).length;
|
||||
|
||||
return (
|
||||
<div className="rounded-md border border-border/60 bg-muted/40 px-3 py-2 text-xs">
|
||||
<div className="flex items-center justify-between text-[11px] uppercase tracking-wide text-muted-foreground">
|
||||
<span>Todos ({todos.length})</span>
|
||||
<IconChevronDown className="h-3.5 w-3.5" />
|
||||
</div>
|
||||
<div className="mt-2 space-y-1">
|
||||
{todos.map((todo) => (
|
||||
<div key={todo.text} className="flex items-center gap-2">
|
||||
{todo.done ? (
|
||||
<IconCheck className="h-3.5 w-3.5 text-green-500" />
|
||||
) : (
|
||||
<span className="h-3.5 w-3.5" />
|
||||
)}
|
||||
<span className={cn(todo.done && "line-through text-muted-foreground")}>
|
||||
{todo.text}
|
||||
</span>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
<div className="mt-2 text-[11px] text-muted-foreground">
|
||||
{completed} of {todos.length} completed
|
||||
</div>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -26,7 +26,6 @@ type UseChatInputContainerParams = {
|
||||
onClarificationResolved: (() => void) | undefined;
|
||||
pendingCommentsByFile: Record<string, DiffComment[]> | undefined;
|
||||
hasContextComments: boolean;
|
||||
todoItems: { text: string; done?: boolean }[];
|
||||
showRequestChangesTooltip: boolean;
|
||||
onRequestChangesTooltipDismiss: (() => void) | undefined;
|
||||
onSubmit: (
|
||||
@@ -78,7 +77,6 @@ function computeDerivedState(params: {
|
||||
pendingClarification: Message | null | undefined;
|
||||
onClarificationResolved: (() => void) | undefined;
|
||||
pendingCommentsByFile: Record<string, DiffComment[]> | undefined;
|
||||
todoItems: { text: string }[];
|
||||
allItemsLength: number;
|
||||
isInputFocused: boolean;
|
||||
placeholder: string | undefined;
|
||||
@@ -91,8 +89,7 @@ function computeDerivedState(params: {
|
||||
const hasPendingComments = !!(
|
||||
params.pendingCommentsByFile && Object.keys(params.pendingCommentsByFile).length > 0
|
||||
);
|
||||
const hasTodos = params.todoItems.length > 0;
|
||||
const hasContextZone = hasTodos || params.allItemsLength > 0;
|
||||
const hasContextZone = params.allItemsLength > 0;
|
||||
const showFocusHint = !params.isInputFocused && !hasClarification && !hasPendingComments;
|
||||
const inputPlaceholder = getInputPlaceholder(
|
||||
params.placeholder,
|
||||
@@ -104,7 +101,6 @@ function computeDerivedState(params: {
|
||||
isDisabled,
|
||||
hasClarification,
|
||||
hasPendingComments,
|
||||
hasTodos,
|
||||
hasContextZone,
|
||||
showFocusHint,
|
||||
inputPlaceholder,
|
||||
@@ -126,7 +122,6 @@ export function useChatInputContainer(params: UseChatInputContainerParams) {
|
||||
pendingClarification,
|
||||
onClarificationResolved,
|
||||
pendingCommentsByFile,
|
||||
todoItems,
|
||||
showRequestChangesTooltip,
|
||||
onRequestChangesTooltipDismiss,
|
||||
onSubmit,
|
||||
@@ -142,17 +137,17 @@ export function useChatInputContainer(params: UseChatInputContainerParams) {
|
||||
sessionId ?? undefined,
|
||||
getContentElement,
|
||||
);
|
||||
const { value, inputRef, handleImagePaste, handleChange, handleSubmit, allItems } =
|
||||
useChatInputState({
|
||||
sessionId,
|
||||
isSending,
|
||||
contextItems,
|
||||
pendingCommentsByFile,
|
||||
hasContextComments: params.hasContextComments,
|
||||
showRequestChangesTooltip,
|
||||
onRequestChangesTooltipDismiss,
|
||||
onSubmit,
|
||||
});
|
||||
const fileInputRef = useRef<HTMLInputElement>(null);
|
||||
const { value, inputRef, addFiles, handleChange, handleSubmit, allItems } = useChatInputState({
|
||||
sessionId,
|
||||
isSending,
|
||||
contextItems,
|
||||
pendingCommentsByFile,
|
||||
hasContextComments: params.hasContextComments,
|
||||
showRequestChangesTooltip,
|
||||
onRequestChangesTooltipDismiss,
|
||||
onSubmit,
|
||||
});
|
||||
|
||||
useEffect(() => {
|
||||
tiptapRef.current = inputRef.current;
|
||||
@@ -192,7 +187,6 @@ export function useChatInputContainer(params: UseChatInputContainerParams) {
|
||||
pendingClarification,
|
||||
onClarificationResolved,
|
||||
pendingCommentsByFile,
|
||||
todoItems,
|
||||
allItemsLength: allItems.length,
|
||||
isInputFocused,
|
||||
placeholder,
|
||||
@@ -212,7 +206,8 @@ export function useChatInputContainer(params: UseChatInputContainerParams) {
|
||||
resizeHandleProps,
|
||||
value,
|
||||
inputRef,
|
||||
handleImagePaste,
|
||||
addFiles,
|
||||
fileInputRef,
|
||||
handleChange: handleChangeWithAutoExpand,
|
||||
handleSubmitWithReset,
|
||||
handleAgentCommand,
|
||||
|
||||
@@ -8,13 +8,13 @@ import {
|
||||
restoreAttachmentPreview,
|
||||
} from "@/lib/local-storage";
|
||||
import {
|
||||
processImageFile,
|
||||
processFile,
|
||||
formatBytes,
|
||||
MAX_IMAGES,
|
||||
MAX_FILES,
|
||||
MAX_TOTAL_SIZE,
|
||||
type ImageAttachment,
|
||||
} from "./image-attachment-preview";
|
||||
import type { ContextItem, ImageContextItem } from "@/lib/types/context";
|
||||
type FileAttachment,
|
||||
} from "./file-attachment";
|
||||
import type { ContextItem, ImageContextItem, FileAttachmentContextItem } from "@/lib/types/context";
|
||||
import type { ContextFile } from "@/lib/state/context-files-store";
|
||||
import type { DiffComment } from "@/lib/diff/types";
|
||||
import type { MessageAttachment } from "./chat-input-container";
|
||||
@@ -47,12 +47,12 @@ function collectComments(
|
||||
return allComments;
|
||||
}
|
||||
|
||||
function toMessageAttachments(attachments: ImageAttachment[]): MessageAttachment[] {
|
||||
return attachments.map((att) => ({
|
||||
type: "image" as const,
|
||||
data: att.data,
|
||||
mime_type: att.mimeType,
|
||||
}));
|
||||
function toMessageAttachments(attachments: FileAttachment[]): MessageAttachment[] {
|
||||
return attachments.map((att) =>
|
||||
att.isImage
|
||||
? { type: "image" as const, data: att.data, mime_type: att.mimeType }
|
||||
: { type: "resource" as const, data: att.data, mime_type: att.mimeType, name: att.fileName },
|
||||
);
|
||||
}
|
||||
|
||||
function clearDraft(sessionId: string | null) {
|
||||
@@ -63,7 +63,7 @@ function clearDraft(sessionId: string | null) {
|
||||
}
|
||||
|
||||
function useAttachments(sessionId: string | null) {
|
||||
const [attachments, setAttachments] = useState<ImageAttachment[]>(() =>
|
||||
const [attachments, setAttachments] = useState<FileAttachment[]>(() =>
|
||||
sessionId ? getChatDraftAttachments(sessionId).map(restoreAttachmentPreview) : [],
|
||||
);
|
||||
const attachmentsRef = useRef(attachments);
|
||||
@@ -75,20 +75,20 @@ function useAttachments(sessionId: string | null) {
|
||||
setChatDraftAttachments(sessionId, attachments);
|
||||
}, [attachments, sessionId]);
|
||||
|
||||
const handleImagePaste = useCallback(
|
||||
const addFiles = useCallback(
|
||||
async (files: File[]) => {
|
||||
if (attachments.length >= MAX_IMAGES) {
|
||||
console.warn(`Maximum ${MAX_IMAGES} images allowed`);
|
||||
if (attachments.length >= MAX_FILES) {
|
||||
console.warn(`Maximum ${MAX_FILES} files allowed`);
|
||||
return;
|
||||
}
|
||||
const currentTotalSize = attachments.reduce((sum, att) => sum + att.size, 0);
|
||||
for (const file of files) {
|
||||
if (attachments.length >= MAX_IMAGES) break;
|
||||
if (attachments.length >= MAX_FILES) break;
|
||||
if (currentTotalSize + file.size > MAX_TOTAL_SIZE) {
|
||||
console.warn("Total attachment size limit exceeded");
|
||||
break;
|
||||
}
|
||||
const attachment = await processImageFile(file);
|
||||
const attachment = await processFile(file);
|
||||
if (attachment) setAttachments((prev) => [...prev, attachment]);
|
||||
}
|
||||
},
|
||||
@@ -104,7 +104,7 @@ function useAttachments(sessionId: string | null) {
|
||||
attachmentsRef,
|
||||
prevSessionIdRef,
|
||||
setAttachments,
|
||||
handleImagePaste,
|
||||
addFiles,
|
||||
handleRemoveAttachment,
|
||||
};
|
||||
}
|
||||
@@ -130,7 +130,7 @@ export function useChatInputState({
|
||||
attachmentsRef,
|
||||
prevSessionIdRef,
|
||||
setAttachments,
|
||||
handleImagePaste,
|
||||
addFiles,
|
||||
handleRemoveAttachment,
|
||||
} = useAttachments(sessionId);
|
||||
|
||||
@@ -188,15 +188,26 @@ export function useChatInputState({
|
||||
);
|
||||
|
||||
const allItems = useMemo((): ContextItem[] => {
|
||||
const imageItems: ImageContextItem[] = attachments.map((att) => ({
|
||||
kind: "image" as const,
|
||||
id: `image:${att.id}`,
|
||||
label: `Image (${formatBytes(att.size)})`,
|
||||
attachment: att,
|
||||
onRemove: () => handleRemoveAttachment(att.id),
|
||||
}));
|
||||
return [...contextItems, ...imageItems];
|
||||
const attachmentItems: (ImageContextItem | FileAttachmentContextItem)[] = attachments.map(
|
||||
(att) =>
|
||||
att.isImage
|
||||
? ({
|
||||
kind: "image" as const,
|
||||
id: `image:${att.id}`,
|
||||
label: `Image (${formatBytes(att.size)})`,
|
||||
attachment: att,
|
||||
onRemove: () => handleRemoveAttachment(att.id),
|
||||
} as ImageContextItem)
|
||||
: ({
|
||||
kind: "file-attachment" as const,
|
||||
id: `file:${att.id}`,
|
||||
label: att.fileName,
|
||||
attachment: att,
|
||||
onRemove: () => handleRemoveAttachment(att.id),
|
||||
} as FileAttachmentContextItem),
|
||||
);
|
||||
return [...contextItems, ...attachmentItems];
|
||||
}, [contextItems, attachments, handleRemoveAttachment]);
|
||||
|
||||
return { value, attachments, inputRef, handleImagePaste, handleChange, handleSubmit, allItems };
|
||||
return { value, attachments, inputRef, addFiles, handleChange, handleSubmit, allItems };
|
||||
}
|
||||
|
||||
@@ -422,6 +422,27 @@ function useSessionData(
|
||||
};
|
||||
}
|
||||
|
||||
type TodoStatus = "pending" | "in_progress" | "completed" | "failed";
|
||||
|
||||
function useSessionTodoItems(
|
||||
resolvedSessionId: string | null,
|
||||
messageTodos: Array<{ text: string; done?: boolean }>,
|
||||
) {
|
||||
const storeTodos = useAppStore((s) =>
|
||||
resolvedSessionId ? s.sessionTodos.bySessionId[resolvedSessionId] : undefined,
|
||||
);
|
||||
return useMemo(() => {
|
||||
if (storeTodos && storeTodos.length > 0) {
|
||||
return storeTodos.map((e: { description: string; status: string }) => ({
|
||||
text: e.description,
|
||||
done: e.status === "completed",
|
||||
status: e.status as TodoStatus,
|
||||
}));
|
||||
}
|
||||
return messageTodos;
|
||||
}, [storeTodos, messageTodos]);
|
||||
}
|
||||
|
||||
export type UseChatPanelStateOptions = {
|
||||
sessionId: string | null;
|
||||
onOpenFile?: (path: string) => void;
|
||||
@@ -515,6 +536,8 @@ export function useChatPanelState({
|
||||
onOpenFileAtLine,
|
||||
});
|
||||
|
||||
const todoItems = useSessionTodoItems(resolvedSessionId, sessionData.todoItems);
|
||||
|
||||
return {
|
||||
...sessionState,
|
||||
...planMode,
|
||||
@@ -527,5 +550,6 @@ export function useChatPanelState({
|
||||
planModeAvailable,
|
||||
mcpServers,
|
||||
prompts,
|
||||
todoItems,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -0,0 +1,49 @@
|
||||
"use client";
|
||||
|
||||
import { memo } from "react";
|
||||
import { IconSettings } from "@tabler/icons-react";
|
||||
import { Button } from "@kandev/ui/button";
|
||||
import { Popover, PopoverContent, PopoverTrigger } from "@kandev/ui/popover";
|
||||
import { useAppStore } from "@/components/state-provider";
|
||||
|
||||
type ConfigOptionsDisplayProps = {
|
||||
sessionId: string | null;
|
||||
};
|
||||
|
||||
export const ConfigOptionsDisplay = memo(function ConfigOptionsDisplay({
|
||||
sessionId,
|
||||
}: ConfigOptionsDisplayProps) {
|
||||
const configOptions = useAppStore((state) => {
|
||||
if (!sessionId) return undefined;
|
||||
return state.sessionModels.bySessionId[sessionId]?.configOptions;
|
||||
});
|
||||
|
||||
if (!sessionId || !configOptions || configOptions.length === 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return (
|
||||
<Popover>
|
||||
<PopoverTrigger asChild>
|
||||
<Button
|
||||
variant="ghost"
|
||||
size="sm"
|
||||
className="h-7 gap-1 px-2 cursor-pointer hover:bg-muted/40"
|
||||
>
|
||||
<IconSettings className="h-3.5 w-3.5 text-muted-foreground" />
|
||||
</Button>
|
||||
</PopoverTrigger>
|
||||
<PopoverContent align="end" side="top" className="w-64 p-3">
|
||||
<div className="space-y-2">
|
||||
<div className="text-xs font-medium text-muted-foreground">Config Options</div>
|
||||
{configOptions.map((option) => (
|
||||
<div key={option.id} className="flex items-center justify-between text-xs">
|
||||
<span className="text-muted-foreground">{option.name}</span>
|
||||
<span className="font-mono">{option.currentValue}</span>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
</PopoverContent>
|
||||
</Popover>
|
||||
);
|
||||
});
|
||||
@@ -349,16 +349,16 @@ function RightTopGroupActions() {
|
||||
|
||||
function SessionModeBadge() {
|
||||
const activeSessionId = useAppStore((state) => state.tasks.activeSessionId);
|
||||
const modeId = useAppStore((state) => {
|
||||
const modeState = useAppStore((state) => {
|
||||
if (!activeSessionId) return null;
|
||||
return state.sessionMode.bySessionId[activeSessionId] ?? null;
|
||||
});
|
||||
|
||||
if (!modeId) return null;
|
||||
if (!modeState?.currentModeId) return null;
|
||||
|
||||
return (
|
||||
<span className="text-[10px] font-medium text-muted-foreground bg-muted/60 px-1.5 py-0.5 rounded">
|
||||
{modeId}
|
||||
{modeState.currentModeId}
|
||||
</span>
|
||||
);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,78 @@
|
||||
"use client";
|
||||
|
||||
import { memo, useCallback } from "react";
|
||||
import { IconChevronDown } from "@tabler/icons-react";
|
||||
import { Button } from "@kandev/ui/button";
|
||||
import {
|
||||
DropdownMenu,
|
||||
DropdownMenuContent,
|
||||
DropdownMenuItem,
|
||||
DropdownMenuTrigger,
|
||||
} from "@kandev/ui/dropdown-menu";
|
||||
import { useAppStore } from "@/components/state-provider";
|
||||
import { setSessionMode } from "@/lib/api/domains/session-api";
|
||||
|
||||
type ModeSelectorProps = {
|
||||
sessionId: string | null;
|
||||
};
|
||||
|
||||
export const ModeSelector = memo(function ModeSelector({ sessionId }: ModeSelectorProps) {
|
||||
const modeState = useAppStore((state) =>
|
||||
sessionId ? state.sessionMode.bySessionId[sessionId] : undefined,
|
||||
);
|
||||
|
||||
const handleModeChange = useCallback(
|
||||
async (modeId: string) => {
|
||||
if (!sessionId) return;
|
||||
try {
|
||||
await setSessionMode(sessionId, modeId);
|
||||
} catch (err) {
|
||||
console.error("[ModeSelector] set-mode API failed:", err);
|
||||
}
|
||||
},
|
||||
[sessionId],
|
||||
);
|
||||
|
||||
if (
|
||||
!sessionId ||
|
||||
!modeState ||
|
||||
!modeState.availableModes ||
|
||||
modeState.availableModes.length <= 1
|
||||
) {
|
||||
return null;
|
||||
}
|
||||
|
||||
const currentMode = modeState.availableModes.find((m) => m.id === modeState.currentModeId);
|
||||
const displayName = currentMode?.name || modeState.currentModeId || "Mode";
|
||||
|
||||
return (
|
||||
<DropdownMenu>
|
||||
<DropdownMenuTrigger asChild>
|
||||
<Button
|
||||
variant="ghost"
|
||||
size="sm"
|
||||
className="h-7 gap-1 px-2 cursor-pointer hover:bg-muted/40 whitespace-nowrap"
|
||||
>
|
||||
<span className="text-xs">{displayName}</span>
|
||||
<IconChevronDown className="h-3 w-3 text-muted-foreground shrink-0" />
|
||||
</Button>
|
||||
</DropdownMenuTrigger>
|
||||
<DropdownMenuContent align="end" side="top" className="min-w-[280px]">
|
||||
{modeState.availableModes.map((mode) => (
|
||||
<DropdownMenuItem
|
||||
key={mode.id}
|
||||
onClick={() => handleModeChange(mode.id)}
|
||||
className={mode.id === modeState.currentModeId ? "bg-muted" : ""}
|
||||
>
|
||||
<div>
|
||||
<div>{mode.name}</div>
|
||||
{mode.description && (
|
||||
<div className="text-xs text-muted-foreground">{mode.description}</div>
|
||||
)}
|
||||
</div>
|
||||
</DropdownMenuItem>
|
||||
))}
|
||||
</DropdownMenuContent>
|
||||
</DropdownMenu>
|
||||
);
|
||||
});
|
||||
@@ -1,18 +1,13 @@
|
||||
"use client";
|
||||
|
||||
import { memo } from "react";
|
||||
import { IconChevronDown } from "@tabler/icons-react";
|
||||
import { Button } from "@kandev/ui/button";
|
||||
import {
|
||||
DropdownMenu,
|
||||
DropdownMenuContent,
|
||||
DropdownMenuItem,
|
||||
DropdownMenuTrigger,
|
||||
} from "@kandev/ui/dropdown-menu";
|
||||
import { memo, useCallback, useMemo } from "react";
|
||||
import { useAppStore } from "@/components/state-provider";
|
||||
import { Combobox, type ComboboxOption } from "@/components/combobox";
|
||||
import { useAvailableAgents } from "@/hooks/domains/settings/use-available-agents";
|
||||
import { useSettingsData } from "@/hooks/domains/settings/use-settings-data";
|
||||
import type { Agent, AgentProfile, AvailableAgent } from "@/lib/types/http";
|
||||
import { setSessionModel } from "@/lib/api/domains/session-api";
|
||||
import type { SessionModelEntry } from "@/lib/state/slices/session-runtime/types";
|
||||
|
||||
type ModelSelectorProps = {
|
||||
sessionId: string | null;
|
||||
@@ -24,6 +19,8 @@ type ModelOption = {
|
||||
provider: string;
|
||||
context_window: number;
|
||||
is_default: boolean;
|
||||
description?: string;
|
||||
usageMultiplier?: string;
|
||||
};
|
||||
|
||||
function resolveSnapshotModel(snapshot: unknown): string | null {
|
||||
@@ -32,7 +29,7 @@ function resolveSnapshotModel(snapshot: unknown): string | null {
|
||||
return typeof model === "string" && model ? model : null;
|
||||
}
|
||||
|
||||
function resolveAvailableModels(
|
||||
function resolveStaticModels(
|
||||
agents: Agent[],
|
||||
profileId: string | null | undefined,
|
||||
availableAgents: AvailableAgent[],
|
||||
@@ -42,11 +39,28 @@ function resolveAvailableModels(
|
||||
const profile = agent.profiles.find((p: AgentProfile) => p.id === profileId);
|
||||
if (!profile) continue;
|
||||
const available = availableAgents.find((a: AvailableAgent) => a.name === agent.name);
|
||||
return available?.model_config?.available_models ?? [];
|
||||
const models = available?.model_config?.available_models ?? [];
|
||||
// Static models don't include description — use model ID as subtitle when it differs from name
|
||||
return models.map((m) => ({
|
||||
...m,
|
||||
description: m.id !== m.name ? m.id : undefined,
|
||||
}));
|
||||
}
|
||||
return [];
|
||||
}
|
||||
|
||||
function sessionModelsToOptions(models: SessionModelEntry[]): ModelOption[] {
|
||||
return models.map((m) => ({
|
||||
id: m.modelId,
|
||||
name: m.name,
|
||||
provider: "",
|
||||
context_window: 0,
|
||||
is_default: false,
|
||||
description: m.description,
|
||||
usageMultiplier: m.usageMultiplier,
|
||||
}));
|
||||
}
|
||||
|
||||
function buildModelOptions(
|
||||
availableModels: ModelOption[],
|
||||
currentModel: string | null,
|
||||
@@ -64,7 +78,8 @@ function buildModelOptions(
|
||||
return options;
|
||||
}
|
||||
|
||||
export const ModelSelector = memo(function ModelSelector({ sessionId }: ModelSelectorProps) {
|
||||
/** Resolves available models and current model from store state. */
|
||||
function useModelSelectorState(sessionId: string | null) {
|
||||
useSettingsData(true);
|
||||
|
||||
const settingsAgents = useAppStore((state) => state.settingsAgents.items);
|
||||
@@ -72,50 +87,89 @@ export const ModelSelector = memo(function ModelSelector({ sessionId }: ModelSel
|
||||
const activeModels = useAppStore((state) => state.activeModel.bySessionId);
|
||||
const setActiveModel = useAppStore((state) => state.setActiveModel);
|
||||
const { items: availableAgents } = useAvailableAgents();
|
||||
const sessionModelsData = useAppStore((state) =>
|
||||
sessionId ? state.sessionModels.bySessionId[sessionId] : undefined,
|
||||
);
|
||||
|
||||
const session = sessionId ? (taskSessions[sessionId] ?? null) : null;
|
||||
const snapshotModel = resolveSnapshotModel(session?.agent_profile_snapshot);
|
||||
const availableModels = resolveAvailableModels(
|
||||
settingsAgents as Agent[],
|
||||
session?.agent_profile_id,
|
||||
availableAgents,
|
||||
);
|
||||
|
||||
// Prefer dynamic ACP session models when available, fall back to static registry models
|
||||
const availableModels = sessionModelsData?.models?.length
|
||||
? sessionModelsToOptions(sessionModelsData.models)
|
||||
: resolveStaticModels(settingsAgents as Agent[], session?.agent_profile_id, availableAgents);
|
||||
|
||||
const activeModel = sessionId ? activeModels[sessionId] || null : null;
|
||||
const currentModel = activeModel || snapshotModel;
|
||||
const acpCurrentModel = sessionModelsData?.currentModelId || null;
|
||||
const currentModel = activeModel || acpCurrentModel || snapshotModel;
|
||||
const modelOptions = buildModelOptions(availableModels, currentModel);
|
||||
|
||||
const handleModelChange = (modelId: string) => {
|
||||
if (!sessionId) return;
|
||||
setActiveModel(sessionId, modelId);
|
||||
const handleModelChange = useCallback(
|
||||
(sid: string, modelId: string) => {
|
||||
setActiveModel(sid, modelId);
|
||||
setSessionModel(sid, modelId).catch((err) => {
|
||||
console.error("[ModelSelector] set-model API failed:", err);
|
||||
});
|
||||
},
|
||||
[setActiveModel],
|
||||
);
|
||||
|
||||
return { currentModel, modelOptions, handleModelChange };
|
||||
}
|
||||
|
||||
function modelToComboboxOption(model: ModelOption): ComboboxOption {
|
||||
return {
|
||||
value: model.id,
|
||||
label: model.name,
|
||||
description: model.description,
|
||||
renderLabel: () => (
|
||||
<>
|
||||
<div className="min-w-0 flex-1">
|
||||
<div className="truncate">{model.name}</div>
|
||||
{model.description && (
|
||||
<div className="text-xs text-muted-foreground truncate" title={model.description}>
|
||||
{model.description}
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
{model.usageMultiplier && (
|
||||
<span className="text-xs text-muted-foreground shrink-0">{model.usageMultiplier}</span>
|
||||
)}
|
||||
</>
|
||||
),
|
||||
};
|
||||
}
|
||||
|
||||
export const ModelSelector = memo(function ModelSelector({ sessionId }: ModelSelectorProps) {
|
||||
const { currentModel, modelOptions, handleModelChange } = useModelSelectorState(sessionId);
|
||||
|
||||
const comboboxOptions = useMemo(() => modelOptions.map(modelToComboboxOption), [modelOptions]);
|
||||
|
||||
const onValueChange = useCallback(
|
||||
(value: string) => {
|
||||
// Don't allow deselecting — always keep a model selected
|
||||
if (!value || !sessionId) return;
|
||||
handleModelChange(sessionId, value);
|
||||
},
|
||||
[sessionId, handleModelChange],
|
||||
);
|
||||
|
||||
if (!sessionId || !currentModel) return null;
|
||||
|
||||
const displayName = modelOptions.find((m) => m.id === currentModel)?.name || currentModel;
|
||||
|
||||
return (
|
||||
<DropdownMenu>
|
||||
<DropdownMenuTrigger asChild>
|
||||
<Button
|
||||
variant="ghost"
|
||||
size="sm"
|
||||
className="h-7 gap-1 px-2 cursor-pointer hover:bg-muted/40 whitespace-nowrap"
|
||||
>
|
||||
<span className="text-xs">{displayName}</span>
|
||||
<IconChevronDown className="h-3 w-3 text-muted-foreground shrink-0" />
|
||||
</Button>
|
||||
</DropdownMenuTrigger>
|
||||
<DropdownMenuContent align="end" side="top">
|
||||
{modelOptions.map((model) => (
|
||||
<DropdownMenuItem
|
||||
key={model.id}
|
||||
onClick={() => handleModelChange(model.id)}
|
||||
className={model.id === currentModel ? "bg-accent" : ""}
|
||||
>
|
||||
{model.name}
|
||||
</DropdownMenuItem>
|
||||
))}
|
||||
</DropdownMenuContent>
|
||||
</DropdownMenu>
|
||||
<Combobox
|
||||
options={comboboxOptions}
|
||||
value={currentModel}
|
||||
onValueChange={onValueChange}
|
||||
placeholder="Select model..."
|
||||
searchPlaceholder="Filter models..."
|
||||
emptyMessage="No models found."
|
||||
showSearch={modelOptions.length > 5}
|
||||
triggerClassName="h-7 gap-1 px-2 text-xs w-auto hover:bg-muted/40 whitespace-nowrap"
|
||||
className="min-w-[280px]"
|
||||
plainTrigger
|
||||
popoverSide="top"
|
||||
popoverAlign="end"
|
||||
/>
|
||||
);
|
||||
});
|
||||
|
||||
@@ -172,6 +172,7 @@ export function useMessageHandler({
|
||||
type: att.type,
|
||||
data: att.data,
|
||||
mime_type: att.mime_type,
|
||||
name: att.name,
|
||||
}));
|
||||
await queue(taskId, finalMessage, modelToSend, planModeEnabled, queueAttachments);
|
||||
return;
|
||||
|
||||
@@ -58,6 +58,24 @@ export async function openSessionFolder(sessionId: string, options?: ApiRequestO
|
||||
});
|
||||
}
|
||||
|
||||
export async function setSessionMode(sessionId: string, modeId: string) {
|
||||
return fetchJson<{ ok: boolean }>(`/api/v1/task-sessions/${sessionId}/set-mode`, {
|
||||
init: { method: "POST", body: JSON.stringify({ mode_id: modeId }) },
|
||||
});
|
||||
}
|
||||
|
||||
export async function setSessionModel(sessionId: string, modelId: string) {
|
||||
return fetchJson<{ ok: boolean }>(`/api/v1/task-sessions/${sessionId}/set-model`, {
|
||||
init: { method: "POST", body: JSON.stringify({ model_id: modelId }) },
|
||||
});
|
||||
}
|
||||
|
||||
export async function authenticateSession(sessionId: string, methodId: string) {
|
||||
return fetchJson<{ ok: boolean }>(`/api/v1/task-sessions/${sessionId}/authenticate`, {
|
||||
init: { method: "POST", body: JSON.stringify({ method_id: methodId }) },
|
||||
});
|
||||
}
|
||||
|
||||
export { launchSession, type LaunchSessionResponse } from "@/lib/services/session-launch-service";
|
||||
export {
|
||||
buildPRPrepareRequest,
|
||||
|
||||
@@ -490,14 +490,14 @@ const CHAT_DRAFT_CONTENT_KEY = "kandev.chatDraft.content";
|
||||
const CHAT_DRAFT_ATTACHMENTS_KEY = "kandev.chatDraft.attachments";
|
||||
const CHAT_INPUT_HEIGHT_KEY = "kandev.chatInput.height";
|
||||
|
||||
/** Stored attachment — same as ImageAttachment but without `preview` (reconstructed on load) */
|
||||
type StoredImageAttachment = {
|
||||
/** Stored attachment — same as FileAttachment but without `preview` (reconstructed on load) */
|
||||
type StoredFileAttachment = {
|
||||
id: string;
|
||||
data: string;
|
||||
mimeType: string;
|
||||
fileName: string;
|
||||
size: number;
|
||||
width: number;
|
||||
height: number;
|
||||
isImage: boolean;
|
||||
};
|
||||
|
||||
export function getChatDraftText(sessionId: string): string {
|
||||
@@ -525,8 +525,8 @@ export function setChatDraftContent(sessionId: string, content: unknown): void {
|
||||
}
|
||||
}
|
||||
|
||||
export function getChatDraftAttachments(sessionId: string): StoredImageAttachment[] {
|
||||
return getSessionStorage<StoredImageAttachment[]>(
|
||||
export function getChatDraftAttachments(sessionId: string): StoredFileAttachment[] {
|
||||
return getSessionStorage<StoredFileAttachment[]>(
|
||||
`${CHAT_DRAFT_ATTACHMENTS_KEY}.${sessionId}`,
|
||||
[],
|
||||
);
|
||||
@@ -538,24 +538,24 @@ export function setChatDraftAttachments(
|
||||
id: string;
|
||||
data: string;
|
||||
mimeType: string;
|
||||
fileName: string;
|
||||
size: number;
|
||||
width: number;
|
||||
height: number;
|
||||
isImage: boolean;
|
||||
preview?: string;
|
||||
}>,
|
||||
): void {
|
||||
if (attachments.length === 0) {
|
||||
removeSessionStorage(`${CHAT_DRAFT_ATTACHMENTS_KEY}.${sessionId}`);
|
||||
} else {
|
||||
// Strip `preview` to halve storage cost — reconstructed on load
|
||||
const stored: StoredImageAttachment[] = attachments.map(
|
||||
({ id, data, mimeType, size, width, height }) => ({
|
||||
// Strip `preview` to halve storage cost — reconstructed on load for images
|
||||
const stored: StoredFileAttachment[] = attachments.map(
|
||||
({ id, data, mimeType, fileName, size, isImage }) => ({
|
||||
id,
|
||||
data,
|
||||
mimeType,
|
||||
fileName,
|
||||
size,
|
||||
width,
|
||||
height,
|
||||
isImage,
|
||||
}),
|
||||
);
|
||||
setSessionStorage(`${CHAT_DRAFT_ATTACHMENTS_KEY}.${sessionId}`, stored);
|
||||
@@ -563,12 +563,15 @@ export function setChatDraftAttachments(
|
||||
}
|
||||
|
||||
/**
|
||||
* Reconstruct the `preview` data URL from stored attachment data.
|
||||
* Reconstruct the `preview` data URL from stored attachment data (images only).
|
||||
*/
|
||||
export function restoreAttachmentPreview(
|
||||
att: StoredImageAttachment,
|
||||
): StoredImageAttachment & { preview: string } {
|
||||
return { ...att, preview: `data:${att.mimeType};base64,${att.data}` };
|
||||
att: StoredFileAttachment,
|
||||
): StoredFileAttachment & { preview?: string } {
|
||||
if (att.isImage) {
|
||||
return { ...att, preview: `data:${att.mimeType};base64,${att.data}` };
|
||||
}
|
||||
return att;
|
||||
}
|
||||
|
||||
export function getChatInputHeight(sessionId: string): number | null {
|
||||
|
||||
@@ -82,6 +82,10 @@ export const defaultSessionRuntimeState: SessionRuntimeSliceState = {
|
||||
agents: { agents: [] },
|
||||
availableCommands: { bySessionId: {} },
|
||||
sessionMode: { bySessionId: {} },
|
||||
agentCapabilities: { bySessionId: {} },
|
||||
sessionModels: { bySessionId: {} },
|
||||
promptUsage: { bySessionId: {} },
|
||||
sessionTodos: { bySessionId: {} },
|
||||
userShells: { bySessionId: {}, loading: {}, loaded: {} },
|
||||
prepareProgress: { bySessionId: {} },
|
||||
};
|
||||
@@ -228,13 +232,33 @@ export const createSessionRuntimeSlice: StateCreator<
|
||||
set((draft) => {
|
||||
delete draft.availableCommands.bySessionId[sessionId];
|
||||
}),
|
||||
setSessionMode: (sessionId, modeId) =>
|
||||
setSessionMode: (sessionId, modeId, availableModes) =>
|
||||
set((draft) => {
|
||||
draft.sessionMode.bySessionId[sessionId] = modeId;
|
||||
const existing = draft.sessionMode.bySessionId[sessionId];
|
||||
draft.sessionMode.bySessionId[sessionId] = {
|
||||
currentModeId: modeId,
|
||||
availableModes: availableModes ?? existing?.availableModes ?? [],
|
||||
};
|
||||
}),
|
||||
clearSessionMode: (sessionId) =>
|
||||
set((draft) => {
|
||||
delete draft.sessionMode.bySessionId[sessionId];
|
||||
}),
|
||||
setAgentCapabilities: (sessionId, caps) =>
|
||||
set((draft) => {
|
||||
draft.agentCapabilities.bySessionId[sessionId] = caps;
|
||||
}),
|
||||
setSessionModels: (sessionId, data) =>
|
||||
set((draft) => {
|
||||
draft.sessionModels.bySessionId[sessionId] = data;
|
||||
}),
|
||||
setPromptUsage: (sessionId, usage) =>
|
||||
set((draft) => {
|
||||
draft.promptUsage.bySessionId[sessionId] = usage;
|
||||
}),
|
||||
setSessionTodos: (sessionId, entries) =>
|
||||
set((draft) => {
|
||||
draft.sessionTodos.bySessionId[sessionId] = entries;
|
||||
}),
|
||||
...buildUserShellActions(set),
|
||||
});
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user