qarpeo 0.0.0-alpha.10

package/dist/runtime/server/middleware/devtools.mjs

@@ -0,0 +1,61 @@
+import {
+  defineEventHandler,
+  getRequestURL,
+  createError,
+  useRuntimeConfig,
+  getRequestHeader,
+  getRequestIP,
+  getQuery
+} from "nuxt/server";
+import { getQarpeoConfig } from "../utils/config.mjs";
+export default defineEventHandler(async (event) => {
+  const url = getRequestURL(event);
+  const pathname = url.pathname;
+  const _rc = useRuntimeConfig();
+  const privateConfig = getQarpeoConfig(event);
+  const publicConfig = _rc?.public?.qarpeo || {};
+  const devtoolsConfig = {
+    ...privateConfig.devtools,
+    ...publicConfig.devtools
+  };
+  const isDevtoolsPath = pathname.startsWith("/_qarpeo/");
+  if (!isDevtoolsPath) return;
+  if (process.env.NODE_ENV === "production") {
+    throw createError({ statusCode: 404, statusMessage: "Not Found" });
+  }
+  if (!devtoolsConfig.enabled) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Not Found",
+      message: "Qarpeo DevTools is a development-only tool and is not available in production."
+    });
+  }
+  if (!devtoolsConfig.allowAnyIp) {
+    const rawIp = getRequestIP?.(event, { xForwardedFor: true }) || event.node?.req?.socket?.remoteAddress || event.node?.req?.headers?.["x-forwarded-for"]?.split(",")?.[0]?.trim() || "127.0.0.1";
+    const cleanIp = rawIp.replace(/^::ffff:/, "");
+    const allowedIps = (devtoolsConfig.allowedIps || ["127.0.0.1", "::1", "localhost"]).map((ip) => ip.replace(/^::ffff:/, ""));
+    const isAllowed = allowedIps.includes(cleanIp) || allowedIps.includes(rawIp) || allowedIps.includes("*") || allowedIps.includes("0.0.0.0");
+    if (!isAllowed) {
+      throw createError({
+        statusCode: 403,
+        statusMessage: "Forbidden",
+        message: `Access to Qarpeo DevTools is restricted. Client IP (${rawIp}) is not in the allowed list.`
+      });
+    }
+  }
+  const expectedToken = devtoolsConfig.token || globalThis.process?.env?.QARPEO_DEVTOOLS_TOKEN || globalThis.process?.env?.NUXT_DEVTOOLS_TOKEN;
+  const isTokenRequired = Boolean(devtoolsConfig.requireAuth || expectedToken);
+  if (isTokenRequired && expectedToken) {
+    const authHeader = getRequestHeader(event, "authorization");
+    const headerToken = getRequestHeader(event, "x-qarpeo-devtools-token") || (authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null);
+    const queryToken = getQuery(event)?.token;
+    const providedToken = headerToken || queryToken;
+    if (!providedToken || providedToken !== expectedToken) {
+      throw createError({
+        statusCode: 401,
+        statusMessage: "Unauthorized",
+        message: "Authentication required to access Qarpeo DevTools. Invalid or missing token."
+      });
+    }
+  }
+});

package/dist/runtime/server/middleware/ratelimit.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/server").EventHandler<Promise<void>>;
+export default _default;

package/dist/runtime/server/middleware/ratelimit.mjs

@@ -0,0 +1,49 @@
+import { defineEventHandler, getRequestURL } from "nuxt/server";
+import { getQarpeoConfig } from "../utils/config.mjs";
+import { assertRateLimit, getClientIp } from "../utils/ratelimit.mjs";
+function matchRouteRule(path, rules) {
+  for (const [pattern, rule] of Object.entries(rules)) {
+    if (!rule) continue;
+    const regexPattern = "^" + pattern.replace(/:[a-zA-Z0-9_]+/g, "[^/]+").replace(/\/\*\*/g, "(/.*)?").replace(/\/\*/g, "/[^/]+") + "$";
+    if (new RegExp(regexPattern).test(path)) {
+      return rule;
+    }
+  }
+  return null;
+}
+export default defineEventHandler(async (event) => {
+  const ratelimitConfig = getQarpeoConfig(event).ratelimit;
+  if (!ratelimitConfig || ratelimitConfig.enabled === false) {
+    return;
+  }
+  if (Array.isArray(ratelimitConfig.ipWhitelist) && ratelimitConfig.ipWhitelist.length > 0) {
+    const ip = getClientIp(event);
+    if (ratelimitConfig.ipWhitelist.includes(ip)) {
+      return;
+    }
+  }
+  let pathname = "/";
+  try {
+    pathname = getRequestURL(event).pathname;
+  } catch {
+    pathname = event.path || "/";
+  }
+  const rules = ratelimitConfig.rules || {};
+  const matchedRule = matchRouteRule(pathname, rules);
+  if (matchedRule) {
+    await assertRateLimit(event, {
+      max: matchedRule.max ?? ratelimitConfig.max ?? 100,
+      window: matchedRule.window ?? ratelimitConfig.window ?? "1m",
+      key: matchedRule.key ? `${matchedRule.key}:${getClientIp(event)}` : void 0,
+      backend: ratelimitConfig.backend
+    });
+    return;
+  }
+  if (ratelimitConfig.global && ratelimitConfig.max) {
+    await assertRateLimit(event, {
+      max: ratelimitConfig.max,
+      window: ratelimitConfig.window ?? "1m",
+      backend: ratelimitConfig.backend
+    });
+  }
+});

package/dist/runtime/server/middleware/tenancy.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @file Middleware/tenancy.ts Edge Multi-Tenancy Middleware. Resolves the active tenant for every
+ *   incoming request and attaches it to `event.context.tenant`.
+ */
+declare const _default: import("nuxt/server").EventHandler<Promise<void>>;
+export default _default;

package/dist/runtime/server/middleware/tenancy.mjs

@@ -0,0 +1,15 @@
+import { defineEventHandler } from "nuxt/server";
+import { resolveTenant } from "../utils/tenant.mjs";
+export default defineEventHandler(async (event) => {
+  const url = event.node?.req?.url || "";
+  if (url.startsWith("/_nuxt/") || url.startsWith("/__nuxt")) {
+    return;
+  }
+  const tenant = await resolveTenant(event);
+  if (tenant) {
+    const res = event.node?.res;
+    if (res && typeof res.setHeader === "function") {
+      res.setHeader("x-qarpeo-tenant", tenant.slug);
+    }
+  }
+});

package/dist/runtime/server/middleware/tracker.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @file Middleware/tracker.ts Auto-pageview tracking middleware. Registered when
+ *   `analytics.autoTrack !== false`. Fires trackPageview() in the background after every non-API
+ *   SSR request.
+ */
+declare const _default: import("nuxt/server").EventHandler<void>;
+export default _default;

package/dist/runtime/server/middleware/tracker.mjs

@@ -0,0 +1,9 @@
+import { defineEventHandler } from "nuxt/server";
+import { trackPageview } from "../utils/tracker.mjs";
+export default defineEventHandler((event) => {
+  const url = event.node?.req?.url || "";
+  if (url.startsWith("/api/") || url.startsWith("/_nuxt/") || url.startsWith("/__nuxt") || url.includes(".")) {
+    return;
+  }
+  void Promise.resolve().then(() => trackPageview(event));
+});

package/dist/runtime/server/plugins/agents.d.ts

@@ -0,0 +1,7 @@
+import type { NitroApp } from "nitro/types";
+import "#qarpeo/agents-registry";
+/**
+ * Nitro server plugin for Qarpeo Agents. Automatically imports and registers all discovered
+ * `server/agents/*.ts` definition modules into the in-memory agent runtime registry on startup.
+ */
+export default function (_nitroApp?: NitroApp): void;

package/dist/runtime/server/plugins/agents.mjs

@@ -0,0 +1,3 @@
+import "#qarpeo/agents-registry";
+export default function(_nitroApp) {
+}

package/dist/runtime/server/plugins/cms.d.ts

@@ -0,0 +1,7 @@
+import type { NitroApp } from "nitro/types";
+/**
+ * Nitro server plugin for Qarpeo CMS. In development, automatically creates CMS tables and
+ * synchronizes local `content/` files and `nuxt.config.ts` collections into D1 on startup. In
+ * production, creates CMS tables (idempotent) so requests don't fail if migrations weren't run.
+ */
+export default function (_nitroApp?: NitroApp): void;

package/dist/runtime/server/plugins/cms.mjs

@@ -0,0 +1,16 @@
+import { ensureCMSSynced, ensureCMSTables } from "../utils/cms.mjs";
+let tablesEnsured = false;
+export default function(_nitroApp) {
+  if (process.env.NODE_ENV !== "production" || import.meta.dev) {
+    ensureCMSSynced().catch((err) => {
+      console.warn("[qarpeo:cms] Startup auto-sync warning:", err);
+    });
+  } else {
+    if (!tablesEnsured) {
+      tablesEnsured = true;
+      ensureCMSTables().catch((err) => {
+        console.warn("[qarpeo:cms] Startup table creation warning:", err);
+      });
+    }
+  }
+}

package/dist/runtime/server/plugins/dev-logs.d.ts

@@ -0,0 +1 @@
+export default function (nitroApp: any): void;

package/dist/runtime/server/plugins/dev-logs.mjs

@@ -0,0 +1,58 @@
+import { addDevLog } from "../utils/dev-logs.mjs";
+export default function(nitroApp) {
+  nitroApp.hooks?.hook("request", (event) => {
+    event._qarpeoStartTime = Date.now();
+  });
+  nitroApp.hooks?.hook("response", (response, { event } = {}) => {
+    const ev = event || response;
+    const url = ev?.node?.req?.url || ev?.path || "";
+    if (url.startsWith("/_nuxt") || url.startsWith("/__nuxt") || url.startsWith("/favicon.ico") || url.includes("/_qarpeo/api/logs") || url.includes("/__qarpeo/api/logs")) {
+      return;
+    }
+    const duration = ev?._qarpeoStartTime ? Date.now() - ev._qarpeoStartTime : 0;
+    const status = response?.status || ev?.node?.res?.statusCode || 200;
+    const method = ev?.node?.req?.method || ev?.method || "GET";
+    let level = "info";
+    if (status >= 500) {
+      level = "error";
+    } else if (status >= 400) {
+      level = "warn";
+    }
+    let source = "nitro:http";
+    if (url.startsWith("/api/cms") || url.startsWith("/cms")) {
+      source = "qarpeo:cms";
+    } else if (url.startsWith("/api/auth") || url.startsWith("/auth")) {
+      source = "qarpeo:auth";
+    } else if (url.startsWith("/api/tenants")) {
+      source = "qarpeo:tenant";
+    } else if (url.startsWith("/api/agents")) {
+      source = "qarpeo:agent";
+    } else if (url.startsWith("/api/analytics")) {
+      source = "qarpeo:analytics";
+    } else if (url.startsWith("/_qarpeo/api/db") || url.startsWith("/__qarpeo/api/db")) {
+      source = "qarpeo:d1";
+    } else if (url.startsWith("/_qarpeo/api/kv") || url.startsWith("/__qarpeo/api/kv")) {
+      source = "qarpeo:kv";
+    } else if (url.startsWith("/_qarpeo/api/blob") || url.startsWith("/__qarpeo/api/blob")) {
+      source = "qarpeo:blob";
+    } else if (url.startsWith("/_qarpeo/api/mail") || url.startsWith("/__qarpeo/api/mail")) {
+      source = "qarpeo:mail";
+    }
+    addDevLog({
+      level,
+      source,
+      message: `${method} ${url} - ${status} (${duration}ms)`,
+      durationMs: duration,
+      status
+    });
+  });
+  nitroApp.hooks?.hook("error", (error, { event }) => {
+    const url = event?.node?.req?.url || "";
+    addDevLog({
+      level: "error",
+      source: "nitro:error",
+      message: `${error?.message || "Internal error"} on ${url}`,
+      status: error?.statusCode || 500
+    });
+  });
+}

package/dist/runtime/server/plugins/dev-proxy.d.ts

@@ -0,0 +1,3 @@
+import type { NitroApp } from "nitro/types";
+/** Nitro server plugin that attaches Miniflare bindings in dev mode. */
+export default function (nitroApp: NitroApp): Promise<void>;

package/dist/runtime/server/plugins/dev-proxy.mjs

@@ -0,0 +1,21 @@
+import { getOrInitDevProxy } from "../utils/dev-proxy.mjs";
+export default async function(nitroApp) {
+  const proxy = await getOrInitDevProxy();
+  if (proxy?.env) {
+    if (!proxy.env.AI) {
+      proxy.env.AI = {
+        run: async (model, input) => ({
+          response: `[Mock AI] Response for model "${model}" in local development. Set CLOUDFLARE_API_TOKEN to connect to live Cloudflare Workers AI.`
+        })
+      };
+    }
+    ;
+    globalThis.__QARPEO_DEV_ENV__ = proxy.env;
+    nitroApp.hooks?.hook("request", (event) => {
+      event.context = event.context || {};
+      event.context.cloudflare = event.context.cloudflare || {};
+      event.context.cloudflare.env = event.context.cloudflare.env || proxy.env;
+      globalThis.__qarpeo_event__ = event;
+    });
+  }
+}

package/dist/runtime/server/plugins/env.d.ts

@@ -0,0 +1,6 @@
+import type { NitroApp } from "nitro/types";
+/**
+ * Lightweight Nitro runtime plugin that captures the Cloudflare request context across both
+ * production and edge environments.
+ */
+export default function (nitroApp: NitroApp): void;

package/dist/runtime/server/plugins/env.mjs

@@ -0,0 +1,17 @@
+export default function(nitroApp) {
+  nitroApp.hooks?.hook("request", (event) => {
+    ;
+    globalThis.__qarpeo_event__ = event;
+    if (event?.context?.cloudflare?.env) {
+      ;
+      globalThis.__qarpeo_env__ = event.context.cloudflare.env;
+    }
+  });
+  const cleanup = () => {
+    if (globalThis.__qarpeo_event__) {
+      ;
+      globalThis.__qarpeo_event__ = void 0;
+    }
+  };
+  nitroApp.hooks?.hook?.("response", cleanup);
+}

package/dist/runtime/server/plugins/queue.d.ts

@@ -0,0 +1,6 @@
+import type { NitroApp } from "nitro/types";
+/**
+ * Nitro server plugin that dispatches incoming Cloudflare Queue batches to the user's queue
+ * handler.
+ */
+export default function (nitroApp: NitroApp): void;

package/dist/runtime/server/plugins/queue.mjs

@@ -0,0 +1,8 @@
+import queueHandler from "#qarpeo/queue-consumer";
+export default function(nitroApp) {
+  if (typeof queueHandler === "function") {
+    nitroApp.hooks?.hook("cloudflare:queue", async ({ batch }) => {
+      await queueHandler(batch);
+    });
+  }
+}

package/dist/runtime/server/routes/__qarpeo/agents/chat.post.d.ts

@@ -0,0 +1,20 @@
+/**
+ * POST /_qarpeo/api/agents/chat Body: { agent: string, message: string, model?: string } Executes
+ * a chat interaction with an agent and stores the response in the session history.
+ */
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    id: any;
+    reply: any;
+    role: string;
+    model: any;
+    timestamp: string;
+    latencyMs?: undefined;
+} | {
+    id: string;
+    reply: string;
+    role: string;
+    model: any;
+    latencyMs: number;
+    timestamp: string;
+}>>;
+export default _default;

package/dist/runtime/server/routes/__qarpeo/agents/chat.post.mjs

@@ -0,0 +1,110 @@
+import { defineEventHandler, readBody, createError } from "nuxt/server";
+import { getDevMockAgentsStore } from "../../../utils/agent-store.mjs";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event) || {};
+  const agentId = body.agent || body.id;
+  const text = (body.message || "").trim();
+  const customModel = body.model;
+  if (!agentId) {
+    throw createError({ statusCode: 400, message: "agent id is required" });
+  }
+  if (!text) {
+    throw createError({ statusCode: 400, message: "message is required" });
+  }
+  const { getAgentDefinition, useAgent } = await import("../../../utils/ai.mjs");
+  const def = getAgentDefinition(agentId);
+  if (def) {
+    try {
+      const agentClient = useAgent(agentId, "devtools", event);
+      const res = await agentClient.chat(text, {
+        stream: false,
+        model: customModel || def.model,
+        system: def.system
+      });
+      const data = await res.json();
+      const assistantReply = data.reply || data.message?.content || data.response || "";
+      return {
+        id: data.id || `msg_${Date.now()}_a`,
+        reply: assistantReply,
+        role: "assistant",
+        model: customModel || def.model,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (err) {
+      console.warn(`[qarpeo:devtools] Falling back to mock store for agent "${agentId}":`, err.message);
+    }
+  }
+  const store = getDevMockAgentsStore();
+  let agent = store.get(agentId);
+  if (!agent) {
+    agent = {
+      id: agentId,
+      name: agentId.replace(/_/g, " "),
+      description: "Custom Edge Agent",
+      status: "idle",
+      model: customModel || "@cf/meta/llama-3.3-70b-instruct",
+      systemPrompt: "You are an autonomous AI agent running on Cloudflare Workers.",
+      tools: [],
+      createdAt: Date.now(),
+      messages: []
+    };
+    store.set(agentId, agent);
+  }
+  const activeModel = customModel || agent.model;
+  const userMsgId = `msg_${Date.now()}_u`;
+  const userTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+  agent.messages.push({
+    id: userMsgId,
+    role: "user",
+    content: text,
+    timestamp: userTimestamp
+  });
+  const t0 = performance.now();
+  let reply = "";
+  try {
+    const { getAIBinding } = await import("../../../../ai.mjs");
+    const ai = getAIBinding("AI", event);
+    const promptHistory = [
+      { role: "system", content: agent.systemPrompt },
+      ...agent.messages.map((m) => ({ role: m.role, content: m.content }))
+    ];
+    const aiRes = await ai.run(activeModel, { messages: promptHistory });
+    reply = aiRes?.response || aiRes?.reply || aiRes?.text || JSON.stringify(aiRes);
+  } catch {
+    await new Promise((r) => setTimeout(r, 220));
+    if (text.toLowerCase().includes("help") || text.toLowerCase().includes("hello")) {
+      reply = `Hello! I am ${agent.name}. I am running on Cloudflare Edge using ${activeModel}. I maintain persistent memory across sessions via Durable Objects storage.`;
+    } else if (text.toLowerCase().includes("tool") || text.toLowerCase().includes("capabilities")) {
+      const toolNames = agent.tools.length > 0 ? agent.tools.join(", ") : "none currently bound";
+      reply = `My active tools include: [${toolNames}]. My system prompt is configured as: "${agent.systemPrompt}".`;
+    } else if (text.toLowerCase().includes("code") || text.toLowerCase().includes("example")) {
+      reply = `Here is an example of an edge agent query using Qarpeo:
+\`\`\`ts
+const agent = useAgent("${agent.id}")
+const res = await agent.chat("${text}")
+\`\`\`
+Executed at the edge with zero cold starts.`;
+    } else {
+      reply = `I have received your request: "${text}". I have logged this to my stateful memory (${agent.messages.length} messages in context). Let me know how else I can assist you!`;
+    }
+  }
+  const latencyMs = Math.round(performance.now() - t0);
+  const assistantMsgId = `msg_${Date.now()}_a`;
+  const assistantTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+  agent.messages.push({
+    id: assistantMsgId,
+    role: "assistant",
+    content: reply,
+    timestamp: assistantTimestamp,
+    model: activeModel,
+    latencyMs
+  });
+  return {
+    id: assistantMsgId,
+    reply,
+    role: "assistant",
+    model: activeModel,
+    latencyMs,
+    timestamp: assistantTimestamp
+  };
+});

package/dist/runtime/server/routes/__qarpeo/agents/clear.post.d.ts

@@ -0,0 +1,7 @@
+/** POST /_qarpeo/api/agents/clear Body: { agent: string } Clears history for an agent. */
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    ok: boolean;
+    agentId: any;
+    cleared: boolean;
+}>>;
+export default _default;

package/dist/runtime/server/routes/__qarpeo/agents/clear.post.mjs

@@ -0,0 +1,15 @@
+import { defineEventHandler, readBody, createError } from "nuxt/server";
+import { getDevMockAgentsStore } from "../../../utils/agent-store.mjs";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event) || {};
+  const agentId = body.agent || body.id;
+  if (!agentId) {
+    throw createError({ statusCode: 400, message: "agent id is required" });
+  }
+  const store = getDevMockAgentsStore();
+  const agent = store.get(agentId);
+  if (agent) {
+    agent.messages = [];
+  }
+  return { ok: true, agentId, cleared: true };
+});

package/dist/runtime/server/routes/__qarpeo/agents/create.post.d.ts

@@ -0,0 +1,17 @@
+/**
+ * POST /_qarpeo/api/agents/create Body: { id?: string, name: string, description?: string, model?:
+ * string, systemPrompt?: string, tools?: string[] } Creates a new edge agent session.
+ */
+declare const _default: import("nuxt/server").EventHandler<Promise<{
+    ok: boolean;
+    agent: {
+        id: any;
+        name: any;
+        description: any;
+        model: any;
+        systemPrompt: any;
+        tools: any;
+        createdAt: number;
+    };
+}>>;
+export default _default;

package/dist/runtime/server/routes/__qarpeo/agents/create.post.mjs

@@ -0,0 +1,47 @@
+import { defineEventHandler, readBody, createError } from "nuxt/server";
+import { getDevMockAgentsStore } from "../../../utils/agent-store.mjs";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event) || {};
+  const name = (body.name || "").trim();
+  if (!name) {
+    throw createError({ statusCode: 400, message: "Agent name is required" });
+  }
+  const slug = body.id || `agent_${name.toLowerCase().replace(/[^\w]/g, "_").replace(/_+/g, "_")}`;
+  const model = body.model || "@cf/meta/llama-3.3-70b-instruct";
+  const systemPrompt = body.systemPrompt || "You are an AI assistant running on Cloudflare Workers edge runtime.";
+  const description = body.description || "Custom AI agent created in Qarpeo DevTools.";
+  const tools = Array.isArray(body.tools) ? body.tools : [];
+  const store = getDevMockAgentsStore();
+  const agent = {
+    id: slug,
+    name,
+    description,
+    status: "idle",
+    model,
+    systemPrompt,
+    tools,
+    createdAt: Date.now(),
+    messages: [
+      {
+        id: `msg_${Date.now()}_init`,
+        role: "assistant",
+        content: `Agent "${name}" initialized with model ${model}. System prompt: "${systemPrompt}"`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        model
+      }
+    ]
+  };
+  store.set(slug, agent);
+  return {
+    ok: true,
+    agent: {
+      id: agent.id,
+      name: agent.name,
+      description: agent.description,
+      model: agent.model,
+      systemPrompt: agent.systemPrompt,
+      tools: agent.tools,
+      createdAt: agent.createdAt
+    }
+  };
+});

package/dist/runtime/server/routes/__qarpeo/agents/history.get.d.ts

@@ -0,0 +1,15 @@
+/** GET /_qarpeo/api/agents/history?agent=<id> Returns message history for an agent. */
+declare const _default: import("nuxt/server").EventHandler<{
+    messages: never[];
+    agent?: undefined;
+} | {
+    agent: {
+        id: string;
+        name: string;
+        model: string;
+        systemPrompt: string;
+        tools: string[];
+    };
+    messages: import("../../../utils/agent-store").AgentMessageRecord[];
+}>;
+export default _default;

package/dist/runtime/server/routes/__qarpeo/agents/history.get.mjs

@@ -0,0 +1,24 @@
+import { defineEventHandler, getQuery, createError } from "nuxt/server";
+import { getDevMockAgentsStore } from "../../../utils/agent-store.mjs";
+export default defineEventHandler((event) => {
+  const query = getQuery(event);
+  const agentId = query.agent || query.id;
+  if (!agentId) {
+    throw createError({ statusCode: 400, message: "agent id is required" });
+  }
+  const store = getDevMockAgentsStore();
+  const agent = store.get(agentId);
+  if (!agent) {
+    return { messages: [] };
+  }
+  return {
+    agent: {
+      id: agent.id,
+      name: agent.name,
+      model: agent.model,
+      systemPrompt: agent.systemPrompt,
+      tools: agent.tools
+    },
+    messages: agent.messages
+  };
+});

package/dist/runtime/server/routes/__qarpeo/agents/list.get.d.ts

@@ -0,0 +1,5 @@
+/** GET /_qarpeo/api/agents/list Lists configured/discovered Durable Object agents and their status. */
+declare const _default: import("nuxt/server").EventHandler<{
+    agents: any[];
+}>;
+export default _default;