@d4y/agent-runtime-nuxt 0.1.0 → 0.1.1

package/src/runtime/composables/useAgentRuntime.ts

@@ -1,527 +0,0 @@
-import { computed, onMounted, ref, shallowRef, type Ref, type ComputedRef } from 'vue'
-import type { UIMessage as AiUIMessage } from 'ai'
-import { useRuntimeConfig } from 'nuxt/app'
-
-/**
- * Re-export the AI SDK's `UIMessage` shape — this is the type Nuxt UI's chat
- * components accept, so we use it everywhere in the public surface to keep
- * downstream code zero-friction.
- */
-export type UIMessage = AiUIMessage
-
-/**
- * Lifecycle status for a chat. Mirrors what the AI-SDK `UIMessage` consumers
- * expect, so you can wire this directly into Nuxt UI's `<UChatMessages :status>`.
- */
-export type ChatStatus = 'idle' | 'submitted' | 'streaming' | 'ready' | 'error'
-
-/* -------------------------------------------------------------------------- */
-/* Internal part shapes (AI SDK compatible)                                   */
-/* -------------------------------------------------------------------------- */
-
-interface TextPart { type: 'text', text: string }
-interface ReasoningPart { type: 'reasoning', text: string }
-interface ToolPart {
-  type: `tool-${string}`
-  toolCallId: string
-  state: 'input-available' | 'output-available' | 'output-error'
-  input?: unknown
-  output?: unknown
-  errorText?: string
-}
-type AgentRuntimePart = TextPart | ReasoningPart | ToolPart
-
-/** Internal message representation — cast to {@link UIMessage} at the boundary. */
-interface AgentRuntimeMessage {
-  id: string
-  role: 'user' | 'assistant' | 'system'
-  parts: AgentRuntimePart[]
-}
-
-/* -------------------------------------------------------------------------- */
-/* App / auth                                                                 */
-/* -------------------------------------------------------------------------- */
-
-/** Single env-var slot declared by an app's manifest. */
-export interface AppEnvField {
-  required: boolean
-  secret: boolean
-  description?: string
-}
-
-/** Manifest summary for the active app, as returned by `${apiPrefix}/app`. */
-export interface AppInfo {
-  appId: string
-  name: string
-  envSchema: Record<string, AppEnvField>
-}
-
-/**
- * Generic auth state. Keys are app-defined (whatever the active app declares
- * in its manifest `envSchema`) — the module does not care what they mean,
- * it just ships the resulting map to agent-runtime as the conversation env.
- */
-export interface AppAuth {
-  values: Record<string, string>
-}
-
-/* -------------------------------------------------------------------------- */
-/* Misc                                                                       */
-/* -------------------------------------------------------------------------- */
-
-/** Side-channel UI-action event emitted by the agent (via the `ui_action` SSE event). */
-export interface UiAction {
-  toolCallId: string
-  type: string
-  payload: unknown
-  at: number
-}
-
-/** Workspace file entry, mirrors the backend response. */
-export interface FileEntry {
-  name: string
-  relPath: string
-  size: number
-  mtime: string
-  mimeType: string
-}
-
-/** Per-turn options for `send`. */
-export interface SendOptions {
-  /**
-   * Optional dynamic context object forwarded verbatim to the agent for this
-   * turn (the harness passes it into `agent.run`'s `context` field).
-   */
-  context?: unknown
-  /**
-   * Pre-`send` hook to mutate the *forwarded* prompt without changing what is
-   * displayed to the user. Useful for model-specific soft switches like
-   * Qwen3's `/think` / `/no_think` toggles. Return the rewritten string.
-   */
-  rewriteContent?: (text: string) => string
-  /** Optional language override for this turn / conversation, e.g. `en` or `de-CH`. */
-  language?: string
-}
-
-/** Options for `start`. */
-export interface StartOptions {
-  /** Optional language override for the newly created conversation. */
-  language?: string
-}
-
-/* -------------------------------------------------------------------------- */
-/* Public surface                                                             */
-/* -------------------------------------------------------------------------- */
-
-/** Return shape of {@link useAgentRuntime}. All members are reactive. */
-export interface UseAgentRuntime {
-  /** Active conversation id, or `null` until `start()` (or the first `send()`) succeeds. */
-  conversationId: Ref<string | null>
-  /** Ordered list of UI messages to render. Mutated as SSE events arrive. */
-  messages: Ref<UIMessage[]>
-  /** Lifecycle status — drive your UI from this. */
-  status: Ref<ChatStatus>
-  /** Last error encountered (network failure, upstream error, missing auth, ...). */
-  error: Ref<Error | null>
-  /** Most recent UI-action events, newest first, capped at 50. */
-  uiActions: Ref<UiAction[]>
-  /** Active app manifest. `null` until the first `onMounted` fetch resolves. */
-  app: Ref<AppInfo | null>
-  /** Current auth values (persisted in localStorage, scoped per appId). */
-  auth: Ref<AppAuth>
-  /** True iff every required env var has a non-empty value. */
-  authReady: ComputedRef<boolean>
-  /** Workspace files for the current conversation. Refreshed on every stream `end` event. */
-  files: Ref<FileEntry[]>
-  /** Build the proxied download URL for a workspace-relative path. */
-  fileUrl: (relPath: string) => string
-  /** Manually re-fetch the workspace file listing. */
-  refreshFiles: () => Promise<void>
-  /** Persist a new auth map; if a conversation is open, push the change to its env. */
-  saveAuth: (next: AppAuth) => Promise<void>
-  /** Open a fresh conversation with the current auth. Returns the new id. */
-  start: (options?: StartOptions) => Promise<string>
-  /** Append a user message; lazily calls `start()` if no conversation exists yet. */
-  send: (text: string, options?: SendOptions) => Promise<void>
-  /** Cancel the in-flight agent run. */
-  abort: () => Promise<void>
-  /** Tear down state — drops the conversation reference, clears messages and files. */
-  reset: () => Promise<void>
-}
-
-/* -------------------------------------------------------------------------- */
-/* Implementation                                                             */
-/* -------------------------------------------------------------------------- */
-
-const newId = (): string =>
-  typeof crypto !== 'undefined' && 'randomUUID' in crypto
-    ? crypto.randomUUID()
-    : `id-${Date.now()}-${Math.random().toString(36).slice(2)}`
-
-const authStorageKey = (appId: string): string => `agent-runtime.app-auth.${appId}`
-
-const emptyAuth = (): AppAuth => ({ values: {} })
-
-const loadAuth = (appId: string): AppAuth => {
-  if (typeof window === 'undefined') return emptyAuth()
-  try {
-    const raw = window.localStorage.getItem(authStorageKey(appId))
-    if (!raw) return emptyAuth()
-    const parsed = JSON.parse(raw) as Partial<AppAuth>
-    return { values: { ...(parsed.values ?? {}) } }
-  } catch {
-    return emptyAuth()
-  }
-}
-
-const persistAuth = (appId: string, auth: AppAuth): void => {
-  if (typeof window === 'undefined') return
-  try {
-    window.localStorage.setItem(authStorageKey(appId), JSON.stringify(auth))
-  } catch {}
-}
-
-const buildEnvFromAuth = (auth: AppAuth): Record<string, string> => {
-  const out: Record<string, string> = {}
-  for (const [k, v] of Object.entries(auth.values)) {
-    const trimmed = (v ?? '').trim()
-    if (trimmed) out[k] = trimmed
-  }
-  return out
-}
-
-const computeAuthReady = (auth: AppAuth, app: AppInfo | null): boolean => {
-  if (!app) return false
-  const required = Object.entries(app.envSchema).filter(([, f]) => f.required).map(([k]) => k)
-  return required.every(k => (auth.values[k] ?? '').trim().length > 0)
-}
-
-const encodeRelPath = (relPath: string): string =>
-  relPath.split('/').map(encodeURIComponent).join('/')
-
-/**
- * Headless chat client for agent-runtime.
- *
- * Wires up:
- * - Conversation lifecycle (`start`, `send`, `abort`, `reset`).
- * - SSE stream consumption with incremental message updates.
- * - Generic auth/env state (whatever the active app declares).
- * - Workspace file listing + a download URL builder.
- *
- * The composable is **headless** — it produces reactive state shaped for
- * AI-SDK / Nuxt UI chat components but never imports a single UI package
- * itself. Render whatever you want on top.
- *
- * @example
- * ```vue
- * <script setup lang="ts">
- * const chat = useAgentRuntime()
- * </script>
- *
- * <template>
- *   <UChatMessages :messages="chat.messages.value" :status="chat.status.value" />
- *   <UChatPrompt v-model="input" @submit="chat.send(input)" />
- * </template>
- * ```
- */
-export const useAgentRuntime = (): UseAgentRuntime => {
-  const cfg = useRuntimeConfig().public.agentRuntime as { apiPrefix: string, appId: string } | undefined
-  const apiPrefix = (cfg?.apiPrefix ?? '/api/agent-runtime').replace(/\/+$/, '')
-
-  const conversationId = ref<string | null>(null)
-  // Internally we use the simpler AgentRuntimeMessage shape for ergonomic mutation;
-  // we cast to AI SDK's UIMessage when exposing the ref so downstream Nuxt
-  // UI components are happy.
-  const messages = shallowRef<AgentRuntimeMessage[]>([])
-  const status = ref<ChatStatus>('idle')
-  const error = ref<Error | null>(null)
-  const uiActions = ref<UiAction[]>([])
-
-  // IMPORTANT: must start with the same value the server renders so SSR and
-  // client-hydration markup match. We then read localStorage in `onMounted`
-  // (which never runs during SSR) and update reactively. Reading localStorage
-  // synchronously in setup would render with auth populated on the client
-  // while the SSR markup had it empty, producing a hydration mismatch.
-  const app = ref<AppInfo | null>(null)
-  const auth = ref<AppAuth>(emptyAuth())
-  const authReady = computed(() => computeAuthReady(auth.value, app.value))
-
-  onMounted(async () => {
-    try {
-      const info = await $fetch<AppInfo>(`${apiPrefix}/app`)
-      app.value = info
-      auth.value = loadAuth(info.appId)
-    } catch (err) {
-      console.warn('[agent-runtime] failed to load app manifest', err)
-    }
-  })
-
-  const files = ref<FileEntry[]>([])
-
-  const fileUrl = (relPath: string): string => {
-    const cid = conversationId.value
-    if (!cid) return ''
-    return `${apiPrefix}/conversations/${cid}/files/raw/${encodeRelPath(relPath)}`
-  }
-
-  const refreshFiles = async (): Promise<void> => {
-    const cid = conversationId.value
-    if (!cid) {
-      files.value = []
-      return
-    }
-    try {
-      const res = await $fetch<{ items: FileEntry[] }>(`${apiPrefix}/conversations/${cid}/files`)
-      files.value = res.items
-    } catch (err) {
-      console.warn('[agent-runtime] file list failed', err)
-    }
-  }
-
-  let abortController: AbortController | null = null
-  let currentAssistantId: string | null = null
-
-  const replaceMessages = (next: AgentRuntimeMessage[]): void => {
-    messages.value = next
-  }
-
-  const updateAssistant = (mutate: (msg: AgentRuntimeMessage) => AgentRuntimeMessage): void => {
-    if (!currentAssistantId) return
-    const id = currentAssistantId
-    replaceMessages(messages.value.map(m => (m.id === id ? mutate(m) : m)))
-  }
-
-  const ensureAssistant = (): void => {
-    if (currentAssistantId) return
-    currentAssistantId = newId()
-    replaceMessages([
-      ...messages.value,
-      { id: currentAssistantId, role: 'assistant', parts: [] }
-    ])
-  }
-
-  const appendDelta = (kind: 'text' | 'reasoning', delta: string): void => {
-    ensureAssistant()
-    updateAssistant((msg) => {
-      const parts = msg.parts.slice()
-      const last = parts[parts.length - 1] as TextPart | ReasoningPart | undefined
-      if (last && last.type === kind) {
-        parts[parts.length - 1] = { ...last, text: (last.text ?? '') + delta }
-      } else {
-        parts.push({ type: kind, text: delta } as TextPart | ReasoningPart)
-      }
-      return { ...msg, parts }
-    })
-  }
-
-  const upsertToolPart = (toolName: string, toolCallId: string, mut: (existing: ToolPart | undefined) => ToolPart): void => {
-    ensureAssistant()
-    updateAssistant((msg) => {
-      const parts = msg.parts.slice()
-      const idx = parts.findIndex(p => p.type === `tool-${toolName}` && (p as ToolPart).toolCallId === toolCallId)
-      const next = mut(idx >= 0 ? (parts[idx] as ToolPart) : undefined)
-      if (idx >= 0) parts[idx] = next
-      else parts.push(next)
-      return { ...msg, parts }
-    })
-  }
-
-  const onSseEvent = (eventName: string, data: unknown): void => {
-    switch (eventName) {
-      case 'agent_start':
-        status.value = 'streaming'
-        break
-      case 'delta': {
-        const d = data as { kind: 'text' | 'thinking', delta: string }
-        appendDelta(d.kind === 'thinking' ? 'reasoning' : 'text', d.delta ?? '')
-        break
-      }
-      case 'tool_start': {
-        const d = data as { toolCallId: string, toolName: string, args: unknown }
-        upsertToolPart(d.toolName, d.toolCallId, () => ({
-          type: `tool-${d.toolName}`,
-          toolCallId: d.toolCallId,
-          state: 'input-available',
-          input: d.args
-        }))
-        break
-      }
-      case 'tool_end': {
-        const d = data as { toolCallId: string, toolName: string, isError: boolean }
-        upsertToolPart(d.toolName, d.toolCallId, prev => ({
-          ...(prev ?? { type: `tool-${d.toolName}`, toolCallId: d.toolCallId, input: undefined, state: 'input-available' }),
-          type: `tool-${d.toolName}`,
-          toolCallId: d.toolCallId,
-          state: d.isError ? 'output-error' : 'output-available',
-          output: d.isError ? undefined : 'ok',
-          errorText: d.isError ? 'Tool returned an error' : undefined
-        }))
-        break
-      }
-      case 'ui_action': {
-        const d = data as { toolCallId: string, type: string, payload: unknown }
-        uiActions.value = [{ toolCallId: d.toolCallId, type: d.type, payload: d.payload, at: Date.now() }, ...uiActions.value].slice(0, 50)
-        break
-      }
-      case 'end':
-        status.value = 'ready'
-        currentAssistantId = null
-        void refreshFiles()
-        break
-      case 'error': {
-        const d = data as { message?: string }
-        error.value = new Error(d?.message ?? 'stream error')
-        status.value = 'error'
-        currentAssistantId = null
-        break
-      }
-      default:
-        break
-    }
-  }
-
-  const consume = async (signal: AbortSignal): Promise<void> => {
-    const res = await fetch(`${apiPrefix}/conversations/${conversationId.value}/stream`, { signal })
-    if (!res.ok || !res.body) throw new Error(`stream failed: ${res.status}`)
-    const reader = res.body.getReader()
-    const decoder = new TextDecoder()
-    let buffer = ''
-    while (true) {
-      const { value, done } = await reader.read()
-      if (done) break
-      buffer += decoder.decode(value, { stream: true })
-      let idx
-      while ((idx = buffer.indexOf('\n\n')) >= 0) {
-        const frame = buffer.slice(0, idx)
-        buffer = buffer.slice(idx + 2)
-        if (!frame.trim()) continue
-        let event = 'message'
-        const dataLines: string[] = []
-        for (const raw of frame.split('\n')) {
-          if (raw.startsWith(':')) continue
-          if (raw.startsWith('event:')) event = raw.slice(6).trim()
-          else if (raw.startsWith('data:')) dataLines.push(raw.slice(5).trim())
-        }
-        if (dataLines.length === 0) continue
-        const dataStr = dataLines.join('\n')
-        let data: unknown = dataStr
-        try {
-          data = JSON.parse(dataStr)
-        } catch {}
-        onSseEvent(event, data)
-      }
-    }
-  }
-
-  const start = async (options: StartOptions = {}): Promise<string> => {
-    if (!authReady.value) {
-      const missing = app.value
-        ? Object.entries(app.value.envSchema)
-          .filter(([k, f]) => f.required && !(auth.value.values[k] ?? '').trim())
-          .map(([k]) => k)
-        : []
-      throw new Error(
-        missing.length > 0
-          ? `Fill in required env vars before starting a chat: ${missing.join(', ')}`
-          : 'App manifest not loaded yet. Try again in a moment.'
-      )
-    }
-    error.value = null
-    const res = await $fetch<{ conversationId: string }>(`${apiPrefix}/conversations`, {
-      method: 'POST',
-      body: { env: buildEnvFromAuth(auth.value), language: options.language }
-    })
-    conversationId.value = res.conversationId
-    abortController?.abort()
-    abortController = new AbortController()
-    const signal = abortController.signal
-    consume(signal).catch((err) => {
-      if (signal.aborted) return
-      error.value = err instanceof Error ? err : new Error(String(err))
-      status.value = 'error'
-    })
-    void refreshFiles()
-    return res.conversationId
-  }
-
-  const saveAuth = async (next: AppAuth): Promise<void> => {
-    auth.value = { values: { ...next.values } }
-    if (app.value) persistAuth(app.value.appId, auth.value)
-    if (conversationId.value) {
-      await $fetch(`${apiPrefix}/conversations/${conversationId.value}/env`, {
-        method: 'POST',
-        body: { env: buildEnvFromAuth(auth.value), merge: true }
-      }).catch((err) => {
-        error.value = err instanceof Error ? err : new Error(String(err))
-      })
-    }
-  }
-
-  const send = async (text: string, options: SendOptions = {}): Promise<void> => {
-    if (!text.trim()) return
-    if (!conversationId.value) {
-      try {
-        await start({ language: options.language })
-      } catch (err) {
-        error.value = err instanceof Error ? err : new Error(String(err))
-        status.value = 'error'
-        return
-      }
-    }
-    error.value = null
-    status.value = 'submitted'
-    currentAssistantId = null
-    replaceMessages([
-      ...messages.value,
-      { id: newId(), role: 'user', parts: [{ type: 'text', text }] }
-    ])
-    const wireContent = options.rewriteContent ? options.rewriteContent(text) : text
-    await $fetch(`${apiPrefix}/conversations/${conversationId.value}/messages`, {
-      method: 'POST',
-      body: { content: wireContent, context: options.context, language: options.language }
-    }).catch((err) => {
-      error.value = err instanceof Error ? err : new Error(String(err))
-      status.value = 'error'
-    })
-  }
-
-  const abort = async (): Promise<void> => {
-    if (!conversationId.value) return
-    await $fetch(`${apiPrefix}/conversations/${conversationId.value}/abort`, { method: 'POST' }).catch(() => {})
-    status.value = 'ready'
-  }
-
-  const reset = async (): Promise<void> => {
-    abortController?.abort()
-    abortController = null
-    conversationId.value = null
-    currentAssistantId = null
-    replaceMessages([])
-    uiActions.value = []
-    files.value = []
-    status.value = 'idle'
-    error.value = null
-  }
-
-  return {
-    conversationId,
-    // Cast at the boundary: AgentRuntimeMessage is a structurally-compatible subset of
-    // the AI SDK's UIMessage, but the latter's tagged union is too narrow for
-    // TypeScript to accept the cast implicitly.
-    messages: messages as unknown as Ref<UIMessage[]>,
-    status,
-    error,
-    uiActions,
-    app,
-    auth,
-    authReady,
-    files,
-    fileUrl,
-    refreshFiles,
-    saveAuth,
-    start,
-    send,
-    abort,
-    reset
-  }
-}

package/src/runtime/composables/useAgentRuntimeMarkdown.ts

@@ -1,145 +0,0 @@
-import MarkdownIt from 'markdown-it'
-import {
-  isAgentRuntimeImagePath,
-  resolveAgentRuntimeWorkspaceUri,
-  toAgentRuntimeWorkspaceRelativePath,
-} from '../utils/files'
-
-export interface AgentRuntimeMarkdownRenderOptions {
-  /**
-   * Resolve a workspace-relative path (e.g. `outputs/foo.pdf`) to a fetchable
-   * URL on the runtime backend. Returns null/empty if the path can't be
-   * resolved, in which case the renderer falls back to the original text.
-   */
-  resolveWorkspacePath?: (relPath: string) => string | null | undefined
-}
-
-const BARE_WORKSPACE_PATH_RE = /(sandbox:[^\s)\]"'<>]+|\/workspace\/[^\s)\]"'<>]+)/g
-
-export const createAgentRuntimeMarkdownRenderer = (options: AgentRuntimeMarkdownRenderOptions = {}): MarkdownIt => {
-  const md = new MarkdownIt({
-    html: false,
-    linkify: true,
-    breaks: true,
-    typographer: false,
-  })
-
-  const resolve = (uri: string): string | null =>
-    resolveAgentRuntimeWorkspaceUri(uri, options.resolveWorkspacePath)
-
-  const defaultLinkOpen: NonNullable<typeof md.renderer.rules.link_open> = md.renderer.rules.link_open
-    ?? ((tokens, idx, opts, _env, self) => self.renderToken(tokens, idx, opts))
-
-  md.renderer.rules.link_open = (tokens, idx, opts, env, self) => {
-    const token = tokens[idx]
-    if (token) {
-      const href = token.attrGet('href') ?? ''
-      const rewritten = resolve(href)
-      if (rewritten) {
-        token.attrSet('href', rewritten)
-        token.attrSet('target', '_blank')
-        token.attrSet('rel', 'noopener noreferrer')
-        token.attrSet('class', 'agent-runtime-md-file-link')
-      } else if (/^https?:\/\//i.test(href)) {
-        token.attrSet('target', '_blank')
-        token.attrSet('rel', 'noopener noreferrer')
-      }
-    }
-
-    return defaultLinkOpen(tokens, idx, opts, env, self)
-  }
-
-  md.renderer.rules.image = (tokens, idx) => {
-    const token = tokens[idx]
-    if (!token) return ''
-
-    const rawSrc = token.attrGet('src') ?? ''
-    const rewritten = resolve(rawSrc)
-    const src = rewritten ?? rawSrc
-    const alt = token.content || ''
-    const title = token.attrGet('title')
-    const titleAttr = title ? ` title="${md.utils.escapeHtml(title)}"` : ''
-    const safeAlt = md.utils.escapeHtml(alt)
-    const safeSrc = md.utils.escapeHtml(src)
-    const looksLikeImage = isAgentRuntimeImagePath(rawSrc) || isAgentRuntimeImagePath(src)
-
-    if (!looksLikeImage && rewritten) {
-      return `<a href="${safeSrc}" target="_blank" rel="noopener noreferrer" class="agent-runtime-md-file-link">${safeAlt || safeSrc}</a>`
-    }
-
-    return `<a href="${safeSrc}" target="_blank" rel="noopener noreferrer" class="agent-runtime-md-image-link"><img src="${safeSrc}" alt="${safeAlt}" loading="lazy" class="agent-runtime-md-image"${titleAttr} /></a>`
-  }
-
-  md.core.ruler.after('inline', 'agent_runtime_workspace_autolink', (state) => {
-    for (const blockToken of state.tokens) {
-      if (blockToken.type !== 'inline' || !blockToken.children) continue
-
-      const out: typeof blockToken.children = []
-      for (const child of blockToken.children) {
-        if (child.type !== 'text') {
-          out.push(child)
-          continue
-        }
-
-        const text = child.content
-        BARE_WORKSPACE_PATH_RE.lastIndex = 0
-        if (!BARE_WORKSPACE_PATH_RE.test(text)) {
-          out.push(child)
-          continue
-        }
-
-        BARE_WORKSPACE_PATH_RE.lastIndex = 0
-        let lastIndex = 0
-        let match: RegExpExecArray | null
-
-        while ((match = BARE_WORKSPACE_PATH_RE.exec(text)) !== null) {
-          const uri = match[0]
-          const url = resolve(uri)
-          if (!url) continue
-
-          if (match.index > lastIndex) {
-            const before = new state.Token('text', '', 0)
-            before.content = text.slice(lastIndex, match.index)
-            out.push(before)
-          }
-
-          const open = new state.Token('link_open', 'a', 1)
-          open.attrSet('href', url)
-          open.attrSet('target', '_blank')
-          open.attrSet('rel', 'noopener noreferrer')
-          open.attrSet('class', 'agent-runtime-md-file-link')
-
-          const inner = new state.Token('text', '', 0)
-          const relPath = toAgentRuntimeWorkspaceRelativePath(uri) ?? uri
-          inner.content = relPath.split('/').pop() || relPath
-
-          const close = new state.Token('link_close', 'a', -1)
-          out.push(open, inner, close)
-          lastIndex = match.index + uri.length
-        }
-
-        if (lastIndex < text.length) {
-          const tail = new state.Token('text', '', 0)
-          tail.content = text.slice(lastIndex)
-          out.push(tail)
-        }
-      }
-
-      blockToken.children = out
-    }
-
-    return false
-  })
-
-  return md
-}
-
-export const useAgentRuntimeMarkdown = (options: AgentRuntimeMarkdownRenderOptions = {}) => {
-  const markdown = createAgentRuntimeMarkdownRenderer(options)
-
-  return {
-    markdown,
-    render: (text: string): string => (text ? markdown.render(text) : ''),
-    renderInline: (text: string): string => (text ? markdown.renderInline(text) : ''),
-  }
-}