Agent Log: show tool call arguments inline instead of JSON blob

1: # Omni
2: 
3: The Omni project is to leverage automation and asymmetries to create wealth.
4: 
5: ## Critical Rules for AI Agents
6: 
7: **CRITICAL**: This project uses `jr task` for ALL issue tracking. You MUST follow these rules:
8: 
9: - ✅ Use `jr task` for ALL task/TODO tracking (`jr task create ... --json`)
10: - ✅ Link discovered work with `--discovered-from=<parent-id>`
11: - ✅ File bugs IMMEDIATELY when you discover unexpected behavior
12: - ✅ Add facts to the knowledge base when you learn something useful (`jr facts add ...`)
13: - ✅ Run `jr task ready --json` before asking "what should I work on?"
14: - ✅ Store AI planning docs in `_/llm` directory (NEVER in repo root)
15: - ❌ Do NOT use `todo_write` tool
16: - ❌ Do NOT create markdown TODO lists or task checklists
17: - ❌ Do NOT put TODO/FIXME comments in code
18: 
19: ## Cheat Sheet
20: 
21: **Standard workflow:**
22: ```bash
23: # 1. Find ready work
24: jr task ready --json
25: 
26: # 2. Claim a task
27: jr task update <id> in-progress --json
28: 
29: # 3. During work: create discovered issues
30: jr task create "Fix type error found" --discovered-from=<current-id> --json
31: 
32: # 4. Complete the task
33: jr task update <id> done --json
34: ```
35: 
36: **Bug Discovery:**
37: ```bash
38: # Create a task immediately
39: jr task create "Command X fails when Y" --discovered-from=<current-task-id> --json
40: ```
41: 
42: ## Directory Structure
43: 
44: - **`_/`** (cabdir) - All ephemeral/generated files. This directory is gitignored.
45:   - `_/llm/` - AI planning docs and agent logs
46:   - `_/tmp/` - Temporary files, test databases, scratch data
47: - Never create dotfile directories (like `.tasks/`) in the repo root
48: 
49: ## Common Commands
50: 
51: **Build:**
52: ```bash
53: bild Omni/Jr.hs              # Build a Haskell namespace
54: bild Biz/Cloud/Api.py        # Build a Python namespace
55: ```
56: 
57: **Lint and Format:**
58: ```bash
59: lint Omni/Cli.hs             # Lint a file (DO NOT use hlint directly)
60: lint --fix **/*.py           # Lint and auto-fix Python files
61: ```
62: 
63: **Type Check:**
64: ```bash
65: typecheck.sh Omni/Bild/Example.py   # Run mypy on Python files
66: ```
67: 
68: **Test:**
69: ```bash
70: bild --test Omni/Jr.hs       # Build and run tests for a namespace
71: ```
72: 
73: **Run:**
74: ```bash
75: Omni/Ide/run.sh Omni/Jr.hs   # Build (if needed) and run
76: ```
77: 
78: ## Documentation
79: 
80: - **Project Context**: [README.md](README.md) - Goals, source layout, and coding conventions.
81: - **Task Manager**: [`Omni/Task/README.md`](Omni/Task/README.md) - Detailed usage, dependency management, and agent best practices.
82: - **Build Tool (Bild)**: [`Omni/Bild/README.md`](Omni/Bild/README.md) - How to use `bild` and manage dependencies.
83: - **Development Tools**: [`Omni/Ide/README.md`](Omni/Ide/README.md) - `run.sh`, `lint`, `repl.sh`, git workflow.

./Omni/Jr/Web.hs:2422:            "ToolCall" -> renderToolCallTimelineEvent content actor timestamp now
./Omni/Jr/Web.hs:2527:renderToolCallTimelineEvent :: (Monad m) => Text -> TaskCore.CommentAuthor -> UTCTime -> UTCTime -> Lucid.HtmlT m ()
./Omni/Jr/Web.hs:2528:renderToolCallTimelineEvent content _actor timestamp now =
./Omni/Agent/Engine.hs:63:    [ Test.unit "Tool JSON roundtrip" <| do
./Omni/Agent/Engine.hs:68:                  toolJsonSchema = Aeson.object ["type" .= ("object" :: Text), "properties" .= Aeson.object []],
./Omni/Agent/Engine.hs:97:                  toolJsonSchema = Aeson.object [],
./Omni/Agent/Engine.hs:104:                  toolJsonSchema = Aeson.object [],
./Omni/Agent/Engine.hs:149:      Test.unit "ToolCall JSON roundtrip" <| do
./Omni/Agent/Engine.hs:227:    toolJsonSchema :: Aeson.Value,
./Omni/Agent/Engine.hs:263:      toolApiParameters = toolJsonSchema t
./Omni/Agent/Tools.hs:14:-- All tools return structured JSON results.
./Omni/Agent/Tools.hs:57:        let schema = Engine.toolJsonSchema readFileTool
./Omni/Agent/Tools.hs:62:        let schema = Engine.toolJsonSchema writeFileTool
./Omni/Agent/Tools.hs:67:        let schema = Engine.toolJsonSchema editFileTool
./Omni/Agent/Tools.hs:72:        let schema = Engine.toolJsonSchema runBashTool
./Omni/Agent/Tools.hs:77:        let schema = Engine.toolJsonSchema searchCodebaseTool
./Omni/Agent/Tools.hs:118:      Test.unit "ToolResult success JSON roundtrip" <| do
./Omni/Agent/Tools.hs:123:      Test.unit "ToolResult failure JSON roundtrip" <| do
./Omni/Agent/Tools.hs:245:      Engine.toolJsonSchema =
./Omni/Agent/Tools.hs:310:      Engine.toolJsonSchema =
./Omni/Agent/Tools.hs:371:      Engine.toolJsonSchema =
./Omni/Agent/Tools.hs:457:      Engine.toolJsonSchema =
./Omni/Agent/Tools.hs:546:      Engine.toolJsonSchema =

2520:     Lucid.div_ [Lucid.class_ "event-content thought-bubble markdown-content"] <| do
2521:       let truncated = Text.take 2000 content
2522:           isTruncated = Text.length content > 2000
2523:       renderMarkdown truncated
2524:       when isTruncated <| Lucid.span_ [Lucid.class_ "event-truncated"] "..."
2525: 
2526: -- | Render tool call event
2527: renderToolCallTimelineEvent :: (Monad m) => Text -> TaskCore.CommentAuthor -> UTCTime -> UTCTime -> Lucid.HtmlT m ()
2528: renderToolCallTimelineEvent content _actor timestamp now =
2529:   let (toolName, args) = parseToolCallContent content
2530:    in Lucid.details_ [Lucid.class_ "timeline-tool-call"] <| do
2531:         Lucid.summary_ <| do
2532:           Lucid.span_ [Lucid.class_ "event-icon"] "🔧"
2533:           Lucid.span_ [Lucid.class_ "tool-name"] (Lucid.toHtml toolName)
2534:           renderActorLabel TaskCore.Junior
2535:           renderRelativeTimestamp now timestamp
2536:         Lucid.div_ [Lucid.class_ "event-content tool-args"] <| do
2537:           renderCollapsibleOutput args
2538: 
2539: -- | Render tool result event (collapsed by default)
2540: renderToolResultTimelineEvent :: (Monad m) => Text -> TaskCore.CommentAuthor -> UTCTime -> UTCTime -> Lucid.HtmlT m ()
2541: renderToolResultTimelineEvent content _actor timestamp now =
2542:   let lineCount = length (Text.lines content)
2543:    in Lucid.details_ [Lucid.class_ "timeline-tool-result"] <| do
2544:         Lucid.summary_ <| do
2545:           Lucid.span_ [Lucid.class_ "event-icon"] "📄"
2546:           Lucid.span_ [Lucid.class_ "event-label"] "Result"
2547:           when (lineCount > 1)
2548:             <| Lucid.span_ [Lucid.class_ "line-count"] (Lucid.toHtml (tshow lineCount <> " lines"))
2549:           renderRelativeTimestamp now timestamp
2550:         Lucid.pre_ [Lucid.class_ "event-content tool-output"] (renderDecodedToolResult content)
2551: 
2552: -- | Render cost event (inline)
2553: renderCostTimelineEvent :: (Monad m) => Text -> Lucid.HtmlT m ()
2554: renderCostTimelineEvent content =
2555:   Lucid.div_ [Lucid.class_ "timeline-cost"] <| do
2556:     Lucid.span_ [Lucid.class_ "event-icon"] "💰"
2557:     Lucid.span_ [Lucid.class_ "cost-text"] (Lucid.toHtml content)
2558: 
2559: -- | Render checkpoint event
2560: renderCheckpointEvent :: (Monad m) => Text -> TaskCore.CommentAuthor -> UTCTime -> UTCTime -> Lucid.HtmlT m ()
2561: renderCheckpointEvent content actor timestamp now =
2562:   Lucid.div_ [Lucid.class_ "timeline-checkpoint"] <| do
2563:     Lucid.div_ [Lucid.class_ "event-header"] <| do
2564:       Lucid.span_ [Lucid.class_ "event-icon"] "📍"
2565:       Lucid.span_ [Lucid.class_ "event-label"] "Checkpoint"
2566:       renderActorLabel actor
2567:       renderRelativeTimestamp now timestamp
2568:     Lucid.div_ [Lucid.class_ "event-content checkpoint-content"] (Lucid.toHtml content)
2569: 
2570: -- | Render guardrail event

2592: parseToolCallContent :: Text -> (Text, Text)
2593: parseToolCallContent content =
2594:   case Text.breakOn ":" content of
2595:     (name, rest)
2596:       | Text.null rest -> (content, "")
2597:       | otherwise -> (Text.strip name, Text.strip (Text.drop 1 rest))
2598: 
2599: renderCollapsibleOutput :: (Monad m) => Text -> Lucid.HtmlT m ()
2600: renderCollapsibleOutput content =
2601:   let lineCount = length (Text.lines content)
2602:    in if lineCount > 20
2603:         then
2604:           Lucid.details_ [Lucid.class_ "output-collapsible"] <| do
2605:             Lucid.summary_ (Lucid.toHtml (tshow lineCount <> " lines"))
2606:             Lucid.pre_ [Lucid.class_ "tool-output-pre"] (Lucid.toHtml content)
2607:         else Lucid.pre_ [Lucid.class_ "tool-output-pre"] (Lucid.toHtml content)
2608: 
2609: -- | Decode JSON tool result and render in a user-friendly way
2610: renderDecodedToolResult :: (Monad m) => Text -> Lucid.HtmlT m ()
2611: renderDecodedToolResult content =
2612:   case Aeson.decode (LBS.fromStrict (str content)) of
2613:     Just (Aeson.Object obj) ->
2614:       case KeyMap.lookup "output" obj of
2615:         Just (Aeson.String output) -> Lucid.toHtml output
2616:         _ -> Lucid.toHtml content -- Fallback to raw if no output field
2617:     _ -> Lucid.toHtml content -- Fallback to raw if not JSON
2618: 
2619: timelineScrollScript :: (Monad m) => Lucid.HtmlT m ()
2620: timelineScrollScript =
2621:   Lucid.script_
2622:     [ Lucid.type_ "text/javascript"
2623:     ]
2624:     ( Text.unlines
2625:         [ "(function() {",
2626:           "  var log = document.querySelector('.timeline-events');",
2627:           "  if (log) {",
2628:           "    log.scrollTop = log.scrollHeight;",
2629:           "  }",
2630:           "})();"
2631:         ]
2632:     )
2633: 
2634: instance Lucid.ToHtml AgentEventsPartial where
2635:   toHtmlRaw = Lucid.toHtml
2636:   toHtml (AgentEventsPartial events isInProgress now) = do
2637:     Lucid.h3_ <| do
2638:       Lucid.toHtml ("Timeline (" <> tshow (length events) <> ")")
2639:       when isInProgress <| Lucid.span_ [Lucid.class_ "timeline-live"] " LIVE"
2640:     if null events

510: 
511:   -- Parse and format the content based on event type
512:   let formatted = case eventType of
513:         "Assistant" -> formatAssistant content
514:         "ToolCall" -> formatToolCall content
515:         "ToolResult" -> formatToolResult content
516:         "Cost" -> formatCost content
517:         "Error" -> formatError content
518:         "Complete" -> "Complete"
519:         _ -> eventType <> ": " <> content
520: 
521:   putText ("[" <> timeStr <> "] " <> formatted)
522: 
523: -- Format Assistant messages
524: formatAssistant :: Text -> Text
525: formatAssistant content =
526:   case Aeson.decode (BLC.pack <| T.unpack content) of
527:     Just (Aeson.String msg) -> "Assistant: " <> truncateText 200 msg
528:     _ -> "Assistant: " <> truncateText 200 content
529: 
530: -- Format ToolCall events
531: formatToolCall :: Text -> Text
532: formatToolCall content =
533:   case Aeson.decode (BLC.pack <| T.unpack content) of
534:     Just (Aeson.String msg) -> "Tool: " <> msg
535:     Just (Aeson.Object obj) ->
536:       let toolName = case KM.lookup "tool" obj of
537:             Just (Aeson.String n) -> n
538:             _ -> "<unknown>"
539:           args = case KM.lookup "args" obj of
540:             Just val -> " " <> TE.decodeUtf8 (BLC.toStrict (Aeson.encode val))
541:             _ -> ""
542:        in "Tool: " <> toolName <> args
543:     _ -> "Tool: " <> truncateText 100 content
544: 
545: -- Format ToolResult events
546: formatToolResult :: Text -> Text
547: formatToolResult content =
548:   case Aeson.decode (BLC.pack <| T.unpack content) of
549:     Just (Aeson.Object obj) ->
550:       let toolName = case KM.lookup "tool" obj of
551:             Just (Aeson.String n) -> n
552:             _ -> "<unknown>"
553:           success = case KM.lookup "success" obj of
554:             Just (Aeson.Bool True) -> "ok"
555:             Just (Aeson.Bool False) -> "failed"
556:             _ -> "?"
557:           output = case KM.lookup "output" obj of
558:             Just (Aeson.String s) -> " (" <> tshow (T.length s) <> " bytes)"
559:             _ -> ""
560:        in "Result: " <> toolName <> " (" <> success <> ")" <> output

1: {-# LANGUAGE OverloadedStrings #-}
2: {-# LANGUAGE NoImplicitPrelude #-}
3: 
4: -- | Agent Event types for observability and streaming.
5: --
6: -- Captures all events during agent execution for logging,
7: -- streaming to web UI, and future interactive chat.
8: module Omni.Agent.Event
9:   ( AgentEvent (..),
10:     EventType (..),
11:     eventToJSON,
12:     eventFromJSON,
13:     formatEventForTerminal,
14:   )
15: where
16: 
17: import Alpha
18: import Data.Aeson ((.=))
19: import qualified Data.Aeson as Aeson
20: import qualified Data.Text as Text
21: import Data.Time (UTCTime, defaultTimeLocale, formatTime)
22: 
23: -- | Types of agent events
24: data EventType
25:   = Assistant -- LLM text response
26:   | ToolCall -- Tool invocation with arguments
27:   | ToolResult -- Tool execution result
28:   | UserMessage -- For future interactive chat
29:   | Cost -- Token usage and cost info
30:   | Error -- Failures and errors
31:   | Complete -- Session ended successfully
32:   deriving (Show, Eq, Read)
33: 
34: -- | A single agent event with timestamp and content
35: data AgentEvent = AgentEvent
36:   { eventType :: EventType,
37:     eventTimestamp :: UTCTime,
38:     eventContent :: Aeson.Value
39:   }
40:   deriving (Show, Eq)
41: 
42: -- | Convert event to JSON for storage/streaming
43: eventToJSON :: AgentEvent -> Aeson.Value
44: eventToJSON e =
45:   Aeson.object
46:     [ "type" .= show (eventType e),
47:       "timestamp" .= eventTimestamp e,
48:       "content" .= eventContent e
49:     ]
50: 
51: -- | Parse event from JSON
52: eventFromJSON :: Aeson.Value -> Maybe AgentEvent
53: eventFromJSON v = do
54:   obj <- case v of
55:     Aeson.Object o -> Just o
56:     _ -> Nothing
57:   typeStr <- case Aeson.lookup "type" (Aeson.toList obj) of
58:     Just (Aeson.String t) -> Just (Text.unpack t)
59:     _ -> Nothing
60:   eventT <- readMaybe typeStr
61:   ts <- case Aeson.lookup "timestamp" (Aeson.toList obj) of
62:     Just t -> Aeson.parseMaybe Aeson.parseJSON t
63:     _ -> Nothing
64:   content <- Aeson.lookup "content" (Aeson.toList obj)
65:   pure
66:     AgentEvent
67:       { eventType = eventT,
68:         eventTimestamp = ts,
69:         eventContent = content
70:       }
71:   where
72:     Aeson.lookup k pairs = snd </ find (\(k', _) -> k' == k) pairs
73:     Aeson.toList (Aeson.Object o) = map (first Aeson.toText) (Aeson.toList o)
74:     Aeson.toList _ = []
75:     Aeson.toText = id
76:     first f (a, b) = (f a, b)
77: 
78: -- | Format event for terminal display
79: formatEventForTerminal :: AgentEvent -> Text
80: formatEventForTerminal e =
81:   let ts = Text.pack <| formatTime defaultTimeLocale "%H:%M:%S" (eventTimestamp e)
82:       content = case eventType e of
83:         Assistant -> case eventContent e of
84:           Aeson.String t -> "Assistant: " <> truncate' 100 t
85:           _ -> "Assistant: <message>"
86:         ToolCall -> case eventContent e of
87:           Aeson.Object _ ->
88:             let toolName = getField "tool" (eventContent e)
89:              in "Tool: " <> toolName
90:           _ -> "Tool: <call>"
91:         ToolResult -> case eventContent e of
92:           Aeson.Object _ ->
93:             let toolName = getField "tool" (eventContent e)
94:                 success = getField "success" (eventContent e)
95:              in "Result: " <> toolName <> " (" <> success <> ")"
96:           _ -> "Result: <result>"
97:         UserMessage -> case eventContent e of
98:           Aeson.String t -> "User: " <> truncate' 100 t
99:           _ -> "User: <message>"
100:         Cost -> case eventContent e of

100:         Cost -> case eventContent e of
101:           Aeson.Object _ ->
102:             let tokens = getField "tokens" (eventContent e)
103:                 cents = getField "cents" (eventContent e)
104:              in "Cost: " <> tokens <> " tokens, " <> cents <> " cents"
105:           _ -> "Cost: <info>"
106:         Error -> case eventContent e of
107:           Aeson.String t -> "Error: " <> t
108:           _ -> "Error: <error>"
109:         Complete -> "Complete"
110:    in "[" <> ts <> "] " <> content
111:   where
112:     truncate' n t = if Text.length t > n then Text.take n t <> "..." else t
113:     getField key val = case val of
114:       Aeson.Object o -> case Aeson.lookup key (Aeson.toList o) of
115:         Just (Aeson.String s) -> s
116:         Just (Aeson.Number n) -> Text.pack (show n)
117:         Just (Aeson.Bool b) -> if b then "ok" else "failed"
118:         _ -> "<" <> key <> ">"
119:       _ -> "<" <> key <> ">"
120:       where
121:         Aeson.lookup k pairs = snd </ find (\(k', _) -> k' == k) pairs
122:         Aeson.toList (Aeson.Object o') = map (first' Aeson.toText) (Aeson.toList o')
123:         Aeson.toList _ = []
124:         Aeson.toText = id
125:         first' f (a, b) = (f a, b)
126: 
127: -- Helper constructors for common events
128: 
129: mkAssistantEvent :: UTCTime -> Text -> AgentEvent
130: mkAssistantEvent ts content =
131:   AgentEvent
132:     { eventType = Assistant,
133:       eventTimestamp = ts,
134:       eventContent = Aeson.String content
135:     }
136: 
137: mkToolCallEvent :: UTCTime -> Text -> Aeson.Value -> AgentEvent
138: mkToolCallEvent ts toolName args =
139:   AgentEvent
140:     { eventType = ToolCall,
141:       eventTimestamp = ts,
142:       eventContent = Aeson.object ["tool" .= toolName, "args" .= args]
143:     }
144: 
145: mkToolResultEvent :: UTCTime -> Text -> Bool -> Text -> AgentEvent
146: mkToolResultEvent ts toolName success output =
147:   AgentEvent
148:     { eventType = ToolResult,
149:       eventTimestamp = ts,
150:       eventContent =

290:                 Engine.engineOnActivity = \activity -> do
291:                   sayLog <| "[engine] " <> activity,
292:                 Engine.engineOnToolCall = \toolName args -> do
293:                   sayLog <| "[tool] " <> toolName
294:                   logJuniorEvent "ToolCall" (toolName <> ": " <> args),
295:                 Engine.engineOnAssistant = \msg -> do
296:                   sayLog <| "[assistant] " <> Text.take 200 msg
297:                   logJuniorEvent "Assistant" msg,
298:                 Engine.engineOnToolResult = \toolName success output -> do
299:                   let statusStr = if success then "ok" else "failed"
300:                   sayLog <| "[result] " <> toolName <> " (" <> statusStr <> "): " <> Text.take 100 output
301:                   logJuniorEvent "ToolResult" output,
302:                 Engine.engineOnComplete = do
303:                   sayLog "[engine] Complete"
304:                   logJuniorEvent "Complete" "",
305:                 Engine.engineOnError = \err -> do
306:                   sayLog <| "[error] " <> err
307:                   logJuniorEvent "Error" err,
308:                 Engine.engineOnGuardrail = \guardrailResult -> do
309:                   let guardrailMsg = formatGuardrailResult guardrailResult
310:                       contentJson = TE.decodeUtf8 (BSL.toStrict (Aeson.encode guardrailResult))
311:                   sayLog <| "[guardrail] " <> guardrailMsg
312:                   logSystemEvent "Guardrail" contentJson
313:               }
314: 
315:       -- Build Agent config with guardrails
316:       let guardrails =
317:             Engine.Guardrails
318:               { Engine.guardrailMaxCostCents = 200.0,
319:                 Engine.guardrailMaxTokens = 1000000,
320:                 Engine.guardrailMaxDuplicateToolCalls = 20,
321:                 Engine.guardrailMaxTestFailures = 3
322:               }
323:           agentCfg =
324:             Engine.AgentConfig
325:               { Engine.agentModel = model,

740:           argsText = fcArguments (tcFunction tc)
741:           callId = tcId tc
742:       engineOnActivity engineCfg <| "Executing tool: " <> name
743:       engineOnToolCall engineCfg name argsText
744:       case Map.lookup name toolMap of
745:         Nothing -> do
746:           let errMsg = "Tool not found: " <> name
747:           engineOnToolResult engineCfg name False errMsg
748:           pure (Message ToolRole errMsg Nothing (Just callId), 0)
749:         Just tool -> do
750:           case Aeson.decode (BL.fromStrict (TE.encodeUtf8 argsText)) of
751:             Nothing -> do
752:               let errMsg = "Invalid JSON arguments: " <> argsText
753:               engineOnToolResult engineCfg name False errMsg
754:               pure (Message ToolRole errMsg Nothing (Just callId), 0)
755:             Just args -> do
756:               resultValue <- toolExecute tool args
757:               let resultText = TE.decodeUtf8 (BL.toStrict (Aeson.encode resultValue))
758:                   isTestCall = name == "bash" && ("bild --test" `Text.isInfixOf` argsText || "bild -t" `Text.isInfixOf` argsText)
759:                   isTestFailure = isTestCall && isFailureResult resultValue
760:                   failureDelta = if isTestFailure then 1 else 0
761:               engineOnToolResult engineCfg name True resultText
762:               pure (Message ToolRole resultText Nothing (Just callId), failureDelta)
763: 
764:     isFailureResult :: Aeson.Value -> Bool
765:     isFailureResult (Aeson.Object obj) =
766:       case KeyMap.lookup "exit_code" obj of
767:         Just (Aeson.Number n) -> n /= 0
768:         _ -> False
769:     isFailureResult (Aeson.String s) =
770:       "error"
771:         `Text.isInfixOf` Text.toLower s
772:         || "failed"
773:         `Text.isInfixOf` Text.toLower s
774:         || "FAILED"
775:         `Text.isInfixOf` s
776:     isFailureResult _ = False
777: 
778: -- | Estimate cost in cents from token count
779: estimateCost :: Text -> Int -> Double
780: estimateCost model tokens

1: {-# LANGUAGE DeriveGeneric #-}
2: {-# LANGUAGE OverloadedStrings #-}
3: {-# LANGUAGE NoImplicitPrelude #-}
4: 
5: -- | Core coding tools for Jr agent.
6: --
7: -- Provides implementations for:
8: -- - readFile: Read file contents
9: -- - writeFile: Write file contents
10: -- - editFile: Search/replace edit
11: -- - runBash: Execute shell commands
12: -- - searchCodebase: Ripgrep wrapper for code search
13: --
14: -- All tools return structured JSON results.
15: --
16: -- : out omni-agent-tools
17: -- : dep aeson
18: -- : dep directory
19: module Omni.Agent.Tools
20:   ( readFileTool,
21:     writeFileTool,
22:     editFileTool,
23:     runBashTool,
24:     searchCodebaseTool,
25:     allTools,
26:     ReadFileArgs (..),
27:     WriteFileArgs (..),
28:     EditFileArgs (..),
29:     RunBashArgs (..),
30:     SearchCodebaseArgs (..),
31:     ToolResult (..),
32:     main,
33:     test,
34:   )
35: where
36: 
37: import Alpha
38: import Data.Aeson ((.!=), (.:), (.:?), (.=))
39: import qualified Data.Aeson as Aeson
40: import qualified Data.List as List
41: import qualified Data.Text as Text
42: import qualified Data.Text.IO as TextIO
43: import qualified Omni.Agent.Engine as Engine
44: import qualified Omni.Test as Test
45: import qualified System.Directory as Directory
46: import qualified System.Exit as Exit
47: import qualified System.Process as Process
48: 
49: main :: IO ()
50: main = Test.run test
51: 
52: test :: Test.Tree
53: test =
54:   Test.group
55:     "Omni.Agent.Tools"
56:     [ Test.unit "readFileTool schema is valid" <| do
57:         let schema = Engine.toolJsonSchema readFileTool
58:         case schema of
59:           Aeson.Object _ -> pure ()
60:           _ -> Test.assertFailure "Schema should be an object",
61:       Test.unit "writeFileTool schema is valid" <| do
62:         let schema = Engine.toolJsonSchema writeFileTool
63:         case schema of
64:           Aeson.Object _ -> pure ()
65:           _ -> Test.assertFailure "Schema should be an object",
66:       Test.unit "editFileTool schema is valid" <| do
67:         let schema = Engine.toolJsonSchema editFileTool
68:         case schema of
69:           Aeson.Object _ -> pure ()
70:           _ -> Test.assertFailure "Schema should be an object",
71:       Test.unit "runBashTool schema is valid" <| do
72:         let schema = Engine.toolJsonSchema runBashTool
73:         case schema of
74:           Aeson.Object _ -> pure ()
75:           _ -> Test.assertFailure "Schema should be an object",
76:       Test.unit "searchCodebaseTool schema is valid" <| do
77:         let schema = Engine.toolJsonSchema searchCodebaseTool
78:         case schema of
79:           Aeson.Object _ -> pure ()
80:           _ -> Test.assertFailure "Schema should be an object",
81:       Test.unit "allTools contains 5 tools" <| do
82:         length allTools Test.@=? 5,
83:       Test.unit "ReadFileArgs parses correctly" <| do
84:         let json = Aeson.object ["path" .= ("test.txt" :: Text)]
85:         case Aeson.fromJSON json of
86:           Aeson.Success (args :: ReadFileArgs) -> readFilePath args Test.@=? "test.txt"
87:           Aeson.Error e -> Test.assertFailure e,
88:       Test.unit "WriteFileArgs parses correctly" <| do
89:         let json = Aeson.object ["path" .= ("test.txt" :: Text), "content" .= ("hello" :: Text)]
90:         case Aeson.fromJSON json of
91:           Aeson.Success (args :: WriteFileArgs) -> do
92:             writeFilePath args Test.@=? "test.txt"
93:             writeFileContent args Test.@=? "hello"
94:           Aeson.Error e -> Test.assertFailure e,
95:       Test.unit "EditFileArgs parses correctly" <| do
96:         let json =
97:               Aeson.object
98:                 [ "path" .= ("test.txt" :: Text),
99:                   "old_str" .= ("foo" :: Text),
100:                   "new_str" .= ("bar" :: Text)

130:         result <- Engine.toolExecute readFileTool args
131:         case Aeson.fromJSON result of
132:           Aeson.Success (tr :: ToolResult) -> do
133:             toolResultSuccess tr Test.@=? False
134:             isJust (toolResultError tr) Test.@=? True
135:           Aeson.Error e -> Test.assertFailure e,
136:       Test.unit "editFileTool handles no-match case" <| do
137:         let args =
138:               Aeson.object
139:                 [ "path" .= ("/nonexistent/file.txt" :: Text),
140:                   "old_str" .= ("needle" :: Text),
141:                   "new_str" .= ("replacement" :: Text)
142:                 ]
143:         result <- Engine.toolExecute editFileTool args
144:         case Aeson.fromJSON result of
145:           Aeson.Success (tr :: ToolResult) -> toolResultSuccess tr Test.@=? False
146:           Aeson.Error e -> Test.assertFailure e,
147:       Test.unit "runBashTool captures exit codes" <| do
148:         let args = Aeson.object ["command" .= ("exit 42" :: Text)]
149:         result <- Engine.toolExecute runBashTool args
150:         case Aeson.fromJSON result of
151:           Aeson.Success (tr :: ToolResult) -> do
152:             toolResultSuccess tr Test.@=? False
153:             toolResultError tr Test.@=? Just "Exit code: 42"
154:           Aeson.Error e -> Test.assertFailure e,
155:       Test.unit "runBashTool captures stdout" <| do
156:         let args = Aeson.object ["command" .= ("echo hello" :: Text)]
157:         result <- Engine.toolExecute runBashTool args
158:         case Aeson.fromJSON result of
159:           Aeson.Success (tr :: ToolResult) -> do
160:             toolResultSuccess tr Test.@=? True
161:             ("hello" `Text.isInfixOf` toolResultOutput tr) Test.@=? True
162:           Aeson.Error e -> Test.assertFailure e,
163:       Test.unit "runBashTool validates cwd exists" <| do
164:         let args =
165:               Aeson.object
166:                 [ "command" .= ("echo test" :: Text),
167:                   "cwd" .= ("/nonexistent/path/that/does/not/exist" :: Text)
168:                 ]
169:         result <- Engine.toolExecute runBashTool args
170:         case Aeson.fromJSON result of
171:           Aeson.Success (tr :: ToolResult) -> do
172:             toolResultSuccess tr Test.@=? False
173:             isJust (toolResultError tr) Test.@=? True
174:           Aeson.Error e -> Test.assertFailure e,
175:       Test.unit "searchCodebaseTool returns structured results" <| do
176:         let args =
177:               Aeson.object
178:                 [ "pattern" .= ("module" :: Text),
179:                   "path" .= ("." :: Text),
180:                   "max_results" .= (5 :: Int)
181:                 ]
182:         result <- Engine.toolExecute searchCodebaseTool args
183:         case Aeson.fromJSON result of
184:           Aeson.Success (tr :: ToolResult) -> toolResultSuccess tr Test.@=? True
185:           Aeson.Error e -> Test.assertFailure e
186:     ]
187: 
188: data ToolResult = ToolResult
189:   { toolResultSuccess :: Bool,
190:     toolResultOutput :: Text,
191:     toolResultError :: Maybe Text
192:   }
193:   deriving (Show, Eq, Generic)
194: 
195: instance Aeson.ToJSON ToolResult where
196:   toJSON r =
197:     Aeson.object
198:       <| catMaybes
199:         [ Just ("success" .= toolResultSuccess r),
200:           Just ("output" .= toolResultOutput r),
201:           ("error" .=) </ toolResultError r
202:         ]
203: 
204: instance Aeson.FromJSON ToolResult where
205:   parseJSON =
206:     Aeson.withObject "ToolResult" <| \v ->
207:       (ToolResult </ (v .: "success"))
208:         <*> (v .:? "output" .!= "")
209:         <*> (v .:? "error")
210: 
211: mkSuccess :: Text -> Aeson.Value
212: mkSuccess output = Aeson.toJSON <| ToolResult True output Nothing
213: 
214: mkError :: Text -> Aeson.Value
215: mkError err = Aeson.toJSON <| ToolResult False "" (Just err)
216: 
217: allTools :: [Engine.Tool]
218: allTools =
219:   [ readFileTool,
220:     writeFileTool,
221:     editFileTool,
222:     runBashTool,
223:     searchCodebaseTool
224:   ]
225: 
226: data ReadFileArgs = ReadFileArgs
227:   { readFilePath :: Text,
228:     readFileStartLine :: Maybe Int,
229:     readFileEndLine :: Maybe Int
230:   }
231:   deriving (Show, Eq, Generic)
232: 
233: instance Aeson.FromJSON ReadFileArgs where
234:   parseJSON =
235:     Aeson.withObject "ReadFileArgs" <| \v ->
236:       (ReadFileArgs </ (v .: "path"))
237:         <*> (v .:? "start_line")
238:         <*> (v .:? "end_line")
239: 
240: readFileTool :: Engine.Tool
241: readFileTool =
242:   Engine.Tool
243:     { Engine.toolName = "read_file",
244:       Engine.toolDescription = "Read the contents of a file. Can optionally read a specific line range.",
245:       Engine.toolJsonSchema =
246:         Aeson.object
247:           [ "type" .= ("object" :: Text),
248:             "properties"
249:               .= Aeson.object
250:                 [ "path"
251:                     .= Aeson.object
252:                       [ "type" .= ("string" :: Text),
253:                         "description" .= ("Absolute path to the file to read" :: Text)
254:                       ],
255:                   "start_line"
256:                     .= Aeson.object
257:                       [ "type" .= ("integer" :: Text),
258:                         "description" .= ("Optional: first line to read (1-indexed)" :: Text)
259:                       ],
260:                   "end_line"
261:                     .= Aeson.object
262:                       [ "type" .= ("integer" :: Text),
263:                         "description" .= ("Optional: last line to read (1-indexed)" :: Text)
264:                       ]
265:                 ],
266:             "required" .= (["path"] :: [Text])
267:           ],
268:       Engine.toolExecute = executeReadFile
269:     }
270: 
271: executeReadFile :: Aeson.Value -> IO Aeson.Value
272: executeReadFile v =
273:   case Aeson.fromJSON v of
274:     Aeson.Error e -> pure <| mkError (Text.pack e)
275:     Aeson.Success args -> do
276:       let path = Text.unpack (readFilePath args)
277:       exists <- Directory.doesFileExist path
278:       if exists
279:         then do
280:           content <- TextIO.readFile path
281:           let allLines = Text.lines content
282:               startIdx = maybe 0 (\n -> n - 1) (readFileStartLine args)
283:               endIdx = maybe (length allLines) identity (readFileEndLine args)
284:               selectedLines = take (endIdx - startIdx) (drop startIdx allLines)
285:               numberedLines = zipWith formatLine [(startIdx + 1) ..] selectedLines
286:               result = Text.unlines numberedLines
287:           pure <| mkSuccess result
288:         else pure <| mkError ("File not found: " <> readFilePath args)
289:   where
290:     formatLine :: Int -> Text -> Text
291:     formatLine n line = Text.pack (show n) <> ": " <> line
292: 
293: data WriteFileArgs = WriteFileArgs
294:   { writeFilePath :: Text,
295:     writeFileContent :: Text
296:   }
297:   deriving (Show, Eq, Generic)
298: 
299: instance Aeson.FromJSON WriteFileArgs where
300:   parseJSON =

370:       Engine.toolDescription = "Edit a file by replacing old_str with new_str. By default replaces only the first occurrence unless replace_all is true.",
371:       Engine.toolJsonSchema =
372:         Aeson.object
373:           [ "type" .= ("object" :: Text),
374:             "properties"
375:               .= Aeson.object
376:                 [ "path"
377:                     .= Aeson.object
378:                       [ "type" .= ("string" :: Text),
379:                         "description" .= ("Absolute path to the file to edit" :: Text)
380:                       ],
381:                   "old_str"
382:                     .= Aeson.object
383:                       [ "type" .= ("string" :: Text),
384:                         "description" .= ("The text to search for and replace" :: Text)
385:                       ],
386:                   "new_str"
387:                     .= Aeson.object
388:                       [ "type" .= ("string" :: Text),
389:                         "description" .= ("The replacement text" :: Text)
390:                       ],
391:                   "replace_all"
392:                     .= Aeson.object
393:                       [ "type" .= ("boolean" :: Text),
394:                         "description" .= ("If true, replace all occurrences; otherwise replace only the first" :: Text)
395:                       ]
396:                 ],
397:             "required" .= (["path", "old_str", "new_str"] :: [Text])
398:           ],
399:       Engine.toolExecute = executeEditFile
400:     }
401: 
402: executeEditFile :: Aeson.Value -> IO Aeson.Value
403: executeEditFile v =
404:   case Aeson.fromJSON v of
405:     Aeson.Error e -> pure <| mkError (Text.pack e)
406:     Aeson.Success args -> do
407:       let path = Text.unpack (editFilePath args)
408:       exists <- Directory.doesFileExist path
409:       if exists
410:         then do
411:           content <- TextIO.readFile path
412:           let oldStr = editFileOldStr args
413:               newStr = editFileNewStr args
414:               replaceAll = fromMaybe False (editFileReplaceAll args)
415:           if Text.isInfixOf oldStr content
416:             then do
417:               let newContent =
418:                     if replaceAll
419:                       then Text.replace oldStr newStr content
420:                       else replaceFirst oldStr newStr content
421:               TextIO.writeFile path newContent
422:               let count =
423:                     if replaceAll
424:                       then Text.count oldStr content
425:                       else 1
426:               pure <| mkSuccess ("Replaced " <> tshow count <> " occurrence(s)")
427:             else pure <| mkError ("old_str not found in file: " <> editFilePath args)
428:         else pure <| mkError ("File not found: " <> editFilePath args)
429: 
430: replaceFirst :: Text -> Text -> Text -> Text
431: replaceFirst old new content =
432:   case Text.breakOn old content of
433:     (before, after) ->
434:       if Text.null after
435:         then content
436:         else before <> new <> Text.drop (Text.length old) after
437: 
438: data RunBashArgs = RunBashArgs
439:   { runBashCommand :: Text,
440:     runBashCwd :: Maybe Text,
441:     runBashTimeout :: Maybe Int
442:   }
443:   deriving (Show, Eq, Generic)
444: 
445: instance Aeson.FromJSON RunBashArgs where
446:   parseJSON =
447:     Aeson.withObject "RunBashArgs" <| \v ->
448:       (RunBashArgs </ (v .: "command"))
449:         <*> (v .:? "cwd")
450:         <*> (v .:? "timeout")
451: 
452: runBashTool :: Engine.Tool
453: runBashTool =
454:   Engine.Tool
455:     { Engine.toolName = "run_bash",
456:       Engine.toolDescription = "Execute a shell command and return stdout/stderr.",
457:       Engine.toolJsonSchema =
458:         Aeson.object
459:           [ "type" .= ("object" :: Text),
460:             "properties"
461:               .= Aeson.object
462:                 [ "command"
463:                     .= Aeson.object
464:                       [ "type" .= ("string" :: Text),
465:                         "description" .= ("The shell command to execute" :: Text)
466:                       ],
467:                   "cwd"
468:                     .= Aeson.object
469:                       [ "type" .= ("string" :: Text),
470:                         "description" .= ("Optional: working directory for the command" :: Text)
471:                       ],
472:                   "timeout"
473:                     .= Aeson.object
474:                       [ "type" .= ("integer" :: Text),
475:                         "description" .= ("Optional: timeout in seconds (default: 300)" :: Text)
476:                       ]
477:                 ],
478:             "required" .= (["command"] :: [Text])
479:           ],
480:       Engine.toolExecute = executeRunBash
481:     }
482: 
483: executeRunBash :: Aeson.Value -> IO Aeson.Value
484: executeRunBash v =
485:   case Aeson.fromJSON v of
486:     Aeson.Error e -> pure <| mkError (Text.pack e)
487:     Aeson.Success args -> do
488:       let cmd = Text.unpack (runBashCommand args)
489:           maybeCwd = runBashCwd args
490:       cwdValid <- case maybeCwd of
491:         Nothing -> pure True
492:         Just cwd -> Directory.doesDirectoryExist (Text.unpack cwd)
493:       if not cwdValid
494:         then
495:           pure
496:             <| mkError
497:               ("Working directory does not exist: " <> fromMaybe "" maybeCwd)
498:         else do
499:           let proc =
500:                 (Process.shell cmd)

520:                     toolResultError = Just ("Exit code: " <> tshow code)
521:                   }
522: 
523: data SearchCodebaseArgs = SearchCodebaseArgs
524:   { searchPattern :: Text,
525:     searchPath :: Maybe Text,
526:     searchGlob :: Maybe Text,
527:     searchCaseSensitive :: Maybe Bool,
528:     searchMaxResults :: Maybe Int
529:   }
530:   deriving (Show, Eq, Generic)
531: 
532: instance Aeson.FromJSON SearchCodebaseArgs where
533:   parseJSON =
534:     Aeson.withObject "SearchCodebaseArgs" <| \v ->
535:       (SearchCodebaseArgs </ (v .: "pattern"))
536:         <*> (v .:? "path")
537:         <*> (v .:? "glob")
538:         <*> (v .:? "case_sensitive")
539:         <*> (v .:? "max_results")
540: 
541: searchCodebaseTool :: Engine.Tool
542: searchCodebaseTool =
543:   Engine.Tool
544:     { Engine.toolName = "search_codebase",
545:       Engine.toolDescription = "Search the codebase using ripgrep. Returns matching lines with file paths and line numbers.",
546:       Engine.toolJsonSchema =
547:         Aeson.object
548:           [ "type" .= ("object" :: Text),
549:             "properties"
550:               .= Aeson.object
551:                 [ "pattern"
552:                     .= Aeson.object
553:                       [ "type" .= ("string" :: Text),
554:                         "description" .= ("The regex pattern to search for" :: Text)
555:                       ],
556:                   "path"
557:                     .= Aeson.object
558:                       [ "type" .= ("string" :: Text),
559:                         "description" .= ("Optional: directory or file path to search in" :: Text)
560:                       ],
561:                   "glob"
562:                     .= Aeson.object
563:                       [ "type" .= ("string" :: Text),
564:                         "description" .= ("Optional: file glob pattern (e.g., '*.hs')" :: Text)
565:                       ],
566:                   "case_sensitive"
567:                     .= Aeson.object
568:                       [ "type" .= ("boolean" :: Text),
569:                         "description" .= ("Optional: case sensitive search (default: false)" :: Text)
570:                       ],
571:                   "max_results"
572:                     .= Aeson.object
573:                       [ "type" .= ("integer" :: Text),
574:                         "description" .= ("Optional: maximum number of results (default: 100)" :: Text)
575:                       ]
576:                 ],
577:             "required" .= (["pattern"] :: [Text])
578:           ],
579:       Engine.toolExecute = executeSearchCodebase
580:     }
581: 
582: executeSearchCodebase :: Aeson.Value -> IO Aeson.Value
583: executeSearchCodebase v =
584:   case Aeson.fromJSON v of
585:     Aeson.Error e -> pure <| mkError (Text.pack e)
586:     Aeson.Success args -> do
587:       let pat = Text.unpack (searchPattern args)
588:           maxRes = fromMaybe 100 (searchMaxResults args)
589:           caseSensitive = fromMaybe False (searchCaseSensitive args)
590:           baseArgs =
591:             ["--line-number", "--no-heading", "--max-count=" <> show maxRes, pat]
592:           caseArgs = ["--ignore-case" | not caseSensitive]
593:           globArgs = maybe [] (\g -> ["--glob", Text.unpack g]) (searchGlob args)
594:           pathArg = maybe ["."] (\p -> [Text.unpack p]) (searchPath args)
595:           allArgs = caseArgs <> globArgs <> baseArgs <> pathArg
596:           proc = Process.proc "rg" allArgs
597:       (exitCode, stdoutStr, stderrStr) <- Process.readCreateProcessWithExitCode proc ""
598:       case exitCode of
599:         Exit.ExitSuccess ->
600:           pure <| mkSuccess (Text.pack stdoutStr)

1: {-# LANGUAGE OverloadedStrings #-}
2: {-# LANGUAGE NoImplicitPrelude #-}
3: 
4: module Omni.Agent.Worker where
5: 
6: import Alpha
7: import qualified Data.Aeson as Aeson
8: import qualified Data.Aeson.Key as AesonKey
9: import qualified Data.ByteString.Lazy as BSL
10: import Data.IORef (modifyIORef', newIORef, readIORef)
11: import qualified Data.List as List
12: import qualified Data.Text as Text
13: import qualified Data.Text.Encoding as TE
14: import qualified Data.Time
15: import qualified Omni.Agent.Core as Core
16: import qualified Omni.Agent.Engine as Engine
17: import qualified Omni.Agent.Log as AgentLog
18: import qualified Omni.Agent.Tools as Tools
19: import qualified Omni.Fact as Fact
20: import qualified Omni.Task.Core as TaskCore
21: import qualified System.Directory as Directory
22: import qualified System.Environment as Env
23: import qualified System.Exit as Exit
24: import System.FilePath ((</>))
25: import qualified System.Process as Process
26: 
27: start :: Core.Worker -> Maybe Text -> IO ()
28: start worker maybeTaskId = do
29:   if Core.workerQuiet worker
30:     then putText ("[worker] Starting for " <> Core.workerName worker)
31:     else do
32:       AgentLog.init (Core.workerName worker)
33:       AgentLog.log ("[worker] Starting for " <> Core.workerName worker)
34:   case maybeTaskId of
35:     Just tid -> logMsg worker ("[worker] Target task: " <> tid)
36:     Nothing -> logMsg worker "[worker] No specific task, will pick from ready queue"
37:   runOnce worker maybeTaskId
38: 
39: -- | Log message respecting quiet mode
40: logMsg :: Core.Worker -> Text -> IO ()
41: logMsg worker msg =
42:   if Core.workerQuiet worker
43:     then putText msg
44:     else AgentLog.log msg
45: 
46: -- | Convert key-value pairs to JSON metadata string
47: toMetadata :: [(Text, Text)] -> Text
48: toMetadata pairs =
49:   let obj = Aeson.object [(AesonKey.fromText k, Aeson.String v) | (k, v) <- pairs]
50:    in TE.decodeUtf8 (BSL.toStrict (Aeson.encode obj))
51: 
52: -- | Format guardrail result for logging
53: formatGuardrailResult :: Engine.GuardrailResult -> Text
54: formatGuardrailResult Engine.GuardrailOk = "OK"
55: formatGuardrailResult (Engine.GuardrailCostExceeded actual limit) =
56:   "Cost exceeded: " <> tshow actual <> " cents (limit: " <> tshow limit <> ")"
57: formatGuardrailResult (Engine.GuardrailTokensExceeded actual limit) =
58:   "Tokens exceeded: " <> tshow actual <> " (limit: " <> tshow limit <> ")"
59: formatGuardrailResult (Engine.GuardrailDuplicateToolCalls tool count) =
60:   "Duplicate tool calls: " <> tool <> " called " <> tshow count <> " times"
61: formatGuardrailResult (Engine.GuardrailTestFailures count) =
62:   "Test failures: " <> tshow count <> " failures"
63: 
64: runOnce :: Core.Worker -> Maybe Text -> IO ()
65: runOnce worker maybeTaskId = do
66:   -- Find work
67:   targetTask <- case maybeTaskId of
68:     Just tid -> do
69:       TaskCore.findTask tid </ TaskCore.loadTasks
70:     Nothing -> do
71:       readyTasks <- TaskCore.getReadyTasks
72:       case readyTasks of
73:         [] -> pure Nothing
74:         (task : _) -> pure (Just task)
75: 
76:   case targetTask of
77:     Nothing -> do
78:       case maybeTaskId of
79:         Just tid -> do
80:           unless (Core.workerQuiet worker) <| AgentLog.updateActivity ("Task " <> tid <> " not found.")
81:           logMsg worker ("[worker] Task " <> tid <> " not found.")
82:         Nothing -> do
83:           unless (Core.workerQuiet worker) <| AgentLog.updateActivity "No work found."
84:           logMsg worker "[worker] No ready tasks found."
85:     Just task -> do
86:       processTask worker task
87: 
88: processTask :: Core.Worker -> TaskCore.Task -> IO ()
89: processTask worker task = do
90:   let repo = Core.workerPath worker
91:   let tid = TaskCore.taskId task
92:   let quiet = Core.workerQuiet worker
93:   let say = logMsg worker
94: 
95:   unless quiet <| AgentLog.update (\s -> s {AgentLog.statusTask = Just tid})
96:   say ("[worker] Claiming task " <> tid)
97: 
98:   -- Claim task
99:   TaskCore.logActivity tid TaskCore.Claiming Nothing
100:   TaskCore.updateTaskStatusWithActor tid TaskCore.InProgress [] TaskCore.Junior

280:           engineCfg =
281:             Engine.EngineConfig
282:               { Engine.engineLLM =
283:                   Engine.defaultLLM
284:                     { Engine.llmApiKey = Text.pack apiKey
285:                     },
286:                 Engine.engineOnCost = \tokens cost -> do
287:                   modifyIORef' totalCostRef (+ cost)
288:                   sayLog <| "Cost: " <> tshow cost <> " cents (" <> tshow tokens <> " tokens)"
289:                   logJuniorJson "Cost" (Aeson.object [("tokens", Aeson.toJSON tokens), ("cents", Aeson.toJSON cost)]),
290:                 Engine.engineOnActivity = \activity -> do
291:                   sayLog <| "[engine] " <> activity,
292:                 Engine.engineOnToolCall = \toolName args -> do
293:                   sayLog <| "[tool] " <> toolName
294:                   logJuniorEvent "ToolCall" (toolName <> ": " <> args),
295:                 Engine.engineOnAssistant = \msg -> do
296:                   sayLog <| "[assistant] " <> Text.take 200 msg
297:                   logJuniorEvent "Assistant" msg,
298:                 Engine.engineOnToolResult = \toolName success output -> do
299:                   let statusStr = if success then "ok" else "failed"
300:                   sayLog <| "[result] " <> toolName <> " (" <> statusStr <> "): " <> Text.take 100 output
301:                   logJuniorEvent "ToolResult" output,
302:                 Engine.engineOnComplete = do
303:                   sayLog "[engine] Complete"
304:                   logJuniorEvent "Complete" "",
305:                 Engine.engineOnError = \err -> do
306:                   sayLog <| "[error] " <> err
307:                   logJuniorEvent "Error" err,
308:                 Engine.engineOnGuardrail = \guardrailResult -> do
309:                   let guardrailMsg = formatGuardrailResult guardrailResult
310:                       contentJson = TE.decodeUtf8 (BSL.toStrict (Aeson.encode guardrailResult))
311:                   sayLog <| "[guardrail] " <> guardrailMsg
312:                   logSystemEvent "Guardrail" contentJson
313:               }
314: 
315:       -- Build Agent config with guardrails
316:       let guardrails =
317:             Engine.Guardrails
318:               { Engine.guardrailMaxCostCents = 200.0,
319:                 Engine.guardrailMaxTokens = 1000000,
320:                 Engine.guardrailMaxDuplicateToolCalls = 20,

45: 
46: -- | Convert key-value pairs to JSON metadata string
47: toMetadata :: [(Text, Text)] -> Text
48: toMetadata pairs =
49:   let obj = Aeson.object [(AesonKey.fromText k, Aeson.String v) | (k, v) <- pairs]
50:    in TE.decodeUtf8 (BSL.toStrict (Aeson.encode obj))
51: 
52: -- | Format guardrail result for logging
53: formatGuardrailResult :: Engine.GuardrailResult -> Text
54: formatGuardrailResult Engine.GuardrailOk = "OK"
55: formatGuardrailResult (Engine.GuardrailCostExceeded actual limit) =
56:   "Cost exceeded: " <> tshow actual <> " cents (limit: " <> tshow limit <> ")"
57: formatGuardrailResult (Engine.GuardrailTokensExceeded actual limit) =
58:   "Tokens exceeded: " <> tshow actual <> " (limit: " <> tshow limit <> ")"
59: formatGuardrailResult (Engine.GuardrailDuplicateToolCalls tool count) =
60:   "Duplicate tool calls: " <> tool <> " called " <> tshow count <> " times"
61: formatGuardrailResult (Engine.GuardrailTestFailures count) =
62:   "Test failures: " <> tshow count <> " failures"
63: 
64: runOnce :: Core.Worker -> Maybe Text -> IO ()
65: runOnce worker maybeTaskId = do

58:   "Tokens exceeded: " <> tshow actual <> " (limit: " <> tshow limit <> ")"
59: formatGuardrailResult (Engine.GuardrailDuplicateToolCalls tool count) =
60:   "Duplicate tool calls: " <> tool <> " called " <> tshow count <> " times"
61: formatGuardrailResult (Engine.GuardrailTestFailures count) =
62:   "Test failures: " <> tshow count <> " failures"
63: 
64: runOnce :: Core.Worker -> Maybe Text -> IO ()
65: runOnce worker maybeTaskId = do
66:   -- Find work
67:   targetTask <- case maybeTaskId of
68:     Just tid -> do