saeeol 1.1.0 → 1.1.1

package/src/account/repo.ts

@@ -0,0 +1,166 @@
+import { eq } from "drizzle-orm"
+import { Effect, Layer, Option, Schema, Context } from "effect"
+
+import { Database } from "@/storage/db"
+import { AccountStateTable, AccountTable } from "./account.sql"
+import { AccessToken, AccountID, AccountRepoError, Info, OrgID, RefreshToken } from "./schema"
+import { normalizeServerUrl } from "./url"
+
+export type AccountRow = (typeof AccountTable)["$inferSelect"]
+
+type DbClient = Parameters<typeof Database.use>[0] extends (db: infer T) => unknown ? T : never
+type DbTransactionCallback<A> = Parameters<typeof Database.transaction<A>>[0]
+
+const ACCOUNT_STATE_ID = 1
+
+export interface Interface {
+  readonly active: () => Effect.Effect<Option.Option<Info>, AccountRepoError>
+  readonly list: () => Effect.Effect<Info[], AccountRepoError>
+  readonly remove: (accountID: AccountID) => Effect.Effect<void, AccountRepoError>
+  readonly use: (accountID: AccountID, orgID: Option.Option<OrgID>) => Effect.Effect<void, AccountRepoError>
+  readonly getRow: (accountID: AccountID) => Effect.Effect<Option.Option<AccountRow>, AccountRepoError>
+  readonly persistToken: (input: {
+    accountID: AccountID
+    accessToken: AccessToken
+    refreshToken: RefreshToken
+    expiry: Option.Option<number>
+  }) => Effect.Effect<void, AccountRepoError>
+  readonly persistAccount: (input: {
+    id: AccountID
+    email: string
+    url: string
+    accessToken: AccessToken
+    refreshToken: RefreshToken
+    expiry: number
+    orgID: Option.Option<OrgID>
+  }) => Effect.Effect<void, AccountRepoError>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@saeeol/AccountRepo") {}
+
+export const layer: Layer.Layer<Service> = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const decode = Schema.decodeUnknownSync(Info)
+
+    const query = <A>(f: DbTransactionCallback<A>) =>
+      Effect.try({
+        try: () => Database.use(f),
+        catch: (cause) => new AccountRepoError({ message: "Database operation failed", cause }),
+      })
+
+    const tx = <A>(f: DbTransactionCallback<A>) =>
+      Effect.try({
+        try: () => Database.transaction(f),
+        catch: (cause) => new AccountRepoError({ message: "Database operation failed", cause }),
+      })
+
+    const current = (db: DbClient) => {
+      const state = db.select().from(AccountStateTable).where(eq(AccountStateTable.id, ACCOUNT_STATE_ID)).get()
+      if (!state?.active_account_id) return
+      const account = db.select().from(AccountTable).where(eq(AccountTable.id, state.active_account_id)).get()
+      if (!account) return
+      return { ...account, active_org_id: state.active_org_id ?? null }
+    }
+
+    const state = (db: DbClient, accountID: AccountID, orgID: Option.Option<OrgID>) => {
+      const id = Option.getOrNull(orgID)
+      return db
+        .insert(AccountStateTable)
+        .values({ id: ACCOUNT_STATE_ID, active_account_id: accountID, active_org_id: id })
+        .onConflictDoUpdate({
+          target: AccountStateTable.id,
+          set: { active_account_id: accountID, active_org_id: id },
+        })
+        .run()
+    }
+
+    const active = Effect.fn("AccountRepo.active")(() =>
+      query((db) => current(db)).pipe(Effect.map((row) => (row ? Option.some(decode(row)) : Option.none()))),
+    )
+
+    const list = Effect.fn("AccountRepo.list")(() =>
+      query((db) =>
+        db
+          .select()
+          .from(AccountTable)
+          .all()
+          .map((row: AccountRow) => decode({ ...row, active_org_id: null })),
+      ),
+    )
+
+    const remove = Effect.fn("AccountRepo.remove")((accountID: AccountID) =>
+      tx((db) => {
+        db.update(AccountStateTable)
+          .set({ active_account_id: null, active_org_id: null })
+          .where(eq(AccountStateTable.active_account_id, accountID))
+          .run()
+        db.delete(AccountTable).where(eq(AccountTable.id, accountID)).run()
+      }).pipe(Effect.asVoid),
+    )
+
+    const use = Effect.fn("AccountRepo.use")((accountID: AccountID, orgID: Option.Option<OrgID>) =>
+      query((db) => state(db, accountID, orgID)).pipe(Effect.asVoid),
+    )
+
+    const getRow = Effect.fn("AccountRepo.getRow")((accountID: AccountID) =>
+      query((db) => db.select().from(AccountTable).where(eq(AccountTable.id, accountID)).get()).pipe(
+        Effect.map(Option.fromNullishOr),
+      ),
+    )
+
+    const persistToken = Effect.fn("AccountRepo.persistToken")((input) =>
+      query((db) =>
+        db
+          .update(AccountTable)
+          .set({
+            access_token: input.accessToken,
+            refresh_token: input.refreshToken,
+            token_expiry: Option.getOrNull(input.expiry),
+          })
+          .where(eq(AccountTable.id, input.accountID))
+          .run(),
+      ).pipe(Effect.asVoid),
+    )
+
+    const persistAccount = Effect.fn("AccountRepo.persistAccount")((input) =>
+      tx((db) => {
+        const url = normalizeServerUrl(input.url)
+
+        db.insert(AccountTable)
+          .values({
+            id: input.id,
+            email: input.email,
+            url,
+            access_token: input.accessToken,
+            refresh_token: input.refreshToken,
+            token_expiry: input.expiry,
+          })
+          .onConflictDoUpdate({
+            target: AccountTable.id,
+            set: {
+              email: input.email,
+              url,
+              access_token: input.accessToken,
+              refresh_token: input.refreshToken,
+              token_expiry: input.expiry,
+            },
+          })
+          .run()
+        void state(db, input.id, input.orgID)
+      }).pipe(Effect.asVoid),
+    )
+
+    return Service.of({
+      active,
+      list,
+      remove,
+      use,
+      getRow,
+      persistToken,
+      persistAccount,
+    })
+  }),
+)
+
+export * as AccountRepo from "./repo"

package/src/account/schema.ts

@@ -0,0 +1,99 @@
+import { Schema } from "effect"
+import type * as HttpClientError from "effect/unstable/http/HttpClientError"
+
+export const AccountID = Schema.String.pipe(Schema.brand("AccountID"))
+export type AccountID = Schema.Schema.Type<typeof AccountID>
+
+export const OrgID = Schema.String.pipe(Schema.brand("OrgID"))
+export type OrgID = Schema.Schema.Type<typeof OrgID>
+
+export const AccessToken = Schema.String.pipe(Schema.brand("AccessToken"))
+export type AccessToken = Schema.Schema.Type<typeof AccessToken>
+
+export const RefreshToken = Schema.String.pipe(Schema.brand("RefreshToken"))
+export type RefreshToken = Schema.Schema.Type<typeof RefreshToken>
+
+export const DeviceCode = Schema.String.pipe(Schema.brand("DeviceCode"))
+export type DeviceCode = Schema.Schema.Type<typeof DeviceCode>
+
+export const UserCode = Schema.String.pipe(Schema.brand("UserCode"))
+export type UserCode = Schema.Schema.Type<typeof UserCode>
+
+export class Info extends Schema.Class<Info>("Account")({
+  id: AccountID,
+  email: Schema.String,
+  url: Schema.String,
+  active_org_id: Schema.NullOr(OrgID),
+}) {}
+
+export class Org extends Schema.Class<Org>("Org")({
+  id: OrgID,
+  name: Schema.String,
+}) {}
+
+export class AccountRepoError extends Schema.TaggedErrorClass<AccountRepoError>()("AccountRepoError", {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect),
+}) {}
+
+export class AccountServiceError extends Schema.TaggedErrorClass<AccountServiceError>()("AccountServiceError", {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect),
+}) {}
+
+export class AccountTransportError extends Schema.TaggedErrorClass<AccountTransportError>()("AccountTransportError", {
+  method: Schema.String,
+  url: Schema.String,
+  description: Schema.optional(Schema.String),
+  cause: Schema.optional(Schema.Defect),
+}) {
+  static fromHttpClientError(error: HttpClientError.TransportError): AccountTransportError {
+    return new AccountTransportError({
+      method: error.request.method,
+      url: error.request.url,
+      description: error.description,
+      cause: error.cause,
+    })
+  }
+
+  override get message(): string {
+    return [
+      `Could not reach ${this.method} ${this.url}.`,
+      `This failed before the server returned an HTTP response.`,
+      this.description,
+      `Check your network, proxy, or VPN configuration and try again.`,
+    ]
+      .filter(Boolean)
+      .join("\n")
+  }
+}
+
+export type AccountError = AccountRepoError | AccountServiceError | AccountTransportError
+
+export class Login extends Schema.Class<Login>("Login")({
+  code: DeviceCode,
+  user: UserCode,
+  url: Schema.String,
+  server: Schema.String,
+  expiry: Schema.Duration,
+  interval: Schema.Duration,
+}) {}
+
+export class PollSuccess extends Schema.TaggedClass<PollSuccess>()("PollSuccess", {
+  email: Schema.String,
+}) {}
+
+export class PollPending extends Schema.TaggedClass<PollPending>()("PollPending", {}) {}
+
+export class PollSlow extends Schema.TaggedClass<PollSlow>()("PollSlow", {}) {}
+
+export class PollExpired extends Schema.TaggedClass<PollExpired>()("PollExpired", {}) {}
+
+export class PollDenied extends Schema.TaggedClass<PollDenied>()("PollDenied", {}) {}
+
+export class PollError extends Schema.TaggedClass<PollError>()("PollError", {
+  cause: Schema.Defect,
+}) {}
+
+export const PollResult = Schema.Union([PollSuccess, PollPending, PollSlow, PollExpired, PollDenied, PollError])
+export type PollResult = Schema.Schema.Type<typeof PollResult>

package/src/account/url.ts

@@ -0,0 +1,8 @@
+export const normalizeServerUrl = (input: string): string => {
+  const url = new URL(input)
+  url.search = ""
+  url.hash = ""
+
+  const pathname = url.pathname.replace(/\/+$/, "")
+  return pathname.length === 0 ? url.origin : `${url.origin}${pathname}`
+}

package/src/acp/README.md

@@ -0,0 +1,174 @@
+# ACP (Agent Client Protocol) Implementation
+
+This directory contains a clean, protocol-compliant implementation of the [Agent Client Protocol](https://agentclientprotocol.com/) for saeeol.
+
+## Architecture
+
+The implementation follows a clean separation of concerns:
+
+### Core Components
+
+- **`agent.ts`** - Implements the `Agent` interface from `@agentclientprotocol/sdk`
+  - Handles initialization and capability negotiation
+  - Manages session lifecycle (`session/new`, `session/load`)
+  - Processes prompts and returns responses
+  - Properly implements ACP protocol v1
+
+- **`client.ts`** - Implements the `Client` interface for client-side capabilities
+  - File operations (`readTextFile`, `writeTextFile`)
+  - Permission requests (auto-approves for now)
+  - Terminal support (stub implementation)
+
+- **`session.ts`** - Session state management
+  - Creates and tracks ACP sessions
+  - Maps ACP sessions to internal saeeol sessions
+  - Maintains working directory context
+  - Handles MCP server configurations
+
+- **`server.ts`** - ACP server startup and lifecycle
+  - Sets up JSON-RPC over stdio using the official library
+  - Manages graceful shutdown on SIGTERM/SIGINT
+  - Provides Instance context for the agent
+
+- **`types.ts`** - Type definitions for internal use
+
+## Usage
+
+### Command Line
+
+```bash
+# Start the ACP server in the current directory
+saeeol acp
+
+# Start in a specific directory
+saeeol acp --cwd /path/to/project
+```
+
+### Question Tool Opt-In
+
+ACP excludes `QuestionTool` by default.
+
+```bash
+KILO_ENABLE_QUESTION_TOOL=1 saeeol acp
+```
+
+Enable this only for ACP clients that support interactive question prompts.
+
+### Programmatic
+
+```typescript
+import { ACPServer } from "./acp/server"
+
+await ACPServer.start()
+```
+
+### Integration with Zed
+
+Add to your Zed configuration (`~/.config/zed/settings.json`):
+
+```json
+{
+  "agent_servers": {
+    "Saeeol": {
+      "command": "saeeol",
+      "args": ["acp"]
+    }
+  }
+}
+```
+
+## Protocol Compliance
+
+This implementation follows the ACP specification v1:
+
+✅ **Initialization**
+
+- Proper `initialize` request/response with protocol version negotiation
+- Capability advertisement (`agentCapabilities`)
+- Authentication support (stub)
+
+✅ **Session Management**
+
+- `session/new` - Create new conversation sessions
+- `session/load` - Resume existing sessions (basic support)
+- Working directory context (`cwd`)
+- MCP server configuration support
+
+✅ **Prompting**
+
+- `session/prompt` - Process user messages
+- Content block handling (text, resources)
+- Response with stop reasons
+
+✅ **Client Capabilities**
+
+- File read/write operations
+- Permission requests
+- Terminal support (stub for future)
+
+## Current Limitations
+
+### Not Yet Implemented
+
+1. **Streaming Responses** - Currently returns complete responses instead of streaming via `session/update` notifications
+2. **Tool Call Reporting** - Doesn't report tool execution progress
+3. **Session Modes** - No mode switching support yet
+4. **Authentication** - No actual auth implementation
+5. **Terminal Support** - Placeholder only
+6. **Session Persistence** - `session/load` doesn't restore actual conversation history
+
+### Future Enhancements
+
+- **Real-time Streaming**: Implement `session/update` notifications for progressive responses
+- **Tool Call Visibility**: Report tool executions as they happen
+- **Session Persistence**: Save and restore full conversation history
+- **Mode Support**: Implement different operational modes (ask, code, etc.)
+- **Enhanced Permissions**: More sophisticated permission handling
+- **Terminal Integration**: Full terminal support via saeeol's bash tool
+
+## Testing
+
+```bash
+# Run ACP tests
+bun test test/acp.test.ts
+
+# Test manually with stdio
+echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":1}}' | saeeol acp
+```
+
+## Design Decisions
+
+### Why the Official Library?
+
+We use `@agentclientprotocol/sdk` instead of implementing JSON-RPC ourselves because:
+
+- Ensures protocol compliance
+- Handles edge cases and future protocol versions
+- Reduces maintenance burden
+- Works with other ACP clients automatically
+
+### Clean Architecture
+
+Each component has a single responsibility:
+
+- **Agent** = Protocol interface
+- **Client** = Client-side operations
+- **Session** = State management
+- **Server** = Lifecycle and I/O
+
+This makes the codebase maintainable and testable.
+
+### Mapping to Saeeol
+
+ACP sessions map cleanly to saeeol's internal session model:
+
+- ACP `session/new` → creates internal Session
+- ACP `session/prompt` → uses SessionPrompt.prompt()
+- Working directory context preserved per-session
+- Tool execution uses existing ToolRegistry
+
+## References
+
+- [ACP Specification](https://agentclientprotocol.com/)
+- [TypeScript Library](https://github.com/agentclientprotocol/typescript-sdk)
+- [Protocol Examples](https://github.com/agentclientprotocol/typescript-sdk/tree/main/src/examples)

package/src/acp/agent-events.ts

@@ -0,0 +1,157 @@
+import { type AgentSideConnection, type PermissionOption } from "@agentclientprotocol/sdk"
+import * as Log from "@saeeol/core/util/log"
+import { Hash } from "@saeeol/core/util/hash"
+import { Filesystem } from "@/util/filesystem"
+import { type Event, type ToolPart } from "@saeeol/sdk/v2"
+import { Result } from "effect"
+import { type ACPSessionManager } from "./session"
+import { toToolKind, toLocations, getNewContent, log, decodeTodos, sendUsageUpdate } from "./agent-utils"
+import type { AgentDeps } from "./agent-types"
+
+const permLog = Log.create({ service: "acp-permissions" })
+
+export function startEventSubscription(deps: AgentDeps, abort: AbortController, started: { value: boolean }) {
+  if (started.value) return
+  started.value = true
+  runEventSubscription(deps, abort).catch((error: unknown) => { if (!abort.signal.aborted) log.error("event subscription failed", { error }) })
+}
+
+async function runEventSubscription(deps: AgentDeps, abort: AbortController) {
+  while (true) {
+    if (abort.signal.aborted) return
+    const events = await deps.sdk.global.event({ signal: abort.signal })
+    for await (const event of events.stream) {
+      if (abort.signal.aborted) return
+      const payload = event?.payload
+      if (!payload) continue
+      await handleEvent(deps, payload as Event).catch((error: unknown) => { log.error("failed to handle event", { error, type: payload.type }) })
+    }
+  }
+}
+
+async function handleEvent(deps: AgentDeps, event: Event) {
+  switch (event.type) {
+    case "permission.asked": return handlePermission(deps, event.properties)
+    case "message.part.updated": return handleMessagePartUpdated(deps, event.properties)
+    case "message.part.delta": return handleMessagePartDelta(deps, event.properties)
+  }
+}
+
+async function handlePermission(deps: AgentDeps, permission: any) {
+  const session = deps.sessionManager.tryGet(permission.sessionID)
+  if (!session) return
+  const prev = deps.permissionQueues.get(permission.sessionID) ?? Promise.resolve()
+  const next = prev
+    .then(async () => {
+      const directory = session.cwd
+      const res = await deps.connection
+        .requestPermission({ sessionId: permission.sessionID, toolCall: { toolCallId: permission.tool?.callID ?? permission.id, status: "pending", title: permission.permission, rawInput: permission.metadata, kind: toToolKind(permission.permission), locations: toLocations(permission.permission, permission.metadata) }, options: deps.permissionOptions })
+        .catch(async (error: unknown) => { permLog.error("failed to request permission from ACP", { error, permissionID: permission.id, sessionID: permission.sessionID }); await deps.sdk.permission.reply({ requestID: permission.id, reply: "reject", directory }); return undefined })
+      if (!res) return
+      if (res.outcome.outcome !== "selected") { await deps.sdk.permission.reply({ requestID: permission.id, reply: "reject", directory }); return }
+      if (res.outcome.optionId !== "reject" && permission.permission == "edit") {
+        const metadata = permission.metadata || {}
+        const filepath = typeof metadata["filepath"] === "string" ? metadata["filepath"] : ""
+        const diff = typeof metadata["diff"] === "string" ? metadata["diff"] : ""
+        const content = (await Filesystem.exists(filepath)) ? await Filesystem.readText(filepath) : ""
+        const newContent = getNewContent(content, diff)
+        if (newContent) void deps.connection.writeTextFile({ sessionId: session.id, path: filepath, content: newContent })
+      }
+      await deps.sdk.permission.reply({ requestID: permission.id, reply: res.outcome.optionId as "once" | "always" | "reject", directory })
+    })
+    .catch((error: unknown) => { permLog.error("failed to handle permission", { error, permissionID: permission.id }) })
+    .finally(() => { if (deps.permissionQueues.get(permission.sessionID) === next) deps.permissionQueues.delete(permission.sessionID) })
+  deps.permissionQueues.set(permission.sessionID, next)
+}
+
+async function handleMessagePartUpdated(deps: AgentDeps, props: any) {
+  const part = props.part
+  const session = deps.sessionManager.tryGet(part.sessionID)
+  if (!session) return
+  const sessionId = session.id
+  if (part.type === "tool") {
+    await toolStart(deps, sessionId, part)
+    switch (part.state.status) {
+      case "pending": deps.bashSnapshots.delete(part.callID); return
+      case "running": return handleToolRunning(deps, sessionId, part)
+      case "completed": return handleToolCompleted(deps, sessionId, part)
+      case "error": return handleToolError(deps, sessionId, part)
+    }
+  }
+  if (part.type !== "text" && part.type !== "file") return
+  return
+}
+
+async function handleToolRunning(deps: AgentDeps, sessionId: string, part: ToolPart) {
+  const output = bashOutput(deps, part)
+  const content: any[] = []
+  if (output) {
+    const hash = Hash.fast(output)
+    if (part.tool === "bash") {
+      if (deps.bashSnapshots.get(part.callID) === hash) {
+        await deps.connection.sessionUpdate({ sessionId, update: { sessionUpdate: "tool_call_update", toolCallId: part.callID, status: "in_progress", kind: toToolKind(part.tool), title: part.tool, locations: toLocations(part.tool, part.state.input), rawInput: part.state.input } }).catch((error: unknown) => { log.error("failed to send tool in_progress to ACP", { error }) })
+        return
+      }
+      deps.bashSnapshots.set(part.callID, hash)
+    }
+    content.push({ type: "content", content: { type: "text", text: output } })
+  }
+  await deps.connection.sessionUpdate({ sessionId, update: { sessionUpdate: "tool_call_update", toolCallId: part.callID, status: "in_progress", kind: toToolKind(part.tool), title: part.tool, locations: toLocations(part.tool, part.state.input), rawInput: part.state.input, ...(content.length > 0 && { content }) } }).catch((error: unknown) => { log.error("failed to send tool in_progress to ACP", { error }) })
+}
+
+async function handleToolCompleted(deps: AgentDeps, sessionId: string, part: ToolPart) {
+  if (part.state.status !== "completed") return
+  deps.toolStarts.delete(part.callID)
+  deps.bashSnapshots.delete(part.callID)
+  const kind = toToolKind(part.tool)
+  const content: any[] = [{ type: "content", content: { type: "text", text: part.state.output } }]
+  if (kind === "edit") {
+    const input = part.state.input
+    content.push({ type: "diff", path: typeof input["filePath"] === "string" ? input["filePath"] : "", oldText: typeof input["oldString"] === "string" ? input["oldString"] : "", newText: typeof input["newString"] === "string" ? input["newString"] : typeof input["content"] === "string" ? input["content"] : "" })
+  }
+  if (part.tool === "todowrite") {
+    const parsedTodos = decodeTodos(part.state.output)
+    if (Result.isSuccess(parsedTodos)) {
+      await deps.connection.sessionUpdate({ sessionId, update: { sessionUpdate: "plan", entries: parsedTodos.success.map((todo) => ({ priority: "medium" as const, status: (todo.status === "cancelled" ? "completed" : todo.status) as any, content: todo.content })) } }).catch((error: unknown) => { log.error("failed to send session update for todo", { error }) })
+    } else { log.error("failed to parse todo output", { error: parsedTodos.failure }) }
+  }
+  await deps.connection.sessionUpdate({ sessionId, update: { sessionUpdate: "tool_call_update", toolCallId: part.callID, status: "completed", kind, content, title: part.state.title, rawInput: part.state.input, rawOutput: { output: part.state.output, metadata: part.state.metadata } } }).catch((error: unknown) => { log.error("failed to send tool completed to ACP", { error }) })
+}
+
+async function handleToolError(deps: AgentDeps, sessionId: string, part: ToolPart) {
+  if (part.state.status !== "error") return
+  deps.toolStarts.delete(part.callID)
+  deps.bashSnapshots.delete(part.callID)
+  await deps.connection.sessionUpdate({ sessionId, update: { sessionUpdate: "tool_call_update", toolCallId: part.callID, status: "failed", kind: toToolKind(part.tool), title: part.tool, rawInput: part.state.input, content: [{ type: "content", content: { type: "text", text: part.state.error } }], rawOutput: { error: part.state.error, metadata: part.state.metadata } } }).catch((error: unknown) => { log.error("failed to send tool error to ACP", { error }) })
+}
+
+async function handleMessagePartDelta(deps: AgentDeps, props: any) {
+  const session = deps.sessionManager.tryGet(props.sessionID)
+  if (!session) return
+  const sessionId = session.id
+  const message = await deps.sdk.session.message({ sessionID: props.sessionID, messageID: props.messageID, directory: session.cwd }, { throwOnError: true }).then((x: any) => x.data).catch((error: any) => { log.error("unexpected error when fetching message", { error }); return undefined })
+  if (!message || message.info.role !== "assistant") return
+  const part = message.parts.find((p: any) => p.id === props.partID)
+  if (!part) return
+  if (part.type === "text" && props.field === "text" && part.ignored !== true) {
+    await deps.connection.sessionUpdate({ sessionId, update: { sessionUpdate: "agent_message_chunk", messageId: props.messageID, content: { type: "text", text: props.delta } } }).catch((error: any) => { log.error("failed to send text delta to ACP", { error }) })
+    return
+  }
+  if (part.type === "reasoning" && props.field === "text") {
+    await deps.connection.sessionUpdate({ sessionId, update: { sessionUpdate: "agent_thought_chunk", messageId: props.messageID, content: { type: "text", text: props.delta } } }).catch((error: any) => { log.error("failed to send reasoning delta to ACP", { error }) })
+  }
+}
+
+export function bashOutput(deps: AgentDeps, part: ToolPart) {
+  if (part.tool !== "bash") return
+  if (!("metadata" in part.state) || !part.state.metadata || typeof part.state.metadata !== "object") return
+  const output = part.state.metadata["output"]
+  if (typeof output !== "string") return
+  return output
+}
+
+export async function toolStart(deps: AgentDeps, sessionId: string, part: ToolPart) {
+  if (deps.toolStarts.has(part.callID)) return
+  deps.toolStarts.add(part.callID)
+  await deps.connection.sessionUpdate({ sessionId, update: { sessionUpdate: "tool_call", toolCallId: part.callID, title: part.tool, kind: toToolKind(part.tool), status: "pending", locations: [], rawInput: {} } }).catch((error: any) => { log.error("failed to send tool pending to ACP", { error }) })
+}