qarpeo 0.0.0-alpha.10

package/dist/runtime/server/db/cms-schema.mjs

@@ -0,0 +1,74 @@
+import { integer, text, index, snakeCase } from "drizzle-orm/sqlite-core";
+export const ALL_CMS_TABLE_NAMES = [
+  "_qarpeo_cms_collections",
+  "_qarpeo_cms_entries",
+  "_qarpeo_cms_revisions"
+];
+export function getActiveCmsTableNames(cms) {
+  if (!cms) return [];
+  return [...ALL_CMS_TABLE_NAMES];
+}
+export const cmsCollections = snakeCase.table("_qarpeo_cms_collections", {
+  id: text().primaryKey(),
+  tenantId: text(),
+  name: text().notNull(),
+  description: text(),
+  schemaJson: text().notNull().default("{}"),
+  source: text().notNull().default("db"),
+  order: integer().notNull().default(0),
+  createdAt: integer().notNull(),
+  updatedAt: integer().notNull()
+});
+export const cmsEntries = snakeCase.table(
+  "_qarpeo_cms_entries",
+  {
+    id: text().primaryKey(),
+    tenantId: text(),
+    collectionId: text().notNull(),
+    slug: text().notNull(),
+    title: text().notNull(),
+    description: text(),
+    coverImage: text(),
+    tags: text(),
+    order: integer().notNull().default(0),
+    contentMd: text().notNull().default(""),
+    contentHtml: text().notNull().default(""),
+    metadataJson: text().default("{}"),
+    status: text().notNull().default("draft"),
+    source: text().notNull().default("db"),
+    path: text(),
+    filePath: text(),
+    contentHash: text(),
+    authorId: text(),
+    locale: text().notNull().default("en"),
+    version: text().notNull().default("latest"),
+    publishedAt: integer(),
+    createdAt: integer().notNull(),
+    updatedAt: integer().notNull()
+  },
+  (t) => [
+    index("_qarpeo_cms_entries_collection_idx").on(t.collectionId),
+    index("_qarpeo_cms_entries_tenant_idx").on(t.tenantId, t.collectionId),
+    index("_qarpeo_cms_entries_slug_idx").on(t.collectionId, t.slug),
+    index("_qarpeo_cms_entries_status_idx").on(t.status),
+    index("_qarpeo_cms_entries_order_idx").on(t.collectionId, t.order),
+    index("_qarpeo_cms_entries_path_idx").on(t.collectionId, t.path),
+    index("_qarpeo_cms_entries_locale_idx").on(t.collectionId, t.locale),
+    index("_qarpeo_cms_entries_path_locale_idx").on(t.path, t.locale),
+    index("_qarpeo_cms_entries_published_at_idx").on(t.publishedAt),
+    index("_qarpeo_cms_entries_list_idx").on(t.collectionId, t.status, t.publishedAt)
+  ]
+);
+export const cmsRevisions = snakeCase.table(
+  "_qarpeo_cms_revisions",
+  {
+    id: text().primaryKey(),
+    entryId: text().notNull(),
+    title: text().notNull(),
+    contentMd: text().notNull(),
+    metadataJson: text().default("{}"),
+    authorId: text(),
+    createdAt: integer().notNull()
+  },
+  (t) => [index("_qarpeo_cms_revisions_entry_idx").on(t.entryId, t.createdAt)]
+);

package/dist/runtime/server/durable-objects/agent.d.ts

@@ -0,0 +1,14 @@
+import "#qarpeo/agents-registry";
+import type { DurableObjectState, AgentDefinition } from "../../../types";
+export declare class QarpeoAgentDO {
+    ctx: DurableObjectState;
+    env: Record<string, any>;
+    agentDefinition: AgentDefinition | null;
+    constructor(ctx: DurableObjectState, env: Record<string, any>);
+    /**
+     * Cloudflare Durable Object Alarm trigger. Enables scheduled wakeups, delayed reminders, and
+     * background agent tasks.
+     */
+    alarm(): Promise<void>;
+    fetch(request: Request): Promise<Response>;
+}

package/dist/runtime/server/durable-objects/agent.mjs

@@ -0,0 +1,571 @@
+import "#qarpeo/agents-registry";
+import { getAgentDefinition } from "../utils/ai.mjs";
+function normalizeTools(toolsInput) {
+  const map = /* @__PURE__ */ new Map();
+  if (!toolsInput) return map;
+  if (Array.isArray(toolsInput)) {
+    for (const t of toolsInput) {
+      if (t && t.name) {
+        map.set(t.name, t);
+      }
+    }
+  } else if (typeof toolsInput === "object") {
+    for (const [key, t] of Object.entries(toolsInput)) {
+      if (t) {
+        map.set(t.name || key, { ...t, name: t.name || key });
+      }
+    }
+  }
+  return map;
+}
+function extractToolCalls(res, accumulatedText) {
+  const calls = [];
+  const rawCalls = res?.tool_calls || res?.toolCalls;
+  if (Array.isArray(rawCalls) && rawCalls.length > 0) {
+    for (const tc of rawCalls) {
+      const name = tc.name || tc.function?.name;
+      let args = tc.arguments || tc.function?.arguments || {};
+      if (typeof args === "string") {
+        try {
+          args = JSON.parse(args);
+        } catch {
+        }
+      }
+      if (name) {
+        calls.push({
+          id: tc.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
+          name,
+          arguments: args
+        });
+      }
+    }
+  }
+  if (calls.length === 0 && accumulatedText) {
+    const xmlRegex = /<tool_call>([\s\S]*?)<\/tool_call>/gi;
+    let xmlMatch;
+    while ((xmlMatch = xmlRegex.exec(accumulatedText)) !== null) {
+      try {
+        const parsed = JSON.parse(xmlMatch[1].trim());
+        const name = parsed.name || parsed.function?.name;
+        const args = parsed.arguments || parsed.parameters || parsed.function?.arguments || {};
+        if (name) {
+          calls.push({
+            id: parsed.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
+            name,
+            arguments: typeof args === "string" ? JSON.parse(args) : args
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  if (calls.length === 0 && accumulatedText) {
+    try {
+      const match = accumulatedText.match(/```(?:json)?\s*(\{[\s\S]*?"name"[\s\S]*?\})\s*```/i);
+      if (match && match[1]) {
+        const parsed = JSON.parse(match[1]);
+        const name = parsed.name || parsed.function?.name;
+        if (name && (parsed.arguments || parsed.parameters || parsed.function?.arguments)) {
+          calls.push({
+            id: parsed.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
+            name,
+            arguments: parsed.arguments || parsed.parameters || parsed.function?.arguments || {}
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  if (calls.length === 0 && accumulatedText) {
+    const trimmed = accumulatedText.trim();
+    if (trimmed.startsWith("{") && trimmed.endsWith("}") && trimmed.includes('"name"')) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        const name = parsed.name || parsed.function?.name;
+        if (name && (parsed.arguments || parsed.parameters || parsed.function?.arguments)) {
+          calls.push({
+            id: parsed.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
+            name,
+            arguments: parsed.arguments || parsed.parameters || parsed.function?.arguments || {}
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  return calls;
+}
+function cleanAssistantReply(text) {
+  return (text || "").replace(/<tool_call>[\s\S]*?<\/tool_call>/gi, "").trim();
+}
+export class QarpeoAgentDO {
+  ctx;
+  env;
+  agentDefinition = null;
+  constructor(ctx, env) {
+    this.ctx = ctx;
+    this.env = env;
+  }
+  /**
+   * Cloudflare Durable Object Alarm trigger. Enables scheduled wakeups, delayed reminders, and
+   * background agent tasks.
+   */
+  async alarm() {
+    const scheduledTask = await this.ctx.storage.get("scheduled_task");
+    const agentName = await this.ctx.storage.get("agentName");
+    if (agentName && !this.agentDefinition) {
+      this.agentDefinition = getAgentDefinition(agentName) || null;
+    }
+    if (scheduledTask && this.agentDefinition) {
+      console.log(
+        `[qarpeo:agent] Alarm fired for agent "${this.agentDefinition.name}":`,
+        scheduledTask
+      );
+      if (typeof this.agentDefinition.onMessage === "function") {
+        const state = await this.ctx.storage.get("state") || {};
+        const messages = await this.ctx.storage.get("messages") || [];
+        const toolsMap = normalizeTools(this.agentDefinition.tools);
+        const toolsRecord = Object.fromEntries(toolsMap.entries());
+        const context = {
+          agentId: this.agentDefinition.name,
+          agentName: this.agentDefinition.name,
+          state,
+          setState: async (newState) => {
+            const merged = { ...state, ...newState };
+            await this.ctx.storage.put("state", merged);
+          },
+          messages,
+          saveMessages: async (newMessages) => {
+            await this.ctx.storage.put("messages", newMessages);
+          },
+          tools: toolsRecord,
+          env: this.env,
+          setAlarm: async (timestamp) => {
+            const time = timestamp instanceof Date ? timestamp.getTime() : timestamp;
+            if (typeof this.ctx.storage.setAlarm === "function") {
+              await this.ctx.storage.setAlarm(time);
+            }
+          }
+        };
+        try {
+          await this.agentDefinition.onMessage(scheduledTask, context);
+        } catch (err) {
+          console.error(`[qarpeo:agent] Error in alarm onMessage handler:`, err);
+        }
+      }
+      await this.ctx.storage.delete("scheduled_task");
+    }
+  }
+  async fetch(request) {
+    const url = new URL(request.url);
+    const pathname = url.pathname;
+    try {
+      if (request.method === "GET" && pathname.endsWith("/history")) {
+        const messages = await this.ctx.storage.get("messages") || [];
+        return Response.json({ messages });
+      }
+      if (request.method === "POST" && pathname.endsWith("/clear")) {
+        await this.ctx.storage.delete("messages");
+        return Response.json({ success: true, messages: [] });
+      }
+      if (request.method === "GET" && pathname.endsWith("/state")) {
+        const state = await this.ctx.storage.get("state") || {};
+        return Response.json({ state });
+      }
+      if (request.method === "POST" && pathname.endsWith("/state")) {
+        const body = await request.json();
+        const currentState = await this.ctx.storage.get("state") || {};
+        const newState = { ...currentState, ...body };
+        await this.ctx.storage.put("state", newState);
+        return Response.json({ success: true, state: newState });
+      }
+      if (request.method === "POST") {
+        const body = await request.json();
+        const agentName = body.agentName || "";
+        if (agentName) {
+          await this.ctx.storage.put("agentName", agentName);
+          const registered = getAgentDefinition(agentName);
+          if (registered) {
+            this.agentDefinition = registered;
+          }
+        } else if (!this.agentDefinition) {
+          const storedName = await this.ctx.storage.get("agentName");
+          if (storedName) {
+            this.agentDefinition = getAgentDefinition(storedName) || null;
+          }
+        }
+        const userContent = typeof body.message === "string" ? body.message : body.message?.content || "";
+        const stream = body.stream !== false;
+        const systemPrompt = body.system || this.agentDefinition?.system || "You are a helpful assistant.";
+        const model = body.model || this.agentDefinition?.model || "@cf/meta/llama-3.3-70b-instruct";
+        const maxSteps = Math.max(1, body.maxSteps ?? this.agentDefinition?.maxSteps ?? 5);
+        const maxContextMessages = body.maxContextMessages ?? this.agentDefinition?.maxContextMessages ?? 30;
+        const toolMap = /* @__PURE__ */ new Map();
+        const defTools = normalizeTools(this.agentDefinition?.tools);
+        for (const [k, v] of defTools.entries()) toolMap.set(k, v);
+        const reqTools = normalizeTools(body.tools);
+        for (const [k, v] of reqTools.entries()) {
+          if (!toolMap.has(k)) {
+            toolMap.set(k, v);
+          }
+        }
+        const formattedTools = Array.from(toolMap.values()).map((t) => ({
+          name: t.name,
+          description: t.description || "",
+          parameters: t.parameters || { type: "object", properties: {} },
+          type: "function",
+          function: {
+            name: t.name,
+            description: t.description || "",
+            parameters: t.parameters || { type: "object", properties: {} }
+          }
+        }));
+        let enhancedSystemPrompt = systemPrompt;
+        if (toolMap.size > 0) {
+          const toolDescriptions = Array.from(toolMap.values()).map(
+            (t) => `- ${t.name}: ${t.description || "Custom tool"}. Parameters: ${JSON.stringify(t.parameters || {})}`
+          ).join("\n");
+          enhancedSystemPrompt += `
+
+You have access to the following tools:
+${toolDescriptions}
+When using a tool, you can call it natively or output: <tool_call>{"name": "toolName", "arguments": {...}}</tool_call>.`;
+        }
+        let messages = await this.ctx.storage.get("messages") || [];
+        const userMsg = {
+          id: `msg_${Date.now()}_u`,
+          role: "user",
+          content: userContent,
+          createdAt: Date.now()
+        };
+        messages.push(userMsg);
+        if (messages.length > maxContextMessages) {
+          messages = messages.slice(-maxContextMessages);
+        }
+        const aiBinding = this.env.AI;
+        const executeTool = async (name, args) => {
+          const tool = toolMap.get(name);
+          if (!tool || typeof tool.execute !== "function") {
+            return { error: `Tool "${name}" is not implemented or missing execute function.` };
+          }
+          const currentState = await this.ctx.storage.get("state") || {};
+          const toolContext = {
+            env: this.env,
+            storage: this.ctx.storage,
+            state: currentState,
+            setState: async (newState) => {
+              const curr = await this.ctx.storage.get("state") || {};
+              const merged = { ...curr, ...newState };
+              await this.ctx.storage.put("state", merged);
+              return merged;
+            },
+            agentName,
+            getBinding: (bName) => this.env[bName]
+          };
+          try {
+            return await tool.execute(args, toolContext);
+          } catch (err) {
+            return { error: err?.message || String(err) };
+          }
+        };
+        if (stream) {
+          const { readable, writable } = new TransformStream();
+          const writer = writable.getWriter();
+          const encoder = new TextEncoder();
+          const sendSSE = async (event, data) => {
+            const payload = `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+            await writer.write(encoder.encode(payload));
+          };
+          (async () => {
+            try {
+              let assistantFinalReply = "";
+              if (!aiBinding || typeof aiBinding.run !== "function") {
+                let matchedTool;
+                for (const [name, tool] of toolMap.entries()) {
+                  if (userContent.toLowerCase().includes(name.toLowerCase())) {
+                    matchedTool = tool;
+                    break;
+                  }
+                }
+                if (matchedTool) {
+                  const callId = `call_${Date.now()}`;
+                  await sendSSE("tool-call", {
+                    id: callId,
+                    name: matchedTool.name,
+                    arguments: {}
+                  });
+                  const toolResult = await executeTool(matchedTool.name, {});
+                  await sendSSE("tool-result", {
+                    id: callId,
+                    name: matchedTool.name,
+                    result: toolResult
+                  });
+                  assistantFinalReply = `[Dev Mock] Executed tool "${matchedTool.name}" with result: ${typeof toolResult === "object" ? JSON.stringify(toolResult, null, 2) : String(toolResult)}`;
+                  await sendSSE("text-delta", { delta: assistantFinalReply });
+                } else {
+                  const toolNames = Array.from(toolMap.keys());
+                  assistantFinalReply = toolNames.length > 0 ? `[Dev Mock] Agent "${agentName || "default"}" received: "${userContent}". Discovered tools: [${toolNames.join(", ")}]. Mention a tool name to test its execution locally, or configure Cloudflare Workers AI in wrangler.json for live inference.` : `[Dev Mock] Echo from agent: "${userContent}". To use live inference, configure Cloudflare Workers AI in wrangler.json.`;
+                  await sendSSE("text-delta", { delta: assistantFinalReply });
+                }
+              } else {
+                for (let step = 0; step < maxSteps; step++) {
+                  const aiMessages = [
+                    { role: "system", content: enhancedSystemPrompt },
+                    ...messages.map((m) => {
+                      const msg = { role: m.role, content: m.content || "" };
+                      if (m.name) msg.name = m.name;
+                      if (m.toolCalls) {
+                        msg.tool_calls = m.toolCalls.map((tc) => ({
+                          id: tc.id,
+                          type: "function",
+                          function: {
+                            name: tc.name,
+                            arguments: typeof tc.arguments === "string" ? tc.arguments : JSON.stringify(tc.arguments)
+                          }
+                        }));
+                      }
+                      if (m.toolCallId) msg.tool_call_id = m.toolCallId;
+                      return msg;
+                    })
+                  ];
+                  const isLastStep = step === maxSteps - 1;
+                  const aiOptions = {
+                    messages: aiMessages,
+                    stream: isLastStep || formattedTools.length === 0
+                  };
+                  if (formattedTools.length > 0 && !isLastStep) {
+                    aiOptions.tools = formattedTools;
+                  }
+                  let stepReply = "";
+                  let stepToolCalls = [];
+                  if (aiOptions.stream) {
+                    const aiStream = await aiBinding.run(model, aiOptions);
+                    if (aiStream && typeof aiStream.getReader === "function") {
+                      const reader = aiStream.getReader();
+                      const decoder = new TextDecoder();
+                      let sseBuffer = "";
+                      while (true) {
+                        const { done, value } = await reader.read();
+                        if (done) {
+                          if (sseBuffer.trim().startsWith("data: ")) {
+                            const dataStr = sseBuffer.trim().slice(6).trim();
+                            if (dataStr !== "[DONE]") {
+                              try {
+                                const parsed = JSON.parse(dataStr);
+                                const delta = parsed.response || parsed.delta?.content || "";
+                                if (delta) {
+                                  stepReply += delta;
+                                  await sendSSE("text-delta", { delta });
+                                }
+                                if (parsed.tool_calls) {
+                                  const calls = extractToolCalls(parsed, stepReply);
+                                  stepToolCalls.push(...calls);
+                                }
+                              } catch {
+                              }
+                            }
+                          }
+                          break;
+                        }
+                        sseBuffer += decoder.decode(value, { stream: true });
+                        const lines = sseBuffer.split("\n");
+                        sseBuffer = lines.pop() || "";
+                        for (const line of lines) {
+                          if (line.startsWith("data: ")) {
+                            const dataStr = line.slice(6).trim();
+                            if (dataStr === "[DONE]") continue;
+                            try {
+                              const parsed = JSON.parse(dataStr);
+                              const delta = parsed.response || parsed.delta?.content || "";
+                              if (delta) {
+                                stepReply += delta;
+                                await sendSSE("text-delta", { delta });
+                              }
+                              if (parsed.tool_calls) {
+                                const calls = extractToolCalls(parsed, stepReply);
+                                stepToolCalls.push(...calls);
+                              }
+                            } catch {
+                            }
+                          }
+                        }
+                      }
+                    } else if (aiStream && typeof aiStream === "object" && "response" in aiStream) {
+                      stepReply = aiStream.response;
+                      await sendSSE("text-delta", { delta: stepReply });
+                    }
+                  } else {
+                    const result = await aiBinding.run(model, aiOptions);
+                    stepReply = result?.response || "";
+                    stepToolCalls = extractToolCalls(result, stepReply);
+                  }
+                  if (stepToolCalls.length === 0 && stepReply.includes("<tool_call>")) {
+                    stepToolCalls = extractToolCalls(null, stepReply);
+                  }
+                  if (stepToolCalls.length > 0) {
+                    const cleanReply = cleanAssistantReply(stepReply);
+                    const toolCallMsg = {
+                      id: `msg_${Date.now()}_tc_${step}`,
+                      role: "assistant",
+                      content: cleanReply,
+                      toolCalls: stepToolCalls,
+                      createdAt: Date.now()
+                    };
+                    messages.push(toolCallMsg);
+                    for (const call of stepToolCalls) {
+                      await sendSSE("tool-call", {
+                        id: call.id,
+                        name: call.name,
+                        arguments: call.arguments
+                      });
+                      const toolResult = await executeTool(call.name, call.arguments);
+                      await sendSSE("tool-result", {
+                        id: call.id,
+                        name: call.name,
+                        result: toolResult
+                      });
+                      const toolResultMsg = {
+                        id: `msg_${Date.now()}_tr_${call.id}`,
+                        role: "tool",
+                        name: call.name,
+                        toolCallId: call.id,
+                        content: typeof toolResult === "string" ? toolResult : JSON.stringify(toolResult),
+                        createdAt: Date.now()
+                      };
+                      messages.push(toolResultMsg);
+                    }
+                    continue;
+                  }
+                  assistantFinalReply = cleanAssistantReply(stepReply);
+                  break;
+                }
+              }
+              const assistantMsg2 = {
+                id: `msg_${Date.now()}_a`,
+                role: "assistant",
+                content: assistantFinalReply,
+                createdAt: Date.now()
+              };
+              messages.push(assistantMsg2);
+              await this.ctx.storage.put("messages", messages);
+              await sendSSE("done", {
+                id: assistantMsg2.id,
+                content: assistantFinalReply,
+                messages
+              });
+            } catch (err) {
+              await sendSSE("error", { message: err?.message || "Agent execution failed" });
+            } finally {
+              await writer.close();
+            }
+          })();
+          return new Response(readable, {
+            headers: {
+              "Content-Type": "text/event-stream; charset=utf-8",
+              "Cache-Control": "no-cache, no-transform",
+              Connection: "keep-alive"
+            }
+          });
+        }
+        let assistantReply = "";
+        if (!aiBinding || typeof aiBinding.run !== "function") {
+          let matchedTool;
+          for (const [name, tool] of toolMap.entries()) {
+            if (userContent.toLowerCase().includes(name.toLowerCase())) {
+              matchedTool = tool;
+              break;
+            }
+          }
+          if (matchedTool) {
+            const toolResult = await executeTool(matchedTool.name, {});
+            assistantReply = `[Dev Mock] Executed tool "${matchedTool.name}" with result: ${typeof toolResult === "object" ? JSON.stringify(toolResult, null, 2) : String(toolResult)}`;
+          } else {
+            const toolNames = Array.from(toolMap.keys());
+            assistantReply = toolNames.length > 0 ? `[Dev Mock] Agent "${agentName || "default"}" received: "${userContent}". Discovered tools: [${toolNames.join(", ")}].` : `[Dev Mock] Echo from agent: "${userContent}".`;
+          }
+        } else {
+          for (let step = 0; step < maxSteps; step++) {
+            const aiMessages = [
+              { role: "system", content: enhancedSystemPrompt },
+              ...messages.map((m) => {
+                const msg = { role: m.role, content: m.content || "" };
+                if (m.name) msg.name = m.name;
+                if (m.toolCalls) {
+                  msg.tool_calls = m.toolCalls.map((tc) => ({
+                    id: tc.id,
+                    type: "function",
+                    function: {
+                      name: tc.name,
+                      arguments: typeof tc.arguments === "string" ? tc.arguments : JSON.stringify(tc.arguments)
+                    }
+                  }));
+                }
+                if (m.toolCallId) msg.tool_call_id = m.toolCallId;
+                return msg;
+              })
+            ];
+            const isLastStep = step === maxSteps - 1;
+            const aiOptions = {
+              messages: aiMessages
+            };
+            if (formattedTools.length > 0 && !isLastStep) {
+              aiOptions.tools = formattedTools;
+            }
+            const result = await aiBinding.run(model, aiOptions);
+            const stepReply = result?.response || "";
+            let stepToolCalls = extractToolCalls(result, stepReply);
+            if (stepToolCalls.length === 0 && stepReply.includes("<tool_call>")) {
+              stepToolCalls = extractToolCalls(null, stepReply);
+            }
+            if (stepToolCalls.length > 0) {
+              const cleanReply = cleanAssistantReply(stepReply);
+              const toolCallMsg = {
+                id: `msg_${Date.now()}_tc_${step}`,
+                role: "assistant",
+                content: cleanReply,
+                toolCalls: stepToolCalls,
+                createdAt: Date.now()
+              };
+              messages.push(toolCallMsg);
+              for (const call of stepToolCalls) {
+                const toolResult = await executeTool(call.name, call.arguments);
+                const toolResultMsg = {
+                  id: `msg_${Date.now()}_tr_${call.id}`,
+                  role: "tool",
+                  name: call.name,
+                  toolCallId: call.id,
+                  content: typeof toolResult === "string" ? toolResult : JSON.stringify(toolResult),
+                  createdAt: Date.now()
+                };
+                messages.push(toolResultMsg);
+              }
+              continue;
+            }
+            assistantReply = cleanAssistantReply(stepReply);
+            break;
+          }
+        }
+        const assistantMsg = {
+          id: `msg_${Date.now()}_a`,
+          role: "assistant",
+          content: assistantReply,
+          createdAt: Date.now()
+        };
+        messages.push(assistantMsg);
+        await this.ctx.storage.put("messages", messages);
+        return Response.json({
+          id: assistantMsg.id,
+          reply: assistantReply,
+          message: assistantMsg,
+          messages
+        });
+      }
+      return new Response("Not Found", { status: 404 });
+    } catch (err) {
+      return Response.json({ error: err?.message || "Internal Server Error" }, { status: 500 });
+    }
+  }
+}