@d4y/agent-runtime-nuxt 0.1.0

package/dist/runtime/composables/useAgentRuntime.d.ts

@@ -0,0 +1,130 @@
+import { type Ref, type ComputedRef } from 'vue';
+import type { UIMessage as AiUIMessage } from 'ai';
+/**
+ * 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';
+/** 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>;
+}
+/** 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;
+}
+/** 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>;
+}
+/**
+ * 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 declare const useAgentRuntime: () => UseAgentRuntime;

package/dist/runtime/composables/useAgentRuntime.js

@@ -0,0 +1,306 @@
+import { computed, onMounted, ref, shallowRef } from "vue";
+import { useRuntimeConfig } from "nuxt/app";
+const newId = () => typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `id-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+const authStorageKey = (appId) => `agent-runtime.app-auth.${appId}`;
+const emptyAuth = () => ({ values: {} });
+const loadAuth = (appId) => {
+  if (typeof window === "undefined") return emptyAuth();
+  try {
+    const raw = window.localStorage.getItem(authStorageKey(appId));
+    if (!raw) return emptyAuth();
+    const parsed = JSON.parse(raw);
+    return { values: { ...parsed.values ?? {} } };
+  } catch {
+    return emptyAuth();
+  }
+};
+const persistAuth = (appId, auth) => {
+  if (typeof window === "undefined") return;
+  try {
+    window.localStorage.setItem(authStorageKey(appId), JSON.stringify(auth));
+  } catch {
+  }
+};
+const buildEnvFromAuth = (auth) => {
+  const out = {};
+  for (const [k, v] of Object.entries(auth.values)) {
+    const trimmed = (v ?? "").trim();
+    if (trimmed) out[k] = trimmed;
+  }
+  return out;
+};
+const computeAuthReady = (auth, app) => {
+  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) => relPath.split("/").map(encodeURIComponent).join("/");
+export const useAgentRuntime = () => {
+  const cfg = useRuntimeConfig().public.agentRuntime;
+  const apiPrefix = (cfg?.apiPrefix ?? "/api/agent-runtime").replace(/\/+$/, "");
+  const conversationId = ref(null);
+  const messages = shallowRef([]);
+  const status = ref("idle");
+  const error = ref(null);
+  const uiActions = ref([]);
+  const app = ref(null);
+  const auth = ref(emptyAuth());
+  const authReady = computed(() => computeAuthReady(auth.value, app.value));
+  onMounted(async () => {
+    try {
+      const info = await $fetch(`${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([]);
+  const fileUrl = (relPath) => {
+    const cid = conversationId.value;
+    if (!cid) return "";
+    return `${apiPrefix}/conversations/${cid}/files/raw/${encodeRelPath(relPath)}`;
+  };
+  const refreshFiles = async () => {
+    const cid = conversationId.value;
+    if (!cid) {
+      files.value = [];
+      return;
+    }
+    try {
+      const res = await $fetch(`${apiPrefix}/conversations/${cid}/files`);
+      files.value = res.items;
+    } catch (err) {
+      console.warn("[agent-runtime] file list failed", err);
+    }
+  };
+  let abortController = null;
+  let currentAssistantId = null;
+  const replaceMessages = (next) => {
+    messages.value = next;
+  };
+  const updateAssistant = (mutate) => {
+    if (!currentAssistantId) return;
+    const id = currentAssistantId;
+    replaceMessages(messages.value.map((m) => m.id === id ? mutate(m) : m));
+  };
+  const ensureAssistant = () => {
+    if (currentAssistantId) return;
+    currentAssistantId = newId();
+    replaceMessages([
+      ...messages.value,
+      { id: currentAssistantId, role: "assistant", parts: [] }
+    ]);
+  };
+  const appendDelta = (kind, delta) => {
+    ensureAssistant();
+    updateAssistant((msg) => {
+      const parts = msg.parts.slice();
+      const last = parts[parts.length - 1];
+      if (last && last.type === kind) {
+        parts[parts.length - 1] = { ...last, text: (last.text ?? "") + delta };
+      } else {
+        parts.push({ type: kind, text: delta });
+      }
+      return { ...msg, parts };
+    });
+  };
+  const upsertToolPart = (toolName, toolCallId, mut) => {
+    ensureAssistant();
+    updateAssistant((msg) => {
+      const parts = msg.parts.slice();
+      const idx = parts.findIndex((p) => p.type === `tool-${toolName}` && p.toolCallId === toolCallId);
+      const next = mut(idx >= 0 ? parts[idx] : void 0);
+      if (idx >= 0) parts[idx] = next;
+      else parts.push(next);
+      return { ...msg, parts };
+    });
+  };
+  const onSseEvent = (eventName, data) => {
+    switch (eventName) {
+      case "agent_start":
+        status.value = "streaming";
+        break;
+      case "delta": {
+        const d = data;
+        appendDelta(d.kind === "thinking" ? "reasoning" : "text", d.delta ?? "");
+        break;
+      }
+      case "tool_start": {
+        const d = data;
+        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;
+        upsertToolPart(d.toolName, d.toolCallId, (prev) => ({
+          ...prev ?? { type: `tool-${d.toolName}`, toolCallId: d.toolCallId, input: void 0, state: "input-available" },
+          type: `tool-${d.toolName}`,
+          toolCallId: d.toolCallId,
+          state: d.isError ? "output-error" : "output-available",
+          output: d.isError ? void 0 : "ok",
+          errorText: d.isError ? "Tool returned an error" : void 0
+        }));
+        break;
+      }
+      case "ui_action": {
+        const d = data;
+        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;
+        error.value = new Error(d?.message ?? "stream error");
+        status.value = "error";
+        currentAssistantId = null;
+        break;
+      }
+      default:
+        break;
+    }
+  };
+  const consume = async (signal) => {
+    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 = [];
+        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 = dataStr;
+        try {
+          data = JSON.parse(dataStr);
+        } catch {
+        }
+        onSseEvent(event, data);
+      }
+    }
+  };
+  const start = async (options = {}) => {
+    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(`${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) => {
+    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, options = {}) => {
+    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 () => {
+    if (!conversationId.value) return;
+    await $fetch(`${apiPrefix}/conversations/${conversationId.value}/abort`, { method: "POST" }).catch(() => {
+    });
+    status.value = "ready";
+  };
+  const reset = async () => {
+    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,
+    status,
+    error,
+    uiActions,
+    app,
+    auth,
+    authReady,
+    files,
+    fileUrl,
+    refreshFiles,
+    saveAuth,
+    start,
+    send,
+    abort,
+    reset
+  };
+};

package/dist/runtime/composables/useAgentRuntimeMarkdown.d.ts

@@ -0,0 +1,15 @@
+import MarkdownIt from 'markdown-it';
+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;
+}
+export declare const createAgentRuntimeMarkdownRenderer: (options?: AgentRuntimeMarkdownRenderOptions) => MarkdownIt;
+export declare const useAgentRuntimeMarkdown: (options?: AgentRuntimeMarkdownRenderOptions) => {
+    markdown: MarkdownIt;
+    render: (text: string) => string;
+    renderInline: (text: string) => string;
+};

package/dist/runtime/composables/useAgentRuntimeMarkdown.js

@@ -0,0 +1,109 @@
+import MarkdownIt from "markdown-it";
+import {
+  isAgentRuntimeImagePath,
+  resolveAgentRuntimeWorkspaceUri,
+  toAgentRuntimeWorkspaceRelativePath
+} from "../utils/files.js";
+const BARE_WORKSPACE_PATH_RE = /(sandbox:[^\s)\]"'<>]+|\/workspace\/[^\s)\]"'<>]+)/g;
+export const createAgentRuntimeMarkdownRenderer = (options = {}) => {
+  const md = new MarkdownIt({
+    html: false,
+    linkify: true,
+    breaks: true,
+    typographer: false
+  });
+  const resolve = (uri) => resolveAgentRuntimeWorkspaceUri(uri, options.resolveWorkspacePath);
+  const defaultLinkOpen = 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 = [];
+      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;
+        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 = {}) => {
+  const markdown = createAgentRuntimeMarkdownRenderer(options);
+  return {
+    markdown,
+    render: (text) => text ? markdown.render(text) : "",
+    renderInline: (text) => text ? markdown.renderInline(text) : ""
+  };
+};

package/dist/runtime/server/api/app.get.d.ts

@@ -0,0 +1,6 @@
+/**
+ * GET `${apiPrefix}/app` — returns the manifest of the configured app
+ * (so the client can render its env-schema form generically).
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/app.get.js

@@ -0,0 +1,26 @@
+import { agentRuntime, agentRuntimeHeaders } from "../utils/agent-runtime.js";
+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();
+  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/dist/runtime/server/api/conversations/[id]/abort.post.d.ts

@@ -0,0 +1,6 @@
+/**
+ * POST `${apiPrefix}/conversations/:id/abort` — cancels the in-flight
+ * agent run for this conversation. Returns 204 on success.
+ */
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,18 @@
+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 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/dist/runtime/server/api/conversations/[id]/env.post.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ */
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,22 @@
+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).catch(() => ({}));
+  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/dist/runtime/server/api/conversations/[id]/files/raw/[...path].get.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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.
+ */
+declare const _default: any;
+export default _default;