@d4y/agent-runtime-nuxt 0.1.0

package/src/runtime/composables/useAgentRuntime.ts

@@ -0,0 +1,527 @@
+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

@@ -0,0 +1,145 @@
+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) : ''),
+  }
+}