@d4y/agent-runtime-nuxt 0.1.0

package/dist/runtime/server/api/conversations/[id]/files/raw/[...path].get.js

@@ -0,0 +1,31 @@
+import { Readable } from "node:stream";
+import { agentRuntime } from "../../../../../utils/agent-runtime.js";
+const PASS_THROUGH_HEADERS = ["content-type", "content-length", "content-disposition", "cache-control"];
+export default defineEventHandler(async (event) => {
+  const cfg = agentRuntime();
+  const id = getRouterParam(event, "id");
+  if (!id) throw createError({ statusCode: 400, statusMessage: "missing conversation id" });
+  const apiPrefix = (useRuntimeConfig().public.agentRuntime?.apiPrefix ?? "/api/agent-runtime").replace(/\/+$/, "");
+  const marker = `${apiPrefix}/conversations/${id}/files/raw/`;
+  const idx = event.path.indexOf(marker);
+  const tail = idx >= 0 ? event.path.slice(idx + marker.length) : "";
+  if (!tail) throw createError({ statusCode: 400, statusMessage: "missing file path" });
+  const upstreamUrl = `${cfg.baseUrl}/v1/conversations/${id}/files/raw/${tail}`;
+  const controller = new AbortController();
+  event.node.req.on("close", () => controller.abort());
+  const upstream = await fetch(upstreamUrl, {
+    headers: { "X-Agent-Runtime-App-Key": cfg.appKey },
+    signal: controller.signal
+  });
+  if (!upstream.ok || !upstream.body) {
+    throw createError({
+      statusCode: upstream.status || 502,
+      statusMessage: `agent-runtime file fetch failed: ${upstream.status} ${upstream.statusText}`
+    });
+  }
+  for (const name of PASS_THROUGH_HEADERS) {
+    const v = upstream.headers.get(name);
+    if (v) setHeader(event, name, v);
+  }
+  return sendStream(event, Readable.fromWeb(upstream.body));
+});

package/dist/runtime/server/api/conversations/[id]/files.get.d.ts

@@ -0,0 +1,14 @@
+/** Single file entry as returned by agent-runtime. */
+export interface FileEntry {
+    name: string;
+    relPath: string;
+    size: number;
+    mtime: string;
+    mimeType: string;
+}
+/**
+ * GET `${apiPrefix}/conversations/:id/files` — lists the workspace files
+ * the agent has produced (or read in) so the UI can show a side panel.
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/conversations/[id]/files.get.js

@@ -0,0 +1,16 @@
+import { agentRuntime } from "../../../utils/agent-runtime.js";
+export default defineEventHandler(async (event) => {
+  const cfg = agentRuntime();
+  const id = getRouterParam(event, "id");
+  if (!id) throw createError({ statusCode: 400, statusMessage: "missing conversation id" });
+  const response = await fetch(`${cfg.baseUrl}/v1/conversations/${id}/files`, {
+    headers: { "X-Agent-Runtime-App-Key": cfg.appKey }
+  });
+  if (!response.ok) {
+    throw createError({
+      statusCode: response.status,
+      statusMessage: await response.text()
+    });
+  }
+  return await response.json();
+});

package/dist/runtime/server/api/conversations/[id]/history.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/conversations/[id]/history.get.js

@@ -0,0 +1,16 @@
+import { agentRuntime } from "../../../utils/agent-runtime.js";
+export default defineEventHandler(async (event) => {
+  const cfg = agentRuntime();
+  const id = getRouterParam(event, "id");
+  if (!id) throw createError({ statusCode: 400, statusMessage: "missing conversation id" });
+  const response = await fetch(`${cfg.baseUrl}/v1/conversations/${id}/history`, {
+    headers: { "X-Agent-Runtime-App-Key": cfg.appKey }
+  });
+  if (!response.ok) {
+    throw createError({
+      statusCode: response.status,
+      statusMessage: await response.text()
+    });
+  }
+  return await response.json();
+});

package/dist/runtime/server/api/conversations/[id]/messages.post.d.ts

@@ -0,0 +1,7 @@
+/**
+ * POST `${apiPrefix}/conversations/:id/messages` — append a user turn.
+ * The optional `context` field is forwarded verbatim to agent-runtime, where
+ * the agent picks it up as per-turn dynamic context.
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/conversations/[id]/messages.post.js

@@ -0,0 +1,20 @@
+import { agentRuntime, agentRuntimeHeaders } from "../../../utils/agent-runtime.js";
+export default defineEventHandler(async (event) => {
+  const cfg = agentRuntime();
+  const id = getRouterParam(event, "id");
+  if (!id) throw createError({ statusCode: 400, statusMessage: "missing conversation id" });
+  const body = await readBody(event);
+  if (!body?.content) throw createError({ statusCode: 400, statusMessage: "missing content" });
+  const response = await fetch(`${cfg.baseUrl}/v1/conversations/${id}/messages`, {
+    method: "POST",
+    headers: agentRuntimeHeaders(cfg),
+    body: JSON.stringify({ content: body.content, context: body.context, language: body.language })
+  });
+  if (!response.ok) {
+    throw createError({
+      statusCode: response.status,
+      statusMessage: await response.text()
+    });
+  }
+  return await response.json();
+});

package/dist/runtime/server/api/conversations/[id]/stream.get.d.ts

@@ -0,0 +1,9 @@
+/**
+ * GET `${apiPrefix}/conversations/:id/stream` — pipes the upstream
+ * Server-Sent Events stream from agent-runtime straight back to the browser.
+ *
+ * Closing the client connection aborts the upstream fetch so we don't leave
+ * orphaned conversations hanging.
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/conversations/[id]/stream.get.js

@@ -0,0 +1,28 @@
+import { Readable } from "node:stream";
+import { agentRuntime } from "../../../utils/agent-runtime.js";
+export default defineEventHandler(async (event) => {
+  const cfg = agentRuntime();
+  const id = getRouterParam(event, "id");
+  if (!id) throw createError({ statusCode: 400, statusMessage: "missing conversation id" });
+  const controller = new AbortController();
+  event.node.req.on("close", () => controller.abort());
+  const upstream = await fetch(`${cfg.baseUrl}/v1/conversations/${id}/stream`, {
+    method: "GET",
+    headers: {
+      "X-Agent-Runtime-App-Key": cfg.appKey,
+      accept: "text/event-stream"
+    },
+    signal: controller.signal
+  });
+  if (!upstream.ok || !upstream.body) {
+    throw createError({
+      statusCode: upstream.status || 502,
+      statusMessage: `agent-runtime stream failed: ${upstream.status} ${upstream.statusText}`
+    });
+  }
+  setHeader(event, "content-type", "text/event-stream");
+  setHeader(event, "cache-control", "no-cache, no-transform");
+  setHeader(event, "connection", "keep-alive");
+  setHeader(event, "x-accel-buffering", "no");
+  return sendStream(event, Readable.fromWeb(upstream.body));
+});

package/dist/runtime/server/api/conversations/[id].delete.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/conversations/[id].delete.js

@@ -0,0 +1,18 @@
+import { agentRuntime } from "../../utils/agent-runtime.js";
+export default defineEventHandler(async (event) => {
+  const cfg = agentRuntime();
+  const id = getRouterParam(event, "id");
+  if (!id) throw createError({ statusCode: 400, statusMessage: "missing conversation id" });
+  const response = await fetch(`${cfg.baseUrl}/v1/conversations/${id}`, {
+    method: "DELETE",
+    headers: { "X-Agent-Runtime-App-Key": cfg.appKey }
+  });
+  if (!response.ok) {
+    throw createError({
+      statusCode: response.status,
+      statusMessage: await response.text()
+    });
+  }
+  setResponseStatus(event, 204);
+  return null;
+});

package/dist/runtime/server/api/conversations.post.d.ts

@@ -0,0 +1,7 @@
+/**
+ * POST `${apiPrefix}/conversations` — opens a new conversation against the
+ * configured app, optionally seeded with an `env` map (which the harness
+ * uses to populate the workspace environment) and a model override.
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/conversations.post.js

@@ -0,0 +1,17 @@
+import { agentRuntime, agentRuntimeHeaders } from "../utils/agent-runtime.js";
+export default defineEventHandler(async (event) => {
+  const cfg = agentRuntime();
+  const body = await readBody(event).catch(() => ({}));
+  const response = await fetch(`${cfg.baseUrl}/v1/conversations`, {
+    method: "POST",
+    headers: agentRuntimeHeaders(cfg),
+    body: JSON.stringify({ appId: cfg.appId, env: body.env ?? {}, model: body.model, language: body.language })
+  });
+  if (!response.ok) {
+    throw createError({
+      statusCode: response.status,
+      statusMessage: await response.text()
+    });
+  }
+  return await response.json();
+});

package/dist/runtime/server/utils/agent-runtime.d.ts

@@ -0,0 +1,12 @@
+import { type AgentRuntimeResolvedConfig } from '../../../shared.js';
+/** Resolved server-side configuration for talking to agent-runtime. */
+export type AgentRuntimeRuntime = AgentRuntimeResolvedConfig;
+/**
+ * Read the agent-runtime section of `runtimeConfig`, validating that the app key
+ * has been provided. Throws a typed Nitro 500 otherwise so the proxy routes
+ * surface a clear error instead of silently forwarding an unauthenticated
+ * request.
+ */
+export declare const agentRuntime: () => AgentRuntimeRuntime;
+/** Build the standard JSON request headers, including the app key. */
+export declare const agentRuntimeHeaders: (cfg: AgentRuntimeRuntime, extra?: Record<string, string>) => Record<string, string>;

package/dist/runtime/server/utils/agent-runtime.js

@@ -0,0 +1,12 @@
+import { createAgentRuntimeRequestHeaders, resolveAgentRuntimeConfig } from "../../../shared";
+export const agentRuntime = () => {
+  try {
+    return resolveAgentRuntimeConfig(useRuntimeConfig().agentRuntime);
+  } catch (error) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: error instanceof Error ? `${error.message}. Set it via env, runtimeConfig.agentRuntime.appKey, or the module options.` : "[agent-runtime] AGENT_RUNTIME_APP_KEY is not configured. Set it via env, runtimeConfig.agentRuntime.appKey, or the module options."
+    });
+  }
+};
+export const agentRuntimeHeaders = (cfg, extra = {}) => createAgentRuntimeRequestHeaders(cfg, extra);

package/dist/runtime/utils/files.d.ts

@@ -0,0 +1,16 @@
+export interface AgentRuntimeFileLike {
+    name?: string | null;
+    relPath?: string | null;
+    mimeType?: string | null;
+}
+export type AgentRuntimeFilePreviewKind = 'image' | 'pdf' | 'text' | 'download';
+export declare const toAgentRuntimeWorkspaceRelativePath: (uri: string) => string | null;
+export declare const resolveAgentRuntimeWorkspaceUri: (uri: string, resolveWorkspacePath?: (relPath: string) => string | null | undefined) => string | null;
+export declare const isAgentRuntimeImageMimeType: (mimeType: string | null | undefined) => boolean;
+export declare const isAgentRuntimePdfMimeType: (mimeType: string | null | undefined) => boolean;
+export declare const isAgentRuntimeTextMimeType: (mimeType: string | null | undefined) => boolean;
+export declare const isAgentRuntimeImagePath: (value: string | null | undefined) => boolean;
+export declare const isAgentRuntimePdfPath: (value: string | null | undefined) => boolean;
+export declare const isAgentRuntimeTextPath: (value: string | null | undefined) => boolean;
+export declare const getAgentRuntimeFilePreviewKind: (file: AgentRuntimeFileLike) => AgentRuntimeFilePreviewKind;
+export declare const canPreviewAgentRuntimeFileInline: (file: AgentRuntimeFileLike) => boolean;

package/dist/runtime/utils/files.js

@@ -0,0 +1,42 @@
+const IMAGE_EXT_RE = /\.(?:png|jpe?g|gif|webp|svg|avif|bmp)(?:[?#].*)?$/i;
+const PDF_EXT_RE = /\.pdf(?:[?#].*)?$/i;
+const TEXT_EXT_RE = /\.(?:txt|md|json|csv|tsv|xml|ya?ml|log|html?|css|js|mjs|cjs|ts|tsx|jsx|vue|py|rb|sh|sql)(?:[?#].*)?$/i;
+export const toAgentRuntimeWorkspaceRelativePath = (uri) => {
+  if (!uri) return null;
+  if (uri.startsWith("sandbox:")) return uri.slice("sandbox:".length).replace(/^\/+/, "");
+  if (uri.startsWith("/workspace/")) return uri.slice("/workspace/".length);
+  if (uri === "/workspace") return "";
+  if (uri.startsWith("workspace/")) return uri.slice("workspace/".length);
+  return null;
+};
+export const resolveAgentRuntimeWorkspaceUri = (uri, resolveWorkspacePath) => {
+  const relPath = toAgentRuntimeWorkspaceRelativePath(uri);
+  if (relPath === null) return null;
+  const resolved = resolveWorkspacePath?.(relPath);
+  return resolved || null;
+};
+export const isAgentRuntimeImageMimeType = (mimeType) => typeof mimeType === "string" && /^image\//i.test(mimeType);
+export const isAgentRuntimePdfMimeType = (mimeType) => typeof mimeType === "string" && mimeType.toLowerCase() === "application/pdf";
+export const isAgentRuntimeTextMimeType = (mimeType) => {
+  if (typeof mimeType !== "string" || !mimeType) {
+    return false;
+  }
+  const normalized = mimeType.toLowerCase();
+  return normalized.startsWith("text/") || normalized === "application/json" || normalized === "application/ld+json" || normalized === "application/xml" || normalized === "application/yaml" || normalized === "application/x-yaml";
+};
+export const isAgentRuntimeImagePath = (value) => typeof value === "string" && IMAGE_EXT_RE.test(value);
+export const isAgentRuntimePdfPath = (value) => typeof value === "string" && PDF_EXT_RE.test(value);
+export const isAgentRuntimeTextPath = (value) => typeof value === "string" && TEXT_EXT_RE.test(value);
+export const getAgentRuntimeFilePreviewKind = (file) => {
+  if (isAgentRuntimeImageMimeType(file.mimeType) || isAgentRuntimeImagePath(file.name) || isAgentRuntimeImagePath(file.relPath)) {
+    return "image";
+  }
+  if (isAgentRuntimePdfMimeType(file.mimeType) || isAgentRuntimePdfPath(file.name) || isAgentRuntimePdfPath(file.relPath)) {
+    return "pdf";
+  }
+  if (isAgentRuntimeTextMimeType(file.mimeType) || isAgentRuntimeTextPath(file.name) || isAgentRuntimeTextPath(file.relPath)) {
+    return "text";
+  }
+  return "download";
+};
+export const canPreviewAgentRuntimeFileInline = (file) => getAgentRuntimeFilePreviewKind(file) !== "download";

package/dist/types.d.mts

@@ -0,0 +1,9 @@
+export { type AppAuth, type AppEnvField, type AppInfo, type ChatStatus, type FileEntry, type SendOptions, type UIMessage, type UiAction, type UseAgentRuntime } from '../dist/runtime/composables/useAgentRuntime.js'
+
+export { type AgentRuntimeMarkdownRenderOptions } from '../dist/runtime/composables/useAgentRuntimeMarkdown.js'
+
+export { type AgentRuntimeFileLike, type AgentRuntimeFilePreviewKind } from '../dist/runtime/utils/files.js'
+
+export { default } from './module.mjs'
+
+export { type ModuleOptions, type PrivateAgentRuntimeConfig, type PublicAgentRuntimeConfig } from './module.mjs'

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@d4y/agent-runtime-nuxt",
+  "version": "0.1.0",
+  "description": "Headless Nuxt module that connects a Nuxt app to an agent-runtime server. Ships server-side proxy routes (so your X-Agent-Runtime-App-Key never leaves the server) and a single composable, useAgentRuntime(), that exposes a typed chat client.",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/digital4you/agent-runtime.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "main": "./src/module.ts",
+  "types": "./src/module.ts",
+  "exports": {
+    ".": {
+      "types": "./src/module.ts",
+      "import": "./src/module.ts"
+    },
+    "./frontend": {
+      "types": "./src/frontend.ts",
+      "import": "./src/frontend.ts"
+    },
+    "./shared": {
+      "types": "./src/shared.ts",
+      "import": "./src/shared.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "keywords": [
+    "nuxt",
+    "nuxt-module",
+    "agent-runtime",
+    "chat",
+    "ai",
+    "agent"
+  ],
+  "scripts": {
+    "prepack": "nuxt-module-build build",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@nuxt/kit": "^4.4.2",
+    "ai": "^6.0.168",
+    "defu": "^6.1.4",
+    "markdown-it": "^14.1.1"
+  },
+  "devDependencies": {
+    "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/schema": "^4.4.2",
+    "@types/markdown-it": "^14.1.2",
+    "h3": "^1.15.11",
+    "nuxt": "^4.4.2",
+    "typescript": "^6.0.2",
+    "vue": "^3.5.32",
+    "vue-tsc": "^3.2.7"
+  },
+  "peerDependencies": {
+    "nuxt": "^3.13.0 || ^4.0.0"
+  }
+}

package/src/frontend.ts

@@ -0,0 +1,16 @@
+export type { AgentRuntimeMarkdownRenderOptions } from './runtime/composables/useAgentRuntimeMarkdown'
+export type { AgentRuntimeFileLike, AgentRuntimeFilePreviewKind } from './runtime/utils/files'
+export { default as AgentRuntimeArtifactPreview } from './runtime/components/AgentRuntimeArtifactPreview.vue'
+export { createAgentRuntimeMarkdownRenderer, useAgentRuntimeMarkdown } from './runtime/composables/useAgentRuntimeMarkdown'
+export {
+  canPreviewAgentRuntimeFileInline,
+  getAgentRuntimeFilePreviewKind,
+  isAgentRuntimeImageMimeType,
+  isAgentRuntimeImagePath,
+  isAgentRuntimePdfMimeType,
+  isAgentRuntimePdfPath,
+  isAgentRuntimeTextMimeType,
+  isAgentRuntimeTextPath,
+  resolveAgentRuntimeWorkspaceUri,
+  toAgentRuntimeWorkspaceRelativePath,
+} from './runtime/utils/files'

package/src/module.ts

@@ -0,0 +1,155 @@
+import { defineNuxtModule, createResolver, addImportsDir, addServerHandler, addTypeTemplate } from '@nuxt/kit'
+import { defu } from 'defu'
+
+// Re-export the public composable surface so consumers can `import type
+// { UIMessage, AppInfo, … } from '@d4y/agent-runtime-nuxt'` without reaching into
+// `runtime/`. The composable itself is auto-imported via addImportsDir.
+export type {
+  UseAgentRuntime,
+  UIMessage,
+  AppInfo,
+  AppAuth,
+  AppEnvField,
+  FileEntry,
+  UiAction,
+  SendOptions,
+  ChatStatus
+} from './runtime/composables/useAgentRuntime'
+export type { AgentRuntimeMarkdownRenderOptions } from './runtime/composables/useAgentRuntimeMarkdown'
+export type { AgentRuntimeFileLike, AgentRuntimeFilePreviewKind } from './runtime/utils/files'
+
+/**
+ * Module options for `@d4y/agent-runtime-nuxt`.
+ *
+ * Every field is optional at config time — unset values fall back to the
+ * matching `AGENT_RUNTIME_*` environment variable at runtime, so the same build
+ * artifact works across environments without rebuilding.
+ */
+export interface ModuleOptions {
+  /**
+   * Base URL of the agent-runtime HTTP server (no trailing slash required).
+   *
+   * Falls back to `process.env.AGENT_RUNTIME_URL` then `http://127.0.0.1:18791`.
+   */
+  baseUrl?: string
+
+  /**
+   * App key used to authenticate against agent-runtime (`X-Agent-Runtime-App-Key` header).
+   *
+   * **Server-only secret.** Never exposed to the browser; the module only
+   * forwards it from the proxy routes it registers.
+   *
+   * Falls back to `process.env.AGENT_RUNTIME_APP_KEY`. Required at runtime — the
+   * module will throw a 500 from any proxy route if missing.
+   */
+  appKey?: string
+
+  /**
+   * App ID to bind every conversation to (must match an app registered in
+   * the agent-runtime `apps/` directory).
+   *
+   * Falls back to `process.env.AGENT_RUNTIME_APP_ID` then `omnisearch`.
+   */
+  appId?: string
+
+  /**
+   * URL prefix for the auto-registered Nitro proxy routes. Change it if you
+   * need to disambiguate from another module on the same `/api/...` namespace.
+   *
+   * Default: `/api/agent-runtime`.
+   */
+  apiPrefix?: string
+}
+
+/** Public runtime-config shape exposed to the browser (path data only). */
+export interface PublicAgentRuntimeConfig {
+  /** Same value as `apiPrefix` from module options; needed by `useAgentRuntime` to build URLs. */
+  apiPrefix: string
+  /** App ID, used by the composable to scope `localStorage` keys. */
+  appId: string
+}
+
+/** Private runtime-config shape (server-only). */
+export interface PrivateAgentRuntimeConfig {
+  baseUrl: string
+  appKey: string
+  appId: string
+}
+
+declare module '@nuxt/schema' {
+  interface RuntimeConfig {
+    agentRuntime: PrivateAgentRuntimeConfig
+  }
+  interface PublicRuntimeConfig {
+    agentRuntime: PublicAgentRuntimeConfig
+  }
+}
+
+const DEFAULTS: Required<Pick<ModuleOptions, 'baseUrl' | 'appId' | 'apiPrefix'>> = {
+  baseUrl: 'http://127.0.0.1:18791',
+  appId: 'omnisearch',
+  apiPrefix: '/api/agent-runtime'
+}
+
+export default defineNuxtModule<ModuleOptions>({
+  meta: {
+    name: '@d4y/agent-runtime-nuxt',
+    configKey: 'agentRuntime',
+    compatibility: { nuxt: '>=3.13.0' }
+  },
+  defaults: {},
+  setup(userOptions, nuxt) {
+    const resolver = createResolver(import.meta.url)
+
+    const baseUrl = (userOptions.baseUrl ?? process.env.AGENT_RUNTIME_URL ?? DEFAULTS.baseUrl).replace(/\/+$/, '')
+    const appKey = userOptions.appKey ?? process.env.AGENT_RUNTIME_APP_KEY ?? ''
+    const appId = userOptions.appId ?? process.env.AGENT_RUNTIME_APP_ID ?? DEFAULTS.appId
+    const apiPrefix = (userOptions.apiPrefix ?? DEFAULTS.apiPrefix).replace(/\/+$/, '')
+
+    nuxt.options.runtimeConfig.agentRuntime = defu(nuxt.options.runtimeConfig.agentRuntime, {
+      baseUrl,
+      appKey,
+      appId
+    })
+
+    nuxt.options.runtimeConfig.public.agentRuntime = defu(nuxt.options.runtimeConfig.public.agentRuntime, {
+      apiPrefix,
+      appId
+    })
+
+    // Composable auto-import — `useAgentRuntime()` is available everywhere.
+    addImportsDir(resolver.resolve('./runtime/composables'))
+
+    // Generate a `.d.ts` shim that re-exports the public types from the
+    // module so IDEs see them without the consumer touching tsconfig paths.
+    addTypeTemplate({
+      filename: 'types/agent-runtime.d.ts',
+      getContents: () => [
+        `// Auto-generated by @d4y/agent-runtime-nuxt`,
+        `export type { UseAgentRuntime, AppInfo, AppAuth, AppEnvField, FileEntry, UiAction, SendOptions, ChatStatus } from '${resolver.resolve('./runtime/composables/useAgentRuntime')}'`,
+        `export type { AgentRuntimeMarkdownRenderOptions } from '${resolver.resolve('./runtime/composables/useAgentRuntimeMarkdown')}'`,
+        `export type { AgentRuntimeFileLike, AgentRuntimeFilePreviewKind } from '${resolver.resolve('./runtime/utils/files')}'`,
+        ''
+      ].join('\n')
+    })
+
+    // Register every proxy route under the configured prefix.
+    const route = (suffix: string, handler: string, method?: 'get' | 'post' | 'delete') =>
+      addServerHandler({
+        route: `${apiPrefix}${suffix}`,
+        method,
+        handler: resolver.resolve(`./runtime/server/api/${handler}`)
+      })
+
+    route('/app', 'app.get', 'get')
+    route('/conversations', 'conversations.post', 'post')
+    route('/conversations/:id', 'conversations/[id].delete', 'delete')
+    route('/conversations/:id/history', 'conversations/[id]/history.get', 'get')
+    route('/conversations/:id/stream', 'conversations/[id]/stream.get', 'get')
+    route('/conversations/:id/messages', 'conversations/[id]/messages.post', 'post')
+    route('/conversations/:id/abort', 'conversations/[id]/abort.post', 'post')
+    route('/conversations/:id/env', 'conversations/[id]/env.post', 'post')
+    route('/conversations/:id/files', 'conversations/[id]/files.get', 'get')
+    route('/conversations/:id/files/raw/**', 'conversations/[id]/files/raw/[...path].get', 'get')
+  }
+})

package/src/nitro-globals.d.ts

@@ -0,0 +1,8 @@
+declare const defineEventHandler: typeof import('h3').defineEventHandler
+declare const createError: typeof import('h3').createError
+declare const getRouterParam: typeof import('h3').getRouterParam
+declare const setHeader: typeof import('h3').setHeader
+declare const sendStream: typeof import('h3').sendStream
+declare const readBody: typeof import('h3').readBody
+declare const setResponseStatus: typeof import('h3').setResponseStatus
+declare const useRuntimeConfig: () => any