feat(agents): add server-side projects with working directory support

.changeset/add-projects-working-directory.md

@@ -0,0 +1,7 @@
+---
+'@electric-ax/agents-server': patch
+'@electric-ax/agents-server-ui': patch
+'@electric-ax/agents': patch
+---
+
+Add server-side projects (name + directory path) with REST API, popover-based project picker in the new session page, and working directory support in horton. Sessions are tagged by project for sidebar grouping.

.changeset/agents-runtime-tool-call-fix.md

@@ -0,0 +1,5 @@
+---
+'@electric-ax/agents-runtime': patch
+---
+
+Fix tool call event matching.

packages/agents-runtime/src/context-assembly.ts

@@ -324,12 +324,43 @@ export async function assembleContext(
     const message = volatileMessages[i]!
     const nextTokens = approxTokens(message.content)
     if (volatileBudgetUsed + nextTokens > remainingBudget) {
+      if (message.role === `tool_call` || message.role === `tool_result`) {
+        const stub = `[content truncated — use load_timeline_range({ from: ${message.at}, to: ${message.at} }) to read]`
+        const stubTokens = approxTokens(stub)
+        if (volatileBudgetUsed + stubTokens <= remainingBudget) {
+          volatileBudgetUsed += stubTokens
+          accepted.push({ ...message, content: stub })
+          continue
+        }
+      }
       droppedOffsets.push(message.at)
       continue
     }
     volatileBudgetUsed += nextTokens
     accepted.push(message)
   }
+
+  const acceptedCallIds = new Set<string>()
+  const acceptedResultIds = new Set<string>()
+  for (const m of accepted) {
+    const id = (m as VolatileMessage & { toolCallId?: string }).toolCallId
+    if (!id) continue
+    if (m.role === `tool_call`) acceptedCallIds.add(id)
+    else if (m.role === `tool_result`) acceptedResultIds.add(id)
+  }
+  for (let i = accepted.length - 1; i >= 0; i--) {
+    const m = accepted[i]!
+    const id = (m as VolatileMessage & { toolCallId?: string }).toolCallId
+    if (!id) continue
+    if (
+      (m.role === `tool_call` && !acceptedResultIds.has(id)) ||
+      (m.role === `tool_result` && !acceptedCallIds.has(id))
+    ) {
+      droppedOffsets.push(m.at)
+      accepted.splice(i, 1)
+    }
+  }
+
   accepted.reverse()
 
   if (droppedOffsets.length > 0) {

packages/agents-runtime/src/entity-schema.ts

@@ -109,6 +109,7 @@ type TextDeltaValue = {
 type ToolCallValue = {
   key?: string
   run_id?: string
+  tool_call_id?: string
   tool_name: string
   status: `started` | `args_complete` | `executing` | `completed` | `failed`
   args?: unknown
@@ -353,6 +354,7 @@ function createToolCallSchema(): Schema<ToolCallValue> {
   return z.object({
     key: z.string().optional(),
     run_id: z.string().optional(),
+    tool_call_id: z.string().optional(),
     tool_name: z.string(),
     status: z.enum([
       `started`,

packages/agents-runtime/src/outbound-bridge.ts

@@ -110,8 +110,13 @@ export interface OutboundBridge {
   onTextStart: () => void
   onTextDelta: (delta: string) => void
   onTextEnd: () => void
-  onToolCallStart: (name: string, args: unknown) => void
-  onToolCallEnd: (name: string, result: unknown, isError: boolean) => void
+  onToolCallStart: (toolCallId: string, name: string, args: unknown) => void
+  onToolCallEnd: (
+    toolCallId: string,
+    name: string,
+    result: unknown,
+    isError: boolean
+  ) => void
 }
 
 export function createOutboundBridge(
@@ -145,9 +150,10 @@ export function createOutboundBridge(
   let currentStepNumber = 0
   let currentMsgKey: string | null = null
   let currentTextRunKey: string | null = null
-  let currentTcKey: string | null = null
-  let currentTcRunKey: string | null = null
-  let currentTcArgs: unknown = undefined
+  const toolCallsById = new Map<
+    string,
+    { key: string; runKey: string; args: unknown }
+  >()
   const requireActiveRun = (action: string): string => {
     if (!currentRunKey) {
       throw new Error(
@@ -268,16 +274,16 @@ export function createOutboundBridge(
       )
     },
 
-    onToolCallStart(name: string, args: unknown) {
+    onToolCallStart(toolCallId: string, name: string, args: unknown) {
       const runKey = requireActiveRun(`onToolCallStart`)
-      currentTcKey = `tc-${counters.tc++}`
+      const key = `tc-${counters.tc++}`
       persistSeed()
-      currentTcRunKey = runKey
-      currentTcArgs = args
+      toolCallsById.set(toolCallId, { key, runKey, args })
       writeEvent(
         entityStateSchema.toolCalls.insert({
-          key: currentTcKey,
+          key,
           value: {
+            tool_call_id: toolCallId,
             tool_name: name,
             status: `started`,
             args,
@@ -287,21 +293,29 @@ export function createOutboundBridge(
       )
     },
 
-    onToolCallEnd(name: string, result: unknown, isError: boolean) {
-      if (!currentTcKey) return
+    onToolCallEnd(
+      toolCallId: string,
+      name: string,
+      result: unknown,
+      isError: boolean
+    ) {
+      const toolCall = toolCallsById.get(toolCallId)
+      if (!toolCall) return
       writeEvent(
         entityStateSchema.toolCalls.update({
-          key: currentTcKey,
+          key: toolCall.key,
           value: {
+            tool_call_id: toolCallId,
             tool_name: name,
             status: isError ? `failed` : `completed`,
-            args: currentTcArgs,
+            args: toolCall.args,
             result:
               typeof result === `string` ? result : JSON.stringify(result),
-            run_id: currentTcRunKey,
+            run_id: toolCall.runKey,
           } as never,
         }) as ChangeEvent
       )
+      toolCallsById.delete(toolCallId)
     },
   }
 }

packages/agents-runtime/src/pi-adapter.ts

@@ -89,6 +89,11 @@ export function toAgentHistory(
   const history: Array<AgentMessage> = []
   const toolNamesById = new Map<string, string>()
 
+  const lastAssistant = (): AgentMessage | undefined => {
+    const last = history[history.length - 1]
+    return last?.role === `assistant` ? last : undefined
+  }
+
   for (const message of messages) {
     switch (message.role) {
       case `user`:
@@ -99,30 +104,44 @@ export function toAgentHistory(
         } as AgentMessage)
         break
 
-      case `assistant`:
-        history.push({
-          role: `assistant`,
-          content: [{ type: `text`, text: message.content }],
-          timestamp: Date.now(),
-        } as AgentMessage)
+      case `assistant`: {
+        const prev = lastAssistant()
+        if (prev) {
+          ;(prev.content as Array<unknown>).push({
+            type: `text`,
+            text: message.content,
+          })
+        } else {
+          history.push({
+            role: `assistant`,
+            content: [{ type: `text`, text: message.content }],
+            timestamp: Date.now(),
+          } as AgentMessage)
+        }
         break
+      }
 
-      case `tool_call`:
+      case `tool_call`: {
         toolNamesById.set(message.toolCallId, message.toolName)
-        history.push({
-          role: `assistant`,
-          content: [
-            {
-              type: `toolCall`,
-              id: message.toolCallId,
-              name: message.toolName,
-              arguments:
-                (message.toolArgs as Record<string, unknown> | undefined) ?? {},
-            },
-          ],
-          timestamp: Date.now(),
-        } as AgentMessage)
+        const block = {
+          type: `toolCall`,
+          id: message.toolCallId,
+          name: message.toolName,
+          arguments:
+            (message.toolArgs as Record<string, unknown> | undefined) ?? {},
+        }
+        const prev = lastAssistant()
+        if (prev) {
+          ;(prev.content as Array<unknown>).push(block)
+        } else {
+          history.push({
+            role: `assistant`,
+            content: [block],
+            timestamp: Date.now(),
+          } as AgentMessage)
+        }
         break
+      }
 
       case `tool_result`:
         history.push({
@@ -297,12 +316,17 @@ export function createPiAgentAdapter(
               }
 
               case `tool_execution_start`: {
-                bridge.onToolCallStart(event.toolName, event.args)
+                bridge.onToolCallStart(
+                  event.toolCallId,
+                  event.toolName,
+                  event.args
+                )
                 break
               }
 
               case `tool_execution_end`: {
                 bridge.onToolCallEnd(
+                  event.toolCallId,
                   event.toolName,
                   event.result,
                   event.isError

packages/agents-runtime/src/types.ts

@@ -753,8 +753,13 @@ export interface OutboundBridgeHandle {
   onTextStart: () => void
   onTextDelta: (delta: string) => void
   onTextEnd: () => void
-  onToolCallStart: (name: string, args: unknown) => void
-  onToolCallEnd: (name: string, result: unknown, isError: boolean) => void
+  onToolCallStart: (toolCallId: string, name: string, args: unknown) => void
+  onToolCallEnd: (
+    toolCallId: string,
+    name: string,
+    result: unknown,
+    isError: boolean
+  ) => void
 }
 
 export interface AgentHandle {

packages/agents-runtime/test/brave-search-tool.test.ts

@@ -0,0 +1,8 @@
+import { describe, expect, it } from 'vitest'
+import { braveSearchTool } from '../src/tools'
+
+describe(`braveSearchTool`, () => {
+  it(`is exposed to agents as web_search`, () => {
+    expect(braveSearchTool.name).toBe(`web_search`)
+  })
+})

packages/agents-runtime/test/outbound-bridge.test.ts

@@ -69,7 +69,9 @@ describe(`createOutboundBridge`, () => {
 
   it(`rejects tool call outside an active run`, () => {
     const bridge = createOutboundBridge([], () => {})
-    expect(() => bridge.onToolCallStart(`search`, {})).toThrow(/active run/i)
+    expect(() => bridge.onToolCallStart(`call-search`, `search`, {})).toThrow(
+      /active run/i
+    )
   })
 
   it(`rejects step start outside an active run`, () => {
@@ -84,7 +86,7 @@ describe(`createOutboundBridge`, () => {
     })
 
     bridge.onRunStart()
-    bridge.onToolCallStart(`search`, { q: `test` })
+    bridge.onToolCallStart(`call-search`, `search`, { q: `test` })
 
     expect(writes).toHaveLength(2)
     expect(writes[1]!.type).toBe(`tool_call`)
@@ -103,8 +105,8 @@ describe(`createOutboundBridge`, () => {
     })
 
     bridge.onRunStart()
-    bridge.onToolCallStart(`search`, { q: `test` })
-    bridge.onToolCallEnd(`search`, `3 results`, false)
+    bridge.onToolCallStart(`call-search`, `search`, { q: `test` })
+    bridge.onToolCallEnd(`call-search`, `search`, `3 results`, false)
 
     expect(writes).toHaveLength(3)
     expect(writes[2]!.type).toBe(`tool_call`)
@@ -126,13 +128,37 @@ describe(`createOutboundBridge`, () => {
     })
 
     bridge.onRunStart()
-    bridge.onToolCallStart(`bash`, { cmd: `rm -rf /` })
-    bridge.onToolCallEnd(`bash`, `Permission denied`, true)
+    bridge.onToolCallStart(`call-bash`, `bash`, { cmd: `rm -rf /` })
+    bridge.onToolCallEnd(`call-bash`, `bash`, `Permission denied`, true)
 
     expect((writes[2]!.value as Record<string, unknown>).status).toBe(`failed`)
     expect((writes[2]!.value as Record<string, unknown>).run_id).toBe(`run-0`)
   })
 
+  it(`updates the matching tool call when multiple explicit calls overlap`, () => {
+    const writes: Array<ChangeEvent> = []
+    const bridge = createOutboundBridge([], (e) => {
+      writes.push(e)
+    })
+
+    bridge.onRunStart()
+    bridge.onToolCallStart(`call-a`, `read`, { path: `a.txt` })
+    bridge.onToolCallStart(`call-b`, `read`, { path: `b.txt` })
+    bridge.onToolCallEnd(`call-a`, `read`, `A`, false)
+    bridge.onToolCallEnd(`call-b`, `read`, `B`, false)
+
+    expect(writes[3]!.key).toBe(`tc-0`)
+    expect((writes[3]!.value as Record<string, unknown>).tool_call_id).toBe(
+      `call-a`
+    )
+    expect((writes[3]!.value as Record<string, unknown>).result).toBe(`A`)
+    expect(writes[4]!.key).toBe(`tc-1`)
+    expect((writes[4]!.value as Record<string, unknown>).tool_call_id).toBe(
+      `call-b`
+    )
+    expect((writes[4]!.value as Record<string, unknown>).result).toBe(`B`)
+  })
+
   it(`reconstructs ID counters from existing stream events`, () => {
     const existing: Array<ChangeEvent> = [
       ev(`run`, `run-2`, `insert`, { status: `started` }),
@@ -152,7 +178,7 @@ describe(`createOutboundBridge`, () => {
     expect(writes[0]!.key).toBe(`run-3`)
     expect(writes[1]!.key).toBe(`msg-4`)
 
-    bridge.onToolCallStart(`test`, {})
+    bridge.onToolCallStart(`call-test`, `test`, {})
     expect(writes[2]!.key).toBe(`tc-6`)
     expect((writes[2]!.value as Record<string, unknown>).run_id).toBe(`run-3`)
   })
@@ -169,7 +195,7 @@ describe(`createOutboundBridge`, () => {
     bridge.onRunStart()
     bridge.onStepStart()
     bridge.onTextStart()
-    bridge.onToolCallStart(`search`, {})
+    bridge.onToolCallStart(`call-search`, `search`, {})
 
     expect(writes[0]!.key).toBe(`run-2`)
     expect(writes[1]!.key).toBe(`step-4`)
@@ -228,7 +254,9 @@ describe(`createOutboundBridge`, () => {
 
     bridge.onRunStart()
     bridge.onRunEnd()
-    expect(() => bridge.onToolCallStart(`search`, {})).toThrow(/active run/i)
+    expect(() => bridge.onToolCallStart(`call-search`, `search`, {})).toThrow(
+      /active run/i
+    )
   })
 
   it(`rejects step start after run ends`, () => {