@d4y/agent-runtime-nuxt 0.1.0

package/src/runtime/server/api/app.get.ts

@@ -0,0 +1,50 @@
+import { agentRuntime, agentRuntimeHeaders } from '../utils/agent-runtime'
+
+interface AppEnvField {
+  required?: boolean
+  secret?: boolean
+  description?: string
+}
+
+interface AppSummary {
+  appId: string
+  name: string
+  envSchema: Record<string, AppEnvField>
+}
+
+interface AppListResponse {
+  apps: AppSummary[]
+}
+
+/**
+ * GET `${apiPrefix}/app` — returns the manifest of the configured app
+ * (so the client can render its env-schema form generically).
+ */
+export default defineEventHandler(async () => {
+  const cfg = agentRuntime()
+  const response = await fetch(`${cfg.baseUrl}/v1/apps`, {
+    headers: agentRuntimeHeaders(cfg)
+  })
+
+  if (!response.ok) {
+    throw createError({
+      statusCode: response.status,
+      statusMessage: await response.text(),
+    })
+  }
+
+  const res = await response.json() as AppListResponse
+
+  const app = res.apps.find(a => a.appId === cfg.appId)
+  if (!app) {
+    throw createError({
+      statusCode: 502,
+      statusMessage: `agent-runtime has no app with id "${cfg.appId}"`
+    })
+  }
+  return {
+    appId: app.appId,
+    name: app.name,
+    envSchema: app.envSchema ?? {}
+  }
+})

package/src/runtime/server/api/conversations/[id]/abort.post.ts

@@ -0,0 +1,26 @@
+import { agentRuntime, agentRuntimeHeaders } from '../../../utils/agent-runtime'
+
+/**
+ * POST `${apiPrefix}/conversations/:id/abort` — cancels the in-flight
+ * agent run for this conversation. Returns 204 on success.
+ */
+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}/abort`, {
+    method: 'POST',
+    headers: agentRuntimeHeaders(cfg)
+  })
+
+  if (!response.ok) {
+    throw createError({
+      statusCode: response.status,
+      statusMessage: await response.text(),
+    })
+  }
+
+  setResponseStatus(event, 204)
+  return null
+})

package/src/runtime/server/api/conversations/[id]/env.post.ts

@@ -0,0 +1,34 @@
+import { agentRuntime, agentRuntimeHeaders } from '../../../utils/agent-runtime'
+
+/**
+ * POST `${apiPrefix}/conversations/:id/env` — patch the workspace env of an
+ * existing conversation. `merge: true` (the default) merges with the current
+ * env; `merge: false` replaces it entirely.
+ *
+ * Triggers any `bootstrap[]` step on the harness side whose `rerunOn` keys
+ * intersect the changed set, so this is also how you re-import auth.
+ */
+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<{ env?: Record<string, string>, merge?: boolean }>(event).catch(() => ({}))) as { env?: Record<string, string>, merge?: boolean }
+  if (!body.env || typeof body.env !== 'object') {
+    throw createError({ statusCode: 400, statusMessage: 'missing env' })
+  }
+
+  const response = await fetch(`${cfg.baseUrl}/v1/conversations/${id}/env`, {
+    method: 'POST',
+    headers: agentRuntimeHeaders(cfg),
+    body: JSON.stringify({ env: body.env, merge: body.merge ?? true })
+  })
+
+  if (!response.ok) {
+    throw createError({
+      statusCode: response.status,
+      statusMessage: await response.text(),
+    })
+  }
+
+  return await response.json()
+})

package/src/runtime/server/api/conversations/[id]/files/raw/[...path].get.ts

@@ -0,0 +1,48 @@
+import { Readable } from 'node:stream'
+import { agentRuntime } from '../../../../../utils/agent-runtime'
+
+const PASS_THROUGH_HEADERS = ['content-type', 'content-length', 'content-disposition', 'cache-control']
+
+/**
+ * GET `${apiPrefix}/conversations/:id/files/raw/<path>` — streams a single
+ * workspace file straight back to the browser.
+ *
+ * We intentionally read the path tail off the *raw* request URL rather than
+ * `getRouterParam` so the bytes (already URL-encoded by the browser) are
+ * forwarded verbatim — re-encoding after Nitro's decoding step is fragile
+ * for filenames containing spaces or unicode.
+ */
+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 as never))
+})

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

@@ -0,0 +1,33 @@
+import { agentRuntime } from '../../../utils/agent-runtime'
+
+/** 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.
+ */
+export default defineEventHandler(async (event): Promise<{ items: FileEntry[] }> => {
+  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() as { items: FileEntry[] }
+})

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

@@ -0,0 +1,20 @@
+import { agentRuntime } from '../../../utils/agent-runtime'
+
+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/src/runtime/server/api/conversations/[id]/messages.post.ts

@@ -0,0 +1,29 @@
+import { agentRuntime, agentRuntimeHeaders } from '../../../utils/agent-runtime'
+
+/**
+ * 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.
+ */
+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<{ content: string, context?: unknown, language?: string }>(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/src/runtime/server/api/conversations/[id]/stream.get.ts

@@ -0,0 +1,41 @@
+import { Readable } from 'node:stream'
+import { agentRuntime } from '../../../utils/agent-runtime'
+
+/**
+ * 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.
+ */
+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 as never))
+})

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

@@ -0,0 +1,22 @@
+import { agentRuntime } from '../../utils/agent-runtime'
+
+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/src/runtime/server/api/conversations.post.ts

@@ -0,0 +1,26 @@
+import { agentRuntime, agentRuntimeHeaders } from '../utils/agent-runtime'
+
+/**
+ * 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.
+ */
+export default defineEventHandler(async (event) => {
+  const cfg = agentRuntime()
+  const body = (await readBody<{ env?: Record<string, string>, model?: unknown, language?: string }>(event).catch(() => ({}))) as { env?: Record<string, string>, model?: unknown, language?: string }
+
+  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/src/runtime/server/utils/agent-runtime.ts

@@ -0,0 +1,33 @@
+import { createAgentRuntimeRequestHeaders, resolveAgentRuntimeConfig, type AgentRuntimeResolvedConfig } from '../../../shared'
+
+// h3 / Nitro helpers (`useRuntimeConfig`, `createError`, `defineEventHandler`,
+// `getRouterParam`, `setHeader`, `sendStream`, `readBody`, `setResponseStatus`,
+// `$fetch`) are auto-injected into module-provided server handlers by Nitro
+// at build time, so we don't import them here.
+
+/** 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 const agentRuntime = (): AgentRuntimeRuntime => {
+  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.',
+    })
+  }
+}
+
+/** Build the standard JSON request headers, including the app key. */
+export const agentRuntimeHeaders = (cfg: AgentRuntimeRuntime, extra: Record<string, string> = {}): Record<string, string> =>
+  createAgentRuntimeRequestHeaders(cfg, extra)

package/src/runtime/utils/files.ts

@@ -0,0 +1,78 @@
+export interface AgentRuntimeFileLike {
+  name?: string | null
+  relPath?: string | null
+  mimeType?: string | null
+}
+
+export type AgentRuntimeFilePreviewKind = 'image' | 'pdf' | 'text' | 'download'
+
+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: string): string | null => {
+  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: string,
+  resolveWorkspacePath?: (relPath: string) => string | null | undefined,
+): string | null => {
+  const relPath = toAgentRuntimeWorkspaceRelativePath(uri)
+  if (relPath === null) return null
+  const resolved = resolveWorkspacePath?.(relPath)
+  return resolved || null
+}
+
+export const isAgentRuntimeImageMimeType = (mimeType: string | null | undefined): boolean =>
+  typeof mimeType === 'string' && /^image\//i.test(mimeType)
+
+export const isAgentRuntimePdfMimeType = (mimeType: string | null | undefined): boolean =>
+  typeof mimeType === 'string' && mimeType.toLowerCase() === 'application/pdf'
+
+export const isAgentRuntimeTextMimeType = (mimeType: string | null | undefined): boolean => {
+  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: string | null | undefined): boolean =>
+  typeof value === 'string' && IMAGE_EXT_RE.test(value)
+
+export const isAgentRuntimePdfPath = (value: string | null | undefined): boolean =>
+  typeof value === 'string' && PDF_EXT_RE.test(value)
+
+export const isAgentRuntimeTextPath = (value: string | null | undefined): boolean =>
+  typeof value === 'string' && TEXT_EXT_RE.test(value)
+
+export const getAgentRuntimeFilePreviewKind = (file: AgentRuntimeFileLike): AgentRuntimeFilePreviewKind => {
+  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: AgentRuntimeFileLike): boolean =>
+  getAgentRuntimeFilePreviewKind(file) !== 'download'

package/src/shared.ts

@@ -0,0 +1,46 @@
+import { createHash } from 'node:crypto'
+
+export interface AgentRuntimeConfigInput {
+  baseUrl?: string | null
+  appKey?: string | null
+  appId?: string | null
+}
+
+export interface AgentRuntimeResolvedConfig {
+  baseUrl: string
+  appKey: string
+  appId: string
+}
+
+export const normalizeAgentRuntimeBaseUrl = (value: string | null | undefined) =>
+  String(value || '').trim().replace(/\/+$/, '')
+
+export const createScopeFingerprint = (parts: Array<string | null | undefined>) => {
+  const normalized = parts.map((part) => (typeof part === 'string' && part.trim().length > 0 ? part.trim() : 'none')).join('|')
+  return createHash('sha256').update(normalized).digest('hex').slice(0, 12)
+}
+
+export const resolveAgentRuntimeConfig = (
+  config: AgentRuntimeConfigInput | null | undefined,
+  options?: { defaultAppId?: string },
+): AgentRuntimeResolvedConfig => {
+  const appKey = String(config?.appKey || '').trim()
+  if (!appKey) {
+    throw new Error('[agent-runtime] AGENT_RUNTIME_APP_KEY is not configured')
+  }
+
+  return {
+    baseUrl: normalizeAgentRuntimeBaseUrl(config?.baseUrl),
+    appKey,
+    appId: String(config?.appId || options?.defaultAppId || 'omnisearch'),
+  }
+}
+
+export const createAgentRuntimeRequestHeaders = (
+  config: Pick<AgentRuntimeResolvedConfig, 'appKey'>,
+  extra: Record<string, string> = {},
+): Record<string, string> => ({
+  'X-Agent-Runtime-App-Key': config.appKey,
+  'content-type': 'application/json',
+  ...extra,
+})

package/src/vue-shim.d.ts

@@ -0,0 +1,6 @@
+declare module '*.vue' {
+  import type { DefineComponent } from 'vue'
+
+  const component: DefineComponent<Record<string, never>, Record<string, never>, unknown>
+  export default component
+}