saeeol 1.4.2 → 1.4.3

package/src/cli/cmd/providers-auth.ts

@@ -1,162 +0,0 @@
-import { Auth } from "../../auth"
-import { AppRuntime } from "../../effect/app-runtime"
-import * as prompts from "@clack/prompts"
-import { UI } from "../ui"
-import { Plugin } from "../../plugin"
-import { Instance } from "../../project/instance"
-import type { Hooks } from "@saeeol/plugin"
-import { Effect } from "effect"
-
-type PluginAuth = NonNullable<Hooks["auth"]>
-
-export const put = (key: string, info: Auth.Info) =>
-  AppRuntime.runPromise(
-    Effect.gen(function* () {
-      const auth = yield* Auth.Service
-      yield* auth.set(key, info)
-    }),
-  )
-
-export async function handlePluginAuth(
-  plugin: { auth: PluginAuth },
-  provider: string,
-  methodName?: string,
-): Promise<boolean> {
-  let index = 0
-  if (methodName) {
-    const match = plugin.auth.methods.findIndex((x) => x.label.toLowerCase() === methodName.toLowerCase())
-    if (match === -1) {
-      prompts.log.error(
-        `Unknown method "${methodName}" for ${provider}. Available: ${plugin.auth.methods.map((x) => x.label).join(", ")}`,
-      )
-      process.exit(1)
-    }
-    index = match
-  } else if (plugin.auth.methods.length > 1) {
-    const method = await prompts.select({
-      message: "Login method",
-      options: plugin.auth.methods.map((x, index) => ({ label: x.label, value: index.toString() })),
-    })
-    if (prompts.isCancel(method)) throw new UI.CancelledError()
-    index = parseInt(method)
-  }
-  const method = plugin.auth.methods[index]
-
-  await new Promise((r) => setTimeout(r, 10))
-  const inputs: Record<string, string> = {}
-  if (method.prompts) {
-    for (const prompt of method.prompts) {
-      if (prompt.when) {
-        const value = inputs[prompt.when.key]
-        if (value === undefined) continue
-        const matches = prompt.when.op === "eq" ? value === prompt.when.value : value !== prompt.when.value
-        if (!matches) continue
-      }
-      if (prompt.condition && !prompt.condition(inputs)) continue
-      if (prompt.type === "select") {
-        const value = await prompts.select({ message: prompt.message, options: prompt.options })
-        if (prompts.isCancel(value)) throw new UI.CancelledError()
-        inputs[prompt.key] = value
-      } else {
-        const value = await prompts.text({
-          message: prompt.message,
-          placeholder: prompt.placeholder,
-          validate: prompt.validate ? (v) => prompt.validate!(v ?? "") : undefined,
-        })
-        if (prompts.isCancel(value)) throw new UI.CancelledError()
-        inputs[prompt.key] = value
-      }
-    }
-  }
-
-  if (method.type === "oauth") {
-    const authorize = await method.authorize(inputs)
-    if (authorize.url) prompts.log.info("Go to: " + authorize.url)
-
-    if (authorize.method === "auto") {
-      if (authorize.instructions) prompts.log.info(authorize.instructions)
-      const spinner = prompts.spinner()
-      spinner.start("Waiting for authorization...")
-      const result = await authorize.callback()
-      if (result.type === "failed") spinner.stop("Failed to authorize", 1)
-      if (result.type === "success") {
-        const saveProvider = result.provider ?? provider
-        if ("refresh" in result) {
-          const { type: _, provider: __, refresh, access, expires, ...extra } = result
-          await put(saveProvider, { type: "oauth", refresh, access, expires, ...extra })
-        }
-        if ("key" in result) await put(saveProvider, { type: "api", key: result.key })
-        spinner.stop("Login successful")
-      }
-    }
-
-    if (authorize.method === "code") {
-      const code = await prompts.text({
-        message: "Paste the authorization code here: ",
-        validate: (x) => (x && x.length > 0 ? undefined : "Required"),
-      })
-      if (prompts.isCancel(code)) throw new UI.CancelledError()
-      const result = await authorize.callback(code)
-      if (result.type === "failed") prompts.log.error("Failed to authorize")
-      if (result.type === "success") {
-        const saveProvider = result.provider ?? provider
-        if ("refresh" in result) {
-          const { type: _, provider: __, refresh, access, expires, ...extra } = result
-          await put(saveProvider, { type: "oauth", refresh, access, expires, ...extra })
-        }
-        if ("key" in result) await put(saveProvider, { type: "api", key: result.key })
-        prompts.log.success("Login successful")
-      }
-    }
-
-    prompts.outro("Done")
-    return true
-  }
-
-  if (method.type === "api") {
-    const key = await prompts.password({
-      message: "Enter your API key",
-      validate: (x) => (x && x.length > 0 ? undefined : "Required"),
-    })
-    if (prompts.isCancel(key)) throw new UI.CancelledError()
-    const metadata = Object.keys(inputs).length ? { metadata: inputs } : {}
-    if (!method.authorize) {
-      await put(provider, { type: "api", key, ...metadata })
-      prompts.outro("Done")
-      return true
-    }
-    const result = await method.authorize(inputs)
-    if (result.type === "failed") prompts.log.error("Failed to authorize")
-    if (result.type === "success") {
-      const saveProvider = result.provider ?? provider
-      await put(saveProvider, { type: "api", key: result.key ?? key, ...metadata })
-      prompts.log.success("Login successful")
-    }
-    prompts.outro("Done")
-    return true
-  }
-
-  return false
-}
-
-export function resolvePluginProviders(input: {
-  hooks: Hooks[]
-  existingProviders: Record<string, unknown>
-  disabled: Set<string>
-  enabled?: Set<string>
-  providerNames: Record<string, string | undefined>
-}): Array<{ id: string; name: string }> {
-  const seen = new Set<string>()
-  const result: Array<{ id: string; name: string }> = []
-  for (const hook of input.hooks) {
-    if (!hook.auth) continue
-    const id = hook.auth.provider
-    if (seen.has(id)) continue
-    seen.add(id)
-    if (Object.hasOwn(input.existingProviders, id)) continue
-    if (input.disabled.has(id)) continue
-    if (input.enabled && !input.enabled.has(id)) continue
-    result.push({ id, name: input.providerNames[id] ?? id })
-  }
-  return result
-}

package/src/cli/cmd/providers.ts

@@ -1,302 +0,0 @@
-import { Auth } from "../../auth"
-import { AppRuntime } from "../../effect/app-runtime"
-import { cmd } from "./cmd"
-import * as prompts from "@clack/prompts"
-import { UI } from "../ui"
-import { ModelsDev } from "@/provider/models"
-import { map, pipe, sortBy, values } from "remeda"
-import path from "path"
-import os from "os"
-import { Config } from "@/config/config"
-import { Global } from "@saeeol/core/global"
-import { Plugin } from "../../plugin"
-import { Instance } from "../../project/instance"
-import { Process } from "@/util/process"
-import { text } from "node:stream/consumers"
-import { Effect } from "effect"
-import { Npm } from "@saeeol/core/npm"
-import { put, handlePluginAuth, resolvePluginProviders } from "./providers-auth"
-
-const getModels = () => AppRuntime.runPromise(ModelsDev.Service.use((s) => s.get()))
-const refreshModels = () => AppRuntime.runPromise(ModelsDev.Service.use((s) => s.refresh(true)))
-
-export const ProvidersCommand = cmd({
-  command: "auth",
-  aliases: ["providers"],
-  describe: "manage AI providers and credentials",
-  builder: (yargs) =>
-    yargs
-      .command(ProvidersListCommand)
-      .command(ProvidersLoginCommand)
-      .command(ProvidersLogoutCommand)
-      .command(ProvidersInstallCommand)
-      .demandCommand(),
-  async handler() {},
-})
-
-export const ProvidersListCommand = cmd({
-  command: "list",
-  aliases: ["ls"],
-  describe: "list providers",
-  async handler() {
-    await Instance.provide({
-      directory: process.cwd(),
-      async fn() {
-        UI.empty()
-        const authPath = path.join(Global.Path.data, "auth.json")
-        const homedir = os.homedir()
-        const displayPath = authPath.startsWith(homedir) ? authPath.replace(homedir, "~") : authPath
-        prompts.intro(`Credentials ${UI.Style.TEXT_DIM}${displayPath}`)
-        const results = await AppRuntime.runPromise(
-          Effect.gen(function* () {
-            const auth = yield* Auth.Service
-            return Object.entries(yield* auth.all())
-          }),
-        )
-        const database = await getModels()
-        for (const [providerID, result] of results) {
-          const name = database[providerID]?.name || providerID
-          prompts.log.info(`${name} ${UI.Style.TEXT_DIM}${result.type}`)
-        }
-        prompts.outro(`${results.length} credentials`)
-
-        const activeEnvVars: Array<{ provider: string; envVar: string }> = []
-        for (const [providerID, provider] of Object.entries(database)) {
-          for (const envVar of provider.env) {
-            if (process.env[envVar]) activeEnvVars.push({ provider: provider.name || providerID, envVar })
-          }
-        }
-        if (activeEnvVars.length > 0) {
-          UI.empty()
-          prompts.intro("Environment")
-          for (const { provider, envVar } of activeEnvVars) prompts.log.info(`${provider} ${UI.Style.TEXT_DIM}${envVar}`)
-          prompts.outro(`${activeEnvVars.length} environment variable` + (activeEnvVars.length === 1 ? "" : "s"))
-        }
-      },
-    })
-  },
-})
-
-export const ProvidersLoginCommand = cmd({
-  command: "login [url]",
-  describe: "log in to a provider",
-  builder: (yargs) =>
-    yargs
-      .positional("url", { describe: "saeeol auth provider", type: "string" })
-      .option("provider", { alias: ["p"], describe: "provider id or name", type: "string" })
-      .option("method", { alias: ["m"], describe: "login method label", type: "string" }),
-  async handler(args) {
-    await Instance.provide({
-      directory: process.cwd(),
-      async fn() {
-        UI.empty()
-        prompts.intro("Add credential")
-        if (args.url) return await loginViaUrl(args.url)
-
-        await refreshModels().catch(() => {})
-        const config = await AppRuntime.runPromise(Config.Service.use((cfg) => cfg.get()))
-        const disabled = new Set(config.disabled_providers ?? [])
-        const enabled = config.enabled_providers ? new Set(config.enabled_providers) : undefined
-
-        const providers = await getModels().then((x) => {
-          const filtered: Record<string, (typeof x)[string]> = {}
-          for (const [key, value] of Object.entries(x)) {
-            if ((enabled ? enabled.has(key) : true) && !disabled.has(key)) filtered[key] = value
-          }
-          return filtered
-        })
-        const hooks = await AppRuntime.runPromise(
-          Effect.gen(function* () { const plugin = yield* Plugin.Service; return yield* plugin.list() }),
-        )
-        const priority: Record<string, number> = {
-          saeeol: 0, anthropic: 2, "github-copilot": 3, openai: 4, google: 5, openrouter: 6, vercel: 7,
-        }
-        const pluginProviders = resolvePluginProviders({
-          hooks, existingProviders: providers, disabled, enabled,
-          providerNames: Object.fromEntries(Object.entries(config.provider ?? {}).flatMap(([id, p]) => (p ? [[id, p.name]] : []))),
-        })
-        const options = [
-          ...pipe(
-            providers, values(),
-            sortBy((x) => priority[x.id] ?? 99, (x) => x.name ?? x.id),
-            map((x) => ({ label: x.name, value: x.id, hint: { saeeol: "recommended", openai: "ChatGPT login or API key" }[x.id] })),
-          ),
-          ...pluginProviders.map((x) => ({ label: x.name, value: x.id, hint: "plugin" })),
-        ]
-
-        let provider = await resolveProvider(args.provider, options)
-        const plugin = hooks.findLast((x) => x.auth?.provider === provider)
-        if (plugin?.auth) {
-          const handled = await handlePluginAuth({ auth: plugin.auth }, provider, args.method)
-          if (handled) return
-        }
-        if (provider === "other") {
-          provider = await promptCustomProvider(hooks, args.method)
-          prompts.log.warn(`This only stores a credential for ${provider} - configure it in saeeol.json.`)
-        }
-        logProviderHints(provider)
-        const key = await prompts.password({ message: "Enter your API key", validate: (x) => (x && x.length > 0 ? undefined : "Required") })
-        if (prompts.isCancel(key)) throw new UI.CancelledError()
-        await put(provider, { type: "api", key })
-        prompts.outro("Done")
-      },
-    })
-  },
-})
-
-async function loginViaUrl(url: string) {
-  const normalized = url.replace(/\/+$/, "")
-  const wellknown = (await fetch(`${normalized}/.well-known/saeeol`).then((x) => x.json())) as {
-    auth: { command: string[]; env: string }
-  }
-  prompts.log.info(`Running \`${wellknown.auth.command.join(" ")}\``)
-  const proc = Process.spawn(wellknown.auth.command, { stdout: "pipe" })
-  if (!proc.stdout) { prompts.log.error("Failed"); prompts.outro("Done"); return }
-  const [exit, token] = await Promise.all([proc.exited, text(proc.stdout)])
-  if (exit !== 0) { prompts.log.error("Failed"); prompts.outro("Done"); return }
-  await put(normalized, { type: "wellknown", key: wellknown.auth.env, token: token.trim() })
-  prompts.log.success("Logged into " + normalized)
-  prompts.outro("Done")
-}
-
-async function resolveProvider(input: string | undefined, options: Array<{ label: string; value: string; hint?: string }>) {
-  if (input) {
-    const byID = options.find((x) => x.value === input)
-    const byName = options.find((x) => x.label.toLowerCase() === input.toLowerCase())
-    const alias = input.toLowerCase() === "codex" ? options.find((x) => x.value === "openai") : undefined
-    const match = byID ?? byName ?? alias
-    if (!match) { prompts.log.error(`Unknown provider "${input}"`); process.exit(1) }
-    return match.value
-  }
-  const selected = await prompts.autocomplete({
-    message: "Select provider", maxItems: 8,
-    options: [...options, { value: "other", label: "Other" }],
-  })
-  if (prompts.isCancel(selected)) throw new UI.CancelledError()
-  return selected as string
-}
-
-async function promptCustomProvider(hooks: import("@saeeol/plugin").Hooks[], method?: string) {
-  const custom = await prompts.text({
-    message: "Enter provider id",
-    validate: (x) => (x && x.match(/^[0-9a-z-]+$/) ? undefined : "a-z, 0-9 and hyphens only"),
-  })
-  if (prompts.isCancel(custom)) throw new UI.CancelledError()
-  const provider = custom.replace(/^@ai-sdk\//, "")
-  const customPlugin = hooks.findLast((x) => x.auth?.provider === provider)
-  if (customPlugin?.auth) {
-    const handled = await handlePluginAuth({ auth: customPlugin.auth }, provider, method)
-    if (handled) return provider
-  }
-  return provider
-}
-
-function logProviderHints(provider: string) {
-  if (provider === "amazon-bedrock") {
-    prompts.log.info(
-      "Amazon Bedrock auth priority:\n  1. Bearer token (AWS_BEARER_TOKEN_BEDROCK)\n  2. AWS credential chain\n" +
-        "Configure via saeeol.json or AWS env vars.",
-    )
-  }
-  if (provider === "saeeol") prompts.log.info("Create an api key at https://saeeol.ai/auth")
-  if (provider === "vercel") prompts.log.info("Create an api key at https://vercel.link/ai-gateway-token")
-  if (["cloudflare", "cloudflare-ai-gateway"].includes(provider)) {
-    prompts.log.info("Cloudflare AI Gateway can be configured with CLOUDFLARE_GATEWAY_ID, CLOUDFLARE_ACCOUNT_ID, and CLOUDFLARE_API_TOKEN env vars.")
-  }
-}
-
-export const ProvidersLogoutCommand = cmd({
-  command: "logout",
-  describe: "log out from a configured provider",
-  async handler() {
-    await Instance.provide({
-      directory: process.cwd(),
-      async fn() {
-        UI.empty()
-        const credentials = await Auth.all().then((x) => Object.entries(x))
-        prompts.intro("Remove credential")
-        if (credentials.length === 0) { prompts.log.error("No credentials found"); return }
-        const database = await getModels()
-        const selected = await prompts.select({
-          message: "Select provider",
-          options: credentials.map(([key, value]) => ({
-            label: (database[key]?.name || key) + UI.Style.TEXT_DIM + " (" + value.type + ")", value: key,
-          })),
-        })
-        if (prompts.isCancel(selected)) throw new UI.CancelledError()
-        await AppRuntime.runPromise(
-          Effect.gen(function* () { const auth = yield* Auth.Service; yield* auth.remove(selected as string) }),
-        )
-        prompts.outro("Logout successful")
-      },
-    })
-  },
-})
-
-export const ProvidersInstallCommand = cmd({
-  command: "install [providers..]",
-  describe: "pre-install provider SDK packages (skip runtime download delay)",
-  builder: (yargs) =>
-    yargs.positional("providers", {
-      describe: "provider id(s) to install (e.g. anthropic openai google)",
-      type: "string",
-      array: true,
-    }),
-  async handler(args) {
-    await Instance.provide({
-      directory: process.cwd(),
-      async fn() {
-        UI.empty()
-        prompts.intro("Install provider SDKs")
-
-        await refreshModels().catch(() => {})
-        const database = await getModels()
-
-        // Build npm package → provider names mapping from models.dev data
-        const npmToNames: Record<string, Set<string>> = {}
-        for (const [id, info] of Object.entries(database)) {
-          const pkg = info.npm
-          if (!pkg) continue
-          if (!npmToNames[pkg]) npmToNames[pkg] = new Set()
-          npmToNames[pkg].add(info.name || id)
-        }
-
-        // Resolve target packages
-        const targets = args.providers?.length
-          ? args.providers
-          : await (async () => {
-              const options = Object.entries(npmToNames).map(([pkg, names]) => ({
-                label: [...names].join(", "),
-                value: pkg,
-                hint: pkg,
-              }))
-              const selected = await prompts.multiselect({
-                message: "Select providers to install",
-                options,
-                required: true,
-              })
-              if (prompts.isCancel(selected)) throw new UI.CancelledError()
-              return selected as string[]
-            })()
-
-        for (const target of targets) {
-          // If user typed a provider id (like "anthropic"), resolve to npm package
-          const pkg = npmToNames[target] ? target
-            : Object.entries(database).find(([id]) => id === target)?.[1]?.npm
-            ?? target
-
-          const spinner = prompts.spinner()
-          spinner.start(`Installing ${pkg}`)
-          try {
-            await Npm.add(pkg)
-            spinner.stop(`${pkg} installed`)
-          } catch (err) {
-            spinner.stop(`${pkg} failed: ${err instanceof Error ? err.message : String(err)}`)
-          }
-        }
-
-        prompts.outro("Done")
-      },
-    })
-  },
-})

package/src/cli/cmd/remote.ts

@@ -1,31 +0,0 @@
-import { cmd } from "./cmd"
-import { bootstrap } from "../bootstrap"
-import { SaeeolSessions } from "@/sessions/sessions"
-import { Instance } from "@/project/instance"
-import { InstanceStore } from "@/project/instance-store"
-
-export const RemoteCommand = cmd({
-  command: "remote",
-  describe: "enable remote connection for real-time session relay",
-  builder: (yargs) => yargs,
-  handler: async () => {
-    await bootstrap(process.cwd(), async () => {
-      await SaeeolSessions.enableRemote()
-      console.log("Remote connection enabled.")
-
-      const abort = new AbortController()
-      const shutdown = async () => {
-        try {
-          SaeeolSessions.disableRemote()
-          await InstanceStore.disposeInstance(Instance.current)
-        } finally {
-          abort.abort()
-        }
-      }
-      process.on("SIGTERM", shutdown)
-      process.on("SIGINT", shutdown)
-      process.on("SIGHUP", shutdown)
-      await new Promise((resolve) => abort.signal.addEventListener("abort", resolve))
-    })
-  },
-})

package/src/cli/cmd/run-display.ts

@@ -1,169 +0,0 @@
-import type { ToolPart } from "@saeeol/sdk/v2"
-import type { InferParameters, InferMetadata } from "../../tool/tool"
-import { GlobTool } from "../../tool/glob"
-import { GrepTool } from "../../tool/grep"
-import { ReadTool } from "../../tool/read"
-import { WriteTool } from "../../tool/write"
-import { WebFetchTool } from "../../tool/webfetch"
-import { EditTool } from "../../tool/edit"
-import { WebSearchTool } from "../../tool/websearch"
-import { TaskTool } from "../../tool/task"
-import { SkillTool } from "../../tool/skill"
-import { BashTool } from "../../tool/bash"
-import { TodoWriteTool } from "../../tool/todo"
-import { UI } from "../ui"
-import { Locale } from "@/util/locale"
-import path from "path"
-
-export type ToolProps<T> = {
-  input: InferParameters<T>
-  metadata: InferMetadata<T>
-  part: ToolPart
-}
-
-export function props<T>(part: ToolPart): ToolProps<T> {
-  const state = part.state
-  return {
-    input: state.input as InferParameters<T>,
-    metadata: ("metadata" in state ? state.metadata : {}) as InferMetadata<T>,
-    part,
-  }
-}
-
-export type Inline = {
-  icon: string
-  title: string
-  description?: string
-}
-
-export function inline(info: Inline) {
-  const suffix = info.description ? UI.Style.TEXT_DIM + ` ${info.description}` + UI.Style.TEXT_NORMAL : ""
-  UI.println(UI.Style.TEXT_NORMAL + info.icon, UI.Style.TEXT_NORMAL + info.title + suffix)
-}
-
-function block(info: Inline, output?: string) {
-  UI.empty()
-  inline(info)
-  if (!output?.trim()) return
-  UI.println(output)
-  UI.empty()
-}
-
-export function normalizePath(input?: string) {
-  if (!input) return ""
-  if (path.isAbsolute(input)) return path.relative(process.cwd(), input) || "."
-  return input
-}
-
-export function displayTool(part: ToolPart) {
-  try {
-    if (part.tool === "bash") return bash(props<typeof BashTool>(part))
-    if (part.tool === "glob") return glob(props<typeof GlobTool>(part))
-    if (part.tool === "grep") return grep(props<typeof GrepTool>(part))
-    if (part.tool === "read") return read(props<typeof ReadTool>(part))
-    if (part.tool === "write") return write(props<typeof WriteTool>(part))
-    if (part.tool === "webfetch") return webfetch(props<typeof WebFetchTool>(part))
-    if (part.tool === "edit") return edit(props<typeof EditTool>(part))
-    if (part.tool === "websearch") return websearch(props<typeof WebSearchTool>(part))
-    if (part.tool === "task") return task(props<typeof TaskTool>(part))
-    if (part.tool === "todowrite") return todo(props<typeof TodoWriteTool>(part))
-    if (part.tool === "skill") return skill(props<typeof SkillTool>(part))
-    return fallback(part)
-  } catch {
-    return fallback(part)
-  }
-}
-
-function fallback(part: ToolPart) {
-  const state = part.state
-  const input = "input" in state ? state.input : undefined
-  const title =
-    ("title" in state && state.title ? state.title : undefined) ||
-    (input && typeof input === "object" && Object.keys(input).length > 0 ? JSON.stringify(input) : "Unknown")
-  inline({ icon: "⚙", title: `${part.tool} ${title}` })
-}
-
-function glob(info: ToolProps<typeof GlobTool>) {
-  const root = info.input.path ?? ""
-  const title = `Glob "${info.input.pattern}"`
-  const suffix = root ? `in ${normalizePath(root)}` : ""
-  const num = info.metadata.count
-  const description =
-    num === undefined ? suffix : `${suffix}${suffix ? " · " : ""}${num} ${num === 1 ? "match" : "matches"}`
-  inline({ icon: "✱", title, ...(description && { description }) })
-}
-
-function grep(info: ToolProps<typeof GrepTool>) {
-  const root = info.input.path ?? ""
-  const title = `Grep "${info.input.pattern}"`
-  const suffix = root ? `in ${normalizePath(root)}` : ""
-  const num = info.metadata.matches
-  const description =
-    num === undefined ? suffix : `${suffix}${suffix ? " · " : ""}${num} ${num === 1 ? "match" : "matches"}`
-  inline({ icon: "✱", title, ...(description && { description }) })
-}
-
-function read(info: ToolProps<typeof ReadTool>) {
-  const file = normalizePath(info.input.filePath)
-  const pairs = Object.entries(info.input).filter(([key, value]) => {
-    if (key === "filePath") return false
-    return typeof value === "string" || typeof value === "number" || typeof value === "boolean"
-  })
-  const description = pairs.length ? `[${pairs.map(([key, value]) => `${key}=${value}`).join(", ")}]` : undefined
-  inline({ icon: "→", title: `Read ${file}`, ...(description && { description }) })
-}
-
-function write(info: ToolProps<typeof WriteTool>) {
-  block(
-    { icon: "←", title: `Write ${normalizePath(info.input.filePath)}` },
-    info.part.state.status === "completed" ? info.part.state.output : undefined,
-  )
-}
-
-function webfetch(info: ToolProps<typeof WebFetchTool>) {
-  inline({ icon: "%", title: `WebFetch ${info.input.url}` })
-}
-
-function edit(info: ToolProps<typeof EditTool>) {
-  block(
-    { icon: "←", title: `Edit ${normalizePath(info.input.filePath)}` },
-    info.metadata.diff,
-  )
-}
-
-function websearch(info: ToolProps<typeof WebSearchTool>) {
-  inline({ icon: "◈", title: `Exa Web Search "${info.input.query}"` })
-}
-
-export function displayTask(part: ToolPart) {
-  task(props<typeof TaskTool>(part))
-}
-
-function task(info: ToolProps<typeof TaskTool>) {
-  const input = info.part.state.input
-  const status = info.part.state.status
-  const subagent =
-    typeof input.subagent_type === "string" && input.subagent_type.trim().length > 0 ? input.subagent_type : "unknown"
-  const agent = Locale.titlecase(subagent)
-  const desc =
-    typeof input.description === "string" && input.description.trim().length > 0 ? input.description : undefined
-  const icon = status === "error" ? "✗" : status === "running" ? "•" : "✓"
-  const name = desc ?? `${agent} Task`
-  inline({ icon, title: name, description: desc ? `${agent} Agent` : undefined })
-}
-
-function skill(info: ToolProps<typeof SkillTool>) {
-  inline({ icon: "→", title: `Skill "${info.input.name}"` })
-}
-
-function bash(info: ToolProps<typeof BashTool>) {
-  const output = info.part.state.status === "completed" ? info.part.state.output?.trim() : undefined
-  block({ icon: "$", title: `${info.input.command}` }, output)
-}
-
-function todo(info: ToolProps<typeof TodoWriteTool>) {
-  block(
-    { icon: "#", title: "Todos" },
-    info.input.todos.map((item: { status: string; content: string }) => `${item.status === "completed" ? "[x]" : "[ ]"} ${item.content}`).join("\n"),
-  )
-}