498 lines
13 KiB
Go
498 lines
13 KiB
Go
package fs
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"ollie/agent"
|
|
"ollie/paths"
|
|
"ollie/session"
|
|
)
|
|
|
|
func requestAgentNew(ctx HandlerCtx, data []byte) ([]byte, error) {
|
|
args := strings.Fields(string(data))
|
|
ag, err := session.CreateAgent(ctx.Session.Name(), args)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("create agent: %w", err)
|
|
}
|
|
// Create AgentLog for this agent and wire up the event handler
|
|
al := NewAgentLog("")
|
|
ctx.Session.SetAgentLog(ag.ID(), al)
|
|
wireAgentEvents(ctx.Session.ID(), ag, al)
|
|
return []byte(ag.ID() + "\n"), nil
|
|
}
|
|
|
|
// agentBindings returns bindings for all agents in a session.
|
|
// The Blueprint pattern clones the structure and binds ctx.Agent + ctx.AgentLog.
|
|
func agentBindings(ctx HandlerCtx) ([]Binding, error) {
|
|
sess := ctx.Session
|
|
if sess == nil || sess.Core == nil {
|
|
return nil, nil
|
|
}
|
|
|
|
var out []Binding
|
|
for _, ag := range sess.Core.Agents() {
|
|
a := ag // capture
|
|
al := sess.AgentLogFor(a.ID())
|
|
if al == nil {
|
|
continue
|
|
}
|
|
out = append(out, Binding{
|
|
Name: a.Name(),
|
|
Aliases: []string{a.ID()},
|
|
UID: a.ID(),
|
|
GID: "agent",
|
|
Applier: func(c HandlerCtx) HandlerCtx {
|
|
c.Agent = a
|
|
c.AgentLog = al
|
|
return c
|
|
},
|
|
Rename: func(newName string) error {
|
|
a.SetName(newName)
|
|
session.PersistSession(sess.Name())
|
|
return nil
|
|
},
|
|
})
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func writeAgentPrompt(ctx HandlerCtx, data []byte) error {
|
|
input := strings.TrimSpace(string(data))
|
|
if input == "" {
|
|
return nil
|
|
}
|
|
if input == "/invalidate" {
|
|
ctx.Session.InvalidateModelsCache()
|
|
return nil
|
|
}
|
|
go func() {
|
|
ctx.Agent.Submit(ctx.Session.Ctx(), input)
|
|
ctx.AgentLog.EnsureTrailingNewline()
|
|
}()
|
|
return nil
|
|
}
|
|
|
|
func writeAgentFifoIn(ctx HandlerCtx, data []byte) error {
|
|
input := strings.TrimSpace(string(data))
|
|
if input == "" {
|
|
return nil
|
|
}
|
|
ctx.Agent.Queue(input)
|
|
return nil
|
|
}
|
|
|
|
func readAgentFifoOut(ctx HandlerCtx) ([]byte, error) {
|
|
item, ok := ctx.Agent.PopQueue()
|
|
if !ok {
|
|
return nil, nil
|
|
}
|
|
return []byte(item), nil
|
|
}
|
|
|
|
func statAgentChat() os.FileInfo {
|
|
// Note: This needs ctx but Stat doesn't receive it.
|
|
// We'll need to handle this specially or pass via closure.
|
|
// For now, return a placeholder - the real stat is done in builder.
|
|
return &SyntheticFileInfo{Name_: "chat", Mode_: 0444, Size_: 64 * 1024}
|
|
}
|
|
|
|
func readAgentChat(ctx HandlerCtx) ([]byte, error) {
|
|
ctx.AgentLog.mu.RLock()
|
|
defer ctx.AgentLog.mu.RUnlock()
|
|
data := make([]byte, len(ctx.AgentLog.log))
|
|
copy(data, ctx.AgentLog.log)
|
|
return data, nil
|
|
}
|
|
|
|
func readAgentChatText(ctx HandlerCtx) ([]byte, error) {
|
|
ctx.AgentLog.mu.RLock()
|
|
defer ctx.AgentLog.mu.RUnlock()
|
|
return stripMarkers(ctx.AgentLog.log), nil
|
|
}
|
|
|
|
func streamAgentChat(ctx HandlerCtx, cctx context.Context, base string) ([]byte, string, error) {
|
|
merged, cancel := mergeCtx(ctx, cctx)
|
|
defer cancel()
|
|
return streamChat(ctx.AgentLog, merged, base)
|
|
}
|
|
|
|
func streamAgentChatText(ctx HandlerCtx, cctx context.Context, base string) ([]byte, string, error) {
|
|
merged, cancel := mergeCtx(ctx, cctx)
|
|
defer cancel()
|
|
for {
|
|
data, nextBase, err := streamChat(ctx.AgentLog, merged, base)
|
|
if err != nil || len(data) == 0 {
|
|
return data, nextBase, err
|
|
}
|
|
stripped := stripMarkers(data)
|
|
if len(stripped) > 0 {
|
|
return stripped, nextBase, nil
|
|
}
|
|
// All data was markers/fences — advance base and wait for more.
|
|
base = nextBase
|
|
}
|
|
}
|
|
|
|
// stripMarkers removes [[[...]]] marker lines and source fence delimiter lines
|
|
// from raw chat data. Content inside fences is preserved — only the ``` lines
|
|
// themselves are stripped. Partial lines (no trailing \n) are always passed
|
|
// through — they are streaming content, never markers.
|
|
func stripMarkers(data []byte) []byte {
|
|
var out []byte
|
|
for len(data) > 0 {
|
|
// Find next newline
|
|
nl := bytes.IndexByte(data, '\n')
|
|
if nl < 0 {
|
|
// Partial line at end — always content, emit it
|
|
out = append(out, data...)
|
|
break
|
|
}
|
|
line := data[:nl+1] // includes \n
|
|
data = data[nl+1:]
|
|
|
|
// Drop [[[...]]] marker lines
|
|
trimmed := bytes.TrimRight(line, "\n")
|
|
if len(trimmed) >= 7 && bytes.HasPrefix(trimmed, []byte("[[[")) && bytes.HasSuffix(trimmed, []byte("]]]")) {
|
|
continue
|
|
}
|
|
|
|
// Drop bare fence delimiter lines (``` or ```lang).
|
|
// These are the source fences wrapping tool output.
|
|
// Keep fences with 4+ backticks (````), those are user/assistant markdown.
|
|
stripped := bytes.TrimSpace(trimmed)
|
|
if bytes.HasPrefix(stripped, []byte("```")) && !bytes.HasPrefix(stripped, []byte("````")) {
|
|
continue
|
|
}
|
|
|
|
out = append(out, line...)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func blockAgentStateWait(ctx HandlerCtx, cctx context.Context, base string) ([]byte, string, error) {
|
|
merged, cancel := mergeCtx(ctx, cctx)
|
|
defer cancel()
|
|
if base == "" {
|
|
base = ctx.Agent.State()
|
|
}
|
|
v, ok := ctx.Agent.WaitChange(merged, agent.WatchState, base)
|
|
if !ok {
|
|
st := ctx.Agent.State()
|
|
return []byte(st + "\n"), st, nil
|
|
}
|
|
return []byte(v + "\n"), v, nil
|
|
}
|
|
|
|
func readAgentLog(ctx HandlerCtx) ([]byte, error) {
|
|
const maxWindow = 64 * 1024
|
|
ctx.AgentLog.mu.RLock()
|
|
log := ctx.AgentLog.log
|
|
start := 0
|
|
if len(log) > maxWindow {
|
|
start = len(log) - maxWindow
|
|
}
|
|
data := make([]byte, len(log)-start)
|
|
copy(data, log[start:])
|
|
ctx.AgentLog.mu.RUnlock()
|
|
return data, nil
|
|
}
|
|
|
|
func readAgentPlan(ctx HandlerCtx) ([]byte, error) {
|
|
ctx.AgentLog.mu.RLock()
|
|
data := make([]byte, len(ctx.AgentLog.plan))
|
|
copy(data, ctx.AgentLog.plan)
|
|
ctx.AgentLog.mu.RUnlock()
|
|
return data, nil
|
|
}
|
|
|
|
func writeAgentPlan(ctx HandlerCtx, data []byte) error {
|
|
ctx.AgentLog.mu.Lock()
|
|
ctx.AgentLog.plan = make([]byte, len(data))
|
|
copy(ctx.AgentLog.plan, data)
|
|
ctx.AgentLog.mu.Unlock()
|
|
return nil
|
|
}
|
|
|
|
func readAgentCfg(ctx HandlerCtx) ([]byte, error) {
|
|
ctx.AgentLog.mu.RLock()
|
|
defer ctx.AgentLog.mu.RUnlock()
|
|
p := ctx.Agent.GenParams()
|
|
var sb strings.Builder
|
|
fmt.Fprintf(&sb, "name=%s\n", ctx.Session.ID())
|
|
fmt.Fprintf(&sb, "backend=%s\n", ctx.Agent.BackendName())
|
|
fmt.Fprintf(&sb, "model=%s\n", ctx.Agent.ModelName())
|
|
fmt.Fprintf(&sb, "id=%s\n", ctx.Agent.ID())
|
|
fmt.Fprintf(&sb, "profile=%s\n", ctx.Agent.Profile())
|
|
fmt.Fprintf(&sb, "displayName=%s\n", ctx.Agent.Name())
|
|
fmt.Fprintf(&sb, "cwd=%s\n", ctx.Agent.Cwd())
|
|
fmt.Fprintf(&sb, "remote=%s\n", ctx.AgentLog.remote)
|
|
fmt.Fprintf(&sb, "maxTokens=%d\n", p.MaxTokens)
|
|
if p.Temperature != nil {
|
|
fmt.Fprintf(&sb, "temperature=%g\n", *p.Temperature)
|
|
}
|
|
if p.TopP != nil {
|
|
fmt.Fprintf(&sb, "topP=%g\n", *p.TopP)
|
|
}
|
|
if p.TopK != nil {
|
|
fmt.Fprintf(&sb, "topK=%d\n", *p.TopK)
|
|
}
|
|
if len(p.Stop) > 0 {
|
|
fmt.Fprintf(&sb, "stop=%s\n", strings.Join(p.Stop, ","))
|
|
}
|
|
return []byte(sb.String()), nil
|
|
}
|
|
|
|
func writeAgentCfg(ctx HandlerCtx, data []byte) error {
|
|
input := strings.TrimSpace(string(data))
|
|
if input == "" {
|
|
return nil
|
|
}
|
|
parts := strings.SplitN(input, "=", 2)
|
|
if len(parts) != 2 {
|
|
return fmt.Errorf("invalid cfg format (expected key=value)")
|
|
}
|
|
switch parts[0] {
|
|
case "name":
|
|
if strings.TrimSpace(parts[1]) != "" {
|
|
ctx.Agent.SetName(strings.TrimSpace(parts[1]))
|
|
}
|
|
default:
|
|
return fmt.Errorf("unknown cfg key: %s", parts[0])
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func requestAgentCtl(ctx HandlerCtx, data []byte) ([]byte, error) {
|
|
return rdwrDispatch(agentCtlHandlers)(ctx, data)
|
|
}
|
|
|
|
var agentCtlHandlers = map[string]rdwrHandler{
|
|
"kill": func(ctx HandlerCtx, _ []string) ([]byte, error) {
|
|
if ctx.Session.Core != nil {
|
|
ctx.Session.Core.RemoveAgent(ctx.Agent.ID())
|
|
session.PublishEvent("session."+ctx.Session.ID()+".agent."+ctx.Agent.ID()+".kill", "")
|
|
}
|
|
return []byte("ok\n"), nil
|
|
},
|
|
"stop": func(ctx HandlerCtx, _ []string) ([]byte, error) {
|
|
ctx.Agent.Interrupt(agent.ErrInterrupted)
|
|
return []byte("ok\n"), nil
|
|
},
|
|
"compact": func(ctx HandlerCtx, _ []string) ([]byte, error) {
|
|
if err := ctx.Agent.Compact(ctx.Session.Ctx()); err != nil {
|
|
return nil, err
|
|
}
|
|
return []byte("ok\n"), nil
|
|
},
|
|
"clear": func(ctx HandlerCtx, _ []string) ([]byte, error) {
|
|
if err := ctx.Agent.Clear(); err != nil {
|
|
return nil, err
|
|
}
|
|
return []byte("ok\n"), nil
|
|
},
|
|
"inject": func(ctx HandlerCtx, args []string) ([]byte, error) {
|
|
text := strings.Join(args, " ")
|
|
if text == "" {
|
|
return nil, fmt.Errorf("inject requires text")
|
|
}
|
|
ctx.Agent.InjectRewrite(text)
|
|
return []byte("ok\n"), nil
|
|
},
|
|
"agent": func(ctx HandlerCtx, args []string) ([]byte, error) {
|
|
if len(args) == 0 {
|
|
return []byte(ctx.Agent.Profile() + "\n"), nil
|
|
}
|
|
if err := ctx.Agent.SwitchProfile(args[0]); err != nil {
|
|
return nil, err
|
|
}
|
|
return []byte(args[0] + "\n"), nil
|
|
},
|
|
"model": func(ctx HandlerCtx, args []string) ([]byte, error) {
|
|
if len(args) == 0 {
|
|
if be := ctx.Agent.Backend(); be != nil {
|
|
return []byte(be.Model() + "\n"), nil
|
|
}
|
|
return nil, nil
|
|
}
|
|
if be := ctx.Agent.Backend(); be != nil {
|
|
be.SetModel(strings.Join(args, " "))
|
|
}
|
|
return []byte(strings.Join(args, " ") + "\n"), nil
|
|
},
|
|
"models": func(ctx HandlerCtx, _ []string) ([]byte, error) {
|
|
return []byte(ctx.Session.CachedListModels() + "\n"), nil
|
|
},
|
|
"tools": func(ctx HandlerCtx, _ []string) ([]byte, error) {
|
|
if ctx.Session.ToolsConn() == nil {
|
|
return []byte("(no tool server)\n"), nil
|
|
}
|
|
loaded, err := ctx.Session.ToolsConn().ListTools()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var sb strings.Builder
|
|
for _, ti := range loaded {
|
|
if ti.Description != "" {
|
|
fmt.Fprintf(&sb, "%-20s %s\n", ti.Name, ti.Description)
|
|
} else {
|
|
sb.WriteString(ti.Name + "\n")
|
|
}
|
|
}
|
|
return []byte(sb.String()), nil
|
|
},
|
|
"tool_load": func(ctx HandlerCtx, args []string) ([]byte, error) {
|
|
if len(args) == 0 {
|
|
return nil, fmt.Errorf("tool_load requires a tool name")
|
|
}
|
|
if err := ctx.Session.LoadTool(args[0], ctx.Agent); err != nil {
|
|
return nil, err
|
|
}
|
|
return []byte(args[0] + "\n"), nil
|
|
},
|
|
"backend": func(ctx HandlerCtx, args []string) ([]byte, error) {
|
|
if len(args) == 0 {
|
|
if be := ctx.Agent.Backend(); be != nil {
|
|
return []byte(be.Name() + "\n"), nil
|
|
}
|
|
return nil, nil
|
|
}
|
|
return nil, fmt.Errorf("backend switching not supported via ctl; use cfg")
|
|
},
|
|
"name": func(ctx HandlerCtx, args []string) ([]byte, error) {
|
|
if len(args) == 0 {
|
|
return []byte(ctx.Agent.Name() + "\n"), nil
|
|
}
|
|
ctx.Agent.SetName(strings.Join(args, " "))
|
|
return []byte(strings.Join(args, " ") + "\n"), nil
|
|
},
|
|
"cwd": func(ctx HandlerCtx, args []string) ([]byte, error) {
|
|
if len(args) == 0 {
|
|
return []byte(ctx.Agent.Cwd() + "\n"), nil
|
|
}
|
|
dir := paths.ExpandHome(strings.Join(args, " "))
|
|
if _, err := os.Stat(dir); err != nil {
|
|
return nil, fmt.Errorf("cwd: %w", err)
|
|
}
|
|
ctx.Agent.SetCWD(dir)
|
|
return []byte(dir + "\n"), nil
|
|
},
|
|
"systemprompt": func(ctx HandlerCtx, _ []string) ([]byte, error) {
|
|
return []byte(ctx.Agent.SystemPrompt() + "\n"), nil
|
|
},
|
|
"help": func(_ HandlerCtx, _ []string) ([]byte, error) {
|
|
return []byte(`stop — interrupt running agent
|
|
compact — compact context
|
|
clear — clear history
|
|
inject <text> — inject prompt mid-turn (overwrites pending)
|
|
agent [name] — show/switch agent profile
|
|
model [name] — show/switch model
|
|
models — list available models
|
|
tools — list loaded tools
|
|
tool_load <n> — load a tool
|
|
cwd [path] — show/change working directory
|
|
name [name] — show/rename agent
|
|
backend — show backend
|
|
systemprompt — show rendered system prompt
|
|
help — this message
|
|
`), nil
|
|
},
|
|
}
|
|
|
|
func readAgentStats(ctx HandlerCtx) ([]byte, error) {
|
|
s := "usage=" + ctx.Agent.UsageStr() + "\n" +
|
|
"cost=" + ctx.Agent.CostStr() + "\n" +
|
|
"ctxsz=" + ctx.Agent.CtxSz() + "\n"
|
|
return []byte(s), nil
|
|
}
|
|
|
|
func readAgentName(ctx HandlerCtx) ([]byte, error) {
|
|
return []byte(ctx.Agent.Name() + "\n"), nil
|
|
}
|
|
|
|
func writeAgentName(ctx HandlerCtx, data []byte) error {
|
|
newName := strings.TrimSpace(string(data))
|
|
if newName == "" {
|
|
return nil
|
|
}
|
|
ctx.Agent.SetName(newName)
|
|
session.PersistSession(ctx.Session.Name())
|
|
return nil
|
|
}
|
|
|
|
func readAgentID(ctx HandlerCtx) ([]byte, error) {
|
|
return []byte(ctx.Agent.ID() + "\n"), nil
|
|
}
|
|
|
|
func streamChat(al *AgentLog, cctx context.Context, base string) ([]byte, string, error) {
|
|
ctx, cancel := context.WithCancel(cctx)
|
|
defer cancel()
|
|
context.AfterFunc(ctx, func() { al.chatCond.Broadcast() })
|
|
|
|
var offset int
|
|
if base != "" {
|
|
fmt.Sscanf(base, "%d", &offset)
|
|
} else {
|
|
al.mu.RLock()
|
|
offset = len(al.log)
|
|
al.mu.RUnlock()
|
|
}
|
|
|
|
al.mu.RLock()
|
|
for len(al.log) <= offset {
|
|
if ctx.Err() != nil {
|
|
al.mu.RUnlock()
|
|
return nil, "", nil
|
|
}
|
|
al.chatCond.Wait()
|
|
}
|
|
|
|
data := make([]byte, len(al.log)-offset)
|
|
copy(data, al.log[offset:])
|
|
newOffset := len(al.log)
|
|
al.mu.RUnlock()
|
|
|
|
return data, fmt.Sprintf("%d", newOffset), nil
|
|
}
|
|
|
|
// processBindings returns bindings for detached processes.
|
|
func processBindings(ctx HandlerCtx) ([]Binding, error) {
|
|
if ctx.Agent == nil {
|
|
return nil, nil
|
|
}
|
|
procs := ctx.Agent.ListDetached()
|
|
out := make([]Binding, len(procs))
|
|
for i, p := range procs {
|
|
pid := p.PID // capture
|
|
out[i] = Binding{
|
|
Name: strconv.Itoa(p.PID),
|
|
Applier: func(c HandlerCtx) HandlerCtx {
|
|
c.Data = pid
|
|
return c
|
|
},
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func readProcess(ctx HandlerCtx) ([]byte, error) {
|
|
pid := ctx.Data.(int)
|
|
output, err := ctx.Agent.GetDetachedOutput(pid)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return []byte(output), nil
|
|
}
|
|
|
|
func removeProcess(ctx HandlerCtx) error {
|
|
pid := ctx.Data.(int)
|
|
if !ctx.Agent.DismissDetached(pid) {
|
|
return fmt.Errorf("process %d not found or still running", pid)
|
|
}
|
|
return nil
|
|
}
|