@agent-native/core 0.14.0 → 0.14.2

package/dist/server/agent-chat-plugin.js

@@ -1,8 +1,8 @@
 import { runWithRequestContext, getRequestOrgId, getRequestUserEmail, getRequestRunContext, ensureRequestRunContext, } from "./request-context.js";
 import { getSetting, putSetting } from "../settings/store.js";
 import { getH3App, markDefaultPluginProvided, trackPluginInit, } from "./framework-request-handler.js";
-import { createProductionAgentHandler, runAgentLoop, actionsToEngineTools, getActiveRunForThreadAsync, abortRun, subscribeToRun, appendAgentLoopContinuation, isResumableEngineError, continuationReasonForResumableError, } from "../agent/production-agent.js";
-import { resolveRunSoftTimeoutMs } from "../agent/run-manager.js";
+import { createProductionAgentHandler, actionsToEngineTools, getActiveRunForThreadAsync, abortRun, subscribeToRun, } from "../agent/production-agent.js";
+import { runAgentLoopDirectWithSoftTimeout } from "../agent/run-loop-with-resume.js";
 import { resolveEngine, createAnthropicEngine, getStoredModelForEngine, } from "../agent/engine/index.js";
 import { DEFAULT_ANTHROPIC_MODEL } from "../agent/default-model.js";
 import { attachToolSearch } from "../agent/tool-search.js";
@@ -77,94 +77,6 @@ function resolveArtifactBaseUrl(event) {
     catch { }
     return undefined;
 }
-/**
- * Cap on continuation iterations inside a single runAgentLoopDirectWithSoftTimeout
- * invocation. Each iteration runs a fresh LLM call after the previous one was
- * cut off (soft timeout, gateway timeout, network blip). The host's hard
- * function timeout (e.g., Lambda's 75s) usually bounds this naturally — but
- * a defensive cap prevents an instant-error spiral from looping forever
- * inside a hosting environment with a generous budget.
- *
- * 6 leaves room for: 1 normal completion + a few resume rounds for design
- * generation (prompt + 3 variants ≈ 4 LLM calls), with a small safety margin.
- */
-const MAX_RUN_LOOP_CONTINUATIONS = 6;
-async function runAgentLoopDirectWithSoftTimeout(opts, softTimeoutMs) {
-    const timeoutMs = resolveRunSoftTimeoutMs(softTimeoutMs);
-    if (timeoutMs <= 0)
-        return runAgentLoop(opts);
-    const upstreamSignal = opts.signal;
-    const usage = {
-        inputTokens: 0,
-        outputTokens: 0,
-        cacheReadTokens: 0,
-        cacheWriteTokens: 0,
-        model: opts.model,
-    };
-    const addUsage = (next) => {
-        usage.inputTokens += next.inputTokens;
-        usage.outputTokens += next.outputTokens;
-        usage.cacheReadTokens += next.cacheReadTokens;
-        usage.cacheWriteTokens += next.cacheWriteTokens;
-        usage.model = next.model;
-    };
-    let attempts = 0;
-    while (!upstreamSignal.aborted && attempts < MAX_RUN_LOOP_CONTINUATIONS) {
-        attempts++;
-        const controller = new AbortController();
-        const abortFromUpstream = () => controller.abort();
-        if (upstreamSignal.aborted) {
-            controller.abort();
-        }
-        else {
-            upstreamSignal.addEventListener("abort", abortFromUpstream, {
-                once: true,
-            });
-        }
-        let softTimedOut = false;
-        const timer = setTimeout(() => {
-            if (controller.signal.aborted)
-                return;
-            softTimedOut = true;
-            controller.abort();
-        }, timeoutMs);
-        try {
-            const nextUsage = await runAgentLoop({
-                ...opts,
-                signal: controller.signal,
-            });
-            addUsage(nextUsage);
-            if (softTimedOut && !upstreamSignal.aborted) {
-                appendAgentLoopContinuation(opts.messages, "run_timeout");
-                continue;
-            }
-            return usage;
-        }
-        catch (err) {
-            if (softTimedOut && !upstreamSignal.aborted) {
-                appendAgentLoopContinuation(opts.messages, "run_timeout");
-                continue;
-            }
-            // Resumable transport / gateway interruptions: the LLM call was cut off
-            // mid-stream (gateway 45s timeout, socket hang up, function-level
-            // timeout that didn't trip our soft timer first). Treat it the same
-            // way as a soft timeout — append a "continue from where you left off"
-            // nudge and let the loop run another LLM call. The conversation prefix
-            // up to the cut-off is preserved in opts.messages, and Anthropic's
-            // prompt cache makes the resume call much faster.
-            if (!upstreamSignal.aborted && isResumableEngineError(err)) {
-                appendAgentLoopContinuation(opts.messages, continuationReasonForResumableError(err));
-                continue;
-            }
-            throw err;
-        }
-        finally {
-            clearTimeout(timer);
-            upstreamSignal.removeEventListener("abort", abortFromUpstream);
-        }
-    }
-    return usage;
-}
 export function assembleA2AFinalResponse(events, toolResults, options = {}) {
     const responseText = collectFinalResponseTextFromAgentEvents(events);
     const finalText = appendA2AArtifactLinks(responseText, [...toolResults], {
@@ -4093,11 +4005,40 @@ Non-code requests are still fine on this surface — read data, navigate the UI,
                 }
                 if (method === "POST") {
                     const body = await readBody(event);
-                    const thread = await createThread(owner, {
-                        id: body?.id,
-                        title: body?.title ?? "",
-                    });
-                    return thread;
+                    // Idempotent: when the caller supplies an id and a thread with
+                    // that id already exists for this owner, return it instead of
+                    // 500'ing on the UNIQUE constraint. The client can race with
+                    // the agent run's `persistSubmittedUserMessage` (which also
+                    // creates the thread on first message); we don't want either
+                    // racer's POST/onRunPrepared retry to wipe the thread out of
+                    // the user's history.
+                    if (body?.id) {
+                        const existing = await getThread(body.id);
+                        if (existing) {
+                            if (existing.ownerEmail === owner)
+                                return existing;
+                            setResponseStatus(event, 409);
+                            return { error: "Thread id already in use" };
+                        }
+                    }
+                    try {
+                        const thread = await createThread(owner, {
+                            id: body?.id,
+                            title: body?.title ?? "",
+                        });
+                        return thread;
+                    }
+                    catch (err) {
+                        // Lost the create race against another in-flight POST or
+                        // against `persistSubmittedUserMessage`. Re-fetch and
+                        // return the row that actually landed.
+                        if (body?.id) {
+                            const existing = await getThread(body.id);
+                            if (existing && existing.ownerEmail === owner)
+                                return existing;
+                        }
+                        throw err;
+                    }
                 }
                 setResponseStatus(event, 405);
                 return { error: "Method not allowed" };