Files
pipelines/internal/codex/items.go
T

129 lines
3.0 KiB
Go

package codex
import (
"encoding/json"
"strings"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
func rawText(raw json.RawMessage) string {
if len(raw) == 0 || string(raw) == "null" {
return ""
}
var text string
if json.Unmarshal(raw, &text) == nil {
return text
}
return string(raw)
}
func boundedToolText(text string) string {
const limit = 64 << 10
if len(text) > limit {
return text[:limit] + "\n… (tool detail truncated at 64 KiB)"
}
return text
}
func (i item) reasoningText() string {
if i.Text != "" {
return i.Text
}
var content []string
_ = json.Unmarshal(i.Content, &content)
return strings.Join(append(append([]string{}, i.Summary...), content...), "\n\n")
}
func (i item) toolPart(completed bool) protocol.ChatPart {
name := i.Type
if i.Name != "" {
name = i.Name
}
if i.Tool != "" {
name = i.Tool
}
if i.Server != "" {
name = i.Server + "/" + name
} else if i.Namespace != "" {
name = i.Namespace + "/" + name
}
var input any = i.Input
if len(i.Arguments) > 0 {
input = i.Arguments
}
switch i.Type {
case "commandExecution":
name = "shell"
input = map[string]any{"command": i.Command}
case "webSearch":
name = "websearch"
if i.Query != "" {
input = map[string]any{"query": i.Query}
} else {
input = i.Raw
}
case "fileChange":
input = map[string]any{"changes": i.Changes}
}
if input == nil {
input = map[string]any{"type": i.Type, "detail": i.Raw}
}
encoded, _ := json.Marshal(input)
if len(encoded) > 64<<10 {
encoded, _ = json.Marshal(map[string]any{"truncated": true, "preview": boundedToolText(string(encoded))})
}
status := protocol.ChatToolRunning
if completed {
status = protocol.ChatToolCompleted
}
message := ""
if len(i.Error) > 0 && string(i.Error) != "null" {
var detail struct {
Message string `json:"message"`
}
if json.Unmarshal(i.Error, &detail) == nil && detail.Message != "" {
message = detail.Message
} else {
message = rawText(i.Error)
}
}
if message != "" || strings.EqualFold(i.Status, "failed") || strings.EqualFold(i.Status, "declined") || (completed && i.ExitCode != nil && *i.ExitCode != 0) {
status = protocol.ChatToolError
}
state := &protocol.ChatToolState{Status: status, Input: encoded}
output := i.AggregatedOutput
for _, raw := range []json.RawMessage{i.Result, i.Output, i.ContentItems} {
if text := rawText(raw); text != "" {
if output != "" {
output += "\n"
}
output += text
}
}
if i.Text != "" {
if output != "" {
output += "\n"
}
output += i.Text
}
if output != "" {
state.Content = []protocol.ChatToolContent{{Type: "text", Text: boundedToolText(output)}}
}
if message != "" {
state.Error = &protocol.ChatError{Message: boundedToolText(message)}
}
return protocol.ChatPart{Type: protocol.ChatPartTool, ID: i.ID, Name: name, State: state}
}
func (i *item) UnmarshalJSON(raw []byte) error {
type plain item
var value plain
if err := json.Unmarshal(raw, &value); err != nil {
return err
}
*i = item(value)
i.Raw = append(json.RawMessage(nil), raw...)
return nil
}