@standardagents/builder 0.40.9 → 0.40.11

package/dist/built-in-routes.js

@@ -445,6 +445,7 @@ var init_logBroadcast = __esm({
       "message_id",
       "provider",
       "actual_provider",
+      "standard_agents_router_used",
       "model",
       "model_name",
       "prompt_name",
@@ -455,6 +456,7 @@ var init_logBroadcast = __esm({
       "retry_of_log_id",
       "error",
       "error_type",
+      "error_origin",
       "finish_reason",
       "cost_total",
       "cost_input",
@@ -477,6 +479,71 @@ var init_logBroadcast = __esm({
     ];
   }
 });
+
+// src/agents/errorOrigin.ts
+function normalizedOrigin(value) {
+  if (typeof value !== "string") return void 0;
+  const origin = value.trim();
+  return ERROR_ORIGIN_PATTERN.test(origin) ? origin : void 0;
+}
+function normalizedUpstream(value) {
+  if (typeof value !== "string") return void 0;
+  const upstream = value.trim();
+  return upstream.length > 0 ? upstream : void 0;
+}
+function errorObject(error) {
+  return error !== null && (typeof error === "object" || typeof error === "function") ? error : null;
+}
+function resolveErrorAttribution(error, context = {}) {
+  const object161 = errorObject(error);
+  const stored = object161?.[ATTRIBUTION];
+  if (stored) return stored;
+  const taggedOrigin = normalizedOrigin(object161?.origin);
+  const provider = normalizedUpstream(object161?.upstream) ?? normalizedUpstream(context.provider);
+  const standardAgentsRouterUsed = context.viaPlatform === true;
+  if (taggedOrigin) {
+    return {
+      origin: taggedOrigin,
+      ...provider ? { upstream: provider } : {},
+      standardAgentsRouterUsed
+    };
+  }
+  if (provider) {
+    return {
+      origin: standardAgentsRouterUsed ? "platform-router" : `provider:${provider}`,
+      upstream: provider,
+      standardAgentsRouterUsed
+    };
+  }
+  return {
+    origin: context.fallback ?? "runtime",
+    standardAgentsRouterUsed
+  };
+}
+function attributeThrownError(error, context) {
+  const attributed = errorObject(error) ?? new Error(String(error));
+  const attribution = resolveErrorAttribution(attributed, context);
+  try {
+    Object.defineProperty(attributed, ATTRIBUTION, {
+      configurable: true,
+      value: attribution
+    });
+    return attributed;
+  } catch {
+    const wrapped = new Error(error instanceof Error ? error.message : String(error), {
+      cause: error
+    });
+    Object.defineProperty(wrapped, ATTRIBUTION, { value: attribution });
+    return wrapped;
+  }
+}
+var ATTRIBUTION, ERROR_ORIGIN_PATTERN;
+var init_errorOrigin = __esm({
+  "src/agents/errorOrigin.ts"() {
+    ATTRIBUTION = Symbol("standard-agents-error-attribution");
+    ERROR_ORIGIN_PATTERN = /^(?:platform-router|runtime|(?:provider|tool|hook):[A-Za-z0-9._/@-]+)$/;
+  }
+});
 var init_types2 = __esm({
   "src/agents/providers/types.ts"() {
   }
@@ -1786,6 +1853,7 @@ var init_LLMRequest = __esm({
     init_FlowEngine();
     init_toolProgress();
     init_logBroadcast();
+    init_errorOrigin();
     NON_VISION_PLACEHOLDER_TEXT = "[Image omitted: model does not support vision]";
     STREAM_FIRST_CHUNK_TIMEOUT_MS = 12e4;
     STREAM_STALL_TIMEOUT_MS = 45e3;
@@ -2083,6 +2151,7 @@ var init_LLMRequest = __esm({
           state.thread.instance,
           getThreadState
         );
+        await this.logProviderRoute(state, logId, provider.name, viaPlatform);
         const streamAbort = new AbortController();
         const parentSignal = state.abortController?.signal;
         let onParentAbort;
@@ -2096,332 +2165,370 @@ var init_LLMRequest = __esm({
         }
         const request = buildProviderRequest(context, modelDef, streamAbort.signal, state.threadId);
         let response;
-        await state.stream.waitFor(
-          async () => {
-            const requestSentAt = Date.now();
-            const firstChunkTimeoutMs = resolveStreamTimeoutMs(
-              state.env,
-              "STANDARD_AGENTS_STREAM_FIRST_CHUNK_TIMEOUT_MS",
-              STREAM_FIRST_CHUNK_TIMEOUT_MS
-            );
-            const stallTimeoutMs = resolveStreamTimeoutMs(
-              state.env,
-              "STANDARD_AGENTS_STREAM_STALL_TIMEOUT_MS",
-              STREAM_STALL_TIMEOUT_MS
-            );
-            let stalled = false;
-            const stallError = (budgetMs) => new ProviderError(
-              `Provider sent no chunk for ${Math.round(budgetMs / 1e3)}s`,
-              "timeout"
-            );
-            const awaitWithStallGuard = (work, budgetMs) => {
-              let timer;
-              work.catch(() => {
-              });
-              const timeout = new Promise((_resolve, reject) => {
-                timer = setTimeout(() => {
-                  stalled = true;
-                  reject(stallError(budgetMs));
-                  streamAbort.abort();
-                }, budgetMs);
-              });
-              return Promise.race([work, timeout]).finally(() => {
-                if (timer) clearTimeout(timer);
-              });
-            };
-            const stream = await awaitWithStallGuard(provider.stream(request), firstChunkTimeoutMs);
-            let content = "";
-            let reasoning = "";
-            let outputChars = 0;
-            let lastEmittedChars = 0;
-            const GEN_EMIT_STEP = 80;
-            const maybeEmitGeneration = () => {
-              if (outputChars - lastEmittedChars >= GEN_EMIT_STEP) {
-                lastEmittedChars = outputChars;
+        try {
+          await state.stream.waitFor(
+            async () => {
+              const requestSentAt = Date.now();
+              const firstChunkTimeoutMs = resolveStreamTimeoutMs(
+                state.env,
+                "STANDARD_AGENTS_STREAM_FIRST_CHUNK_TIMEOUT_MS",
+                STREAM_FIRST_CHUNK_TIMEOUT_MS
+              );
+              const stallTimeoutMs = resolveStreamTimeoutMs(
+                state.env,
+                "STANDARD_AGENTS_STREAM_STALL_TIMEOUT_MS",
+                STREAM_STALL_TIMEOUT_MS
+              );
+              let stalled = false;
+              const stallError = (budgetMs) => new ProviderError(
+                `Provider sent no chunk for ${Math.round(budgetMs / 1e3)}s`,
+                "timeout"
+              );
+              const awaitWithStallGuard = (work, budgetMs) => {
+                let timer;
+                work.catch(() => {
+                });
+                const timeout = new Promise((_resolve, reject) => {
+                  timer = setTimeout(() => {
+                    stalled = true;
+                    reject(stallError(budgetMs));
+                    streamAbort.abort();
+                  }, budgetMs);
+                });
+                return Promise.race([work, timeout]).finally(() => {
+                  if (timer) clearTimeout(timer);
+                });
+              };
+              const stream = await awaitWithStallGuard(provider.stream(request), firstChunkTimeoutMs);
+              let content = "";
+              let reasoning = "";
+              let outputChars = 0;
+              let lastEmittedChars = 0;
+              const GEN_EMIT_STEP = 80;
+              const maybeEmitGeneration = () => {
+                if (outputChars - lastEmittedChars >= GEN_EMIT_STEP) {
+                  lastEmittedChars = outputChars;
+                  try {
+                    state.emitEvent?.("generation", { outputTokens: Math.ceil(outputChars / 4) });
+                  } catch {
+                  }
+                }
+              };
+              const toolCallsMap = /* @__PURE__ */ new Map();
+              const images = [];
+              const webSearches = [];
+              const providerToolCalls = [];
+              let finishReason = "stop";
+              let usage;
+              let reasoningDetails;
+              let actualProvider;
+              let providerResponseId;
+              let firstChunkAt = 0;
+              let firstTokenAt = 0;
+              let lastTokenAt = 0;
+              const noteToken = () => {
+                const now = Date.now();
+                if (firstTokenAt === 0) firstTokenAt = now;
+                lastTokenAt = now;
+              };
+              const emitLogPatch = (data) => {
                 try {
-                  state.emitEvent?.("generation", { outputTokens: Math.ceil(outputChars / 4) });
+                  state.emitLog?.({ type: "log_data", log_id: logId, data: { id: logId, ...data } });
                 } catch {
                 }
-              }
-            };
-            const toolCallsMap = /* @__PURE__ */ new Map();
-            const images = [];
-            const webSearches = [];
-            const providerToolCalls = [];
-            let finishReason = "stop";
-            let usage;
-            let reasoningDetails;
-            let providerResponseId;
-            let firstChunkAt = 0;
-            let firstTokenAt = 0;
-            let lastTokenAt = 0;
-            const noteToken = () => {
-              const now = Date.now();
-              if (firstTokenAt === 0) firstTokenAt = now;
-              lastTokenAt = now;
-            };
-            const emitLogPatch = (data) => {
+              };
+              const streamedToolNames = [];
+              let lastPreviewChars = 0;
+              const PREVIEW_EMIT_STEP = 80;
+              const maybeEmitPreview = () => {
+                if (outputChars - lastPreviewChars >= PREVIEW_EMIT_STEP) {
+                  lastPreviewChars = outputChars;
+                  emitLogPatch({
+                    content: content || null,
+                    reasoning_content: reasoning || null
+                  });
+                }
+              };
+              const iterator = stream[Symbol.asyncIterator]();
               try {
-                state.emitLog?.({ type: "log_data", log_id: logId, data: { id: logId, ...data } });
-              } catch {
-              }
-            };
-            const streamedToolNames = [];
-            let lastPreviewChars = 0;
-            const PREVIEW_EMIT_STEP = 80;
-            const maybeEmitPreview = () => {
-              if (outputChars - lastPreviewChars >= PREVIEW_EMIT_STEP) {
-                lastPreviewChars = outputChars;
-                emitLogPatch({
-                  content: content || null,
-                  reasoning_content: reasoning || null
-                });
-              }
-            };
-            const iterator = stream[Symbol.asyncIterator]();
-            try {
-              while (true) {
-                if (state.abortController?.signal?.aborted) break;
-                if (await state.thread.instance.shouldStop()) break;
-                let next;
-                try {
-                  next = await awaitWithStallGuard(
-                    iterator.next(),
-                    firstChunkAt === 0 ? firstChunkTimeoutMs : stallTimeoutMs
-                  );
-                } catch (streamErr) {
-                  if (stalled) throw streamErr;
-                  if (state.abortController?.signal?.aborted || await state.thread.instance.shouldStop()) {
-                    break;
+                while (true) {
+                  if (state.abortController?.signal?.aborted) break;
+                  if (await state.thread.instance.shouldStop()) break;
+                  let next;
+                  try {
+                    next = await awaitWithStallGuard(
+                      iterator.next(),
+                      firstChunkAt === 0 ? firstChunkTimeoutMs : stallTimeoutMs
+                    );
+                  } catch (streamErr) {
+                    if (stalled) throw streamErr;
+                    if (state.abortController?.signal?.aborted || await state.thread.instance.shouldStop()) {
+                      break;
+                    }
+                    throw streamErr;
                   }
-                  throw streamErr;
-                }
-                if (next.done) break;
-                const chunk = next.value;
-                state.thread.instance.noteExecutionProgress?.();
-                if (firstChunkAt === 0 && chunkCarriesPayload(chunk)) {
-                  firstChunkAt = Date.now();
-                  emitLogPatch({ time_to_first_token_ms: firstChunkAt - requestSentAt });
-                }
-                switch (chunk.type) {
-                  case "content-delta":
-                    content += chunk.delta;
-                    state.stream.sendContent(chunk.delta);
-                    this.emitContentChunk(chunk.delta, state);
-                    outputChars += chunk.delta.length;
-                    noteToken();
-                    maybeEmitGeneration();
-                    maybeEmitPreview();
-                    break;
-                  case "reasoning-delta":
-                    reasoning += chunk.delta;
-                    this.emitReasoningChunk(chunk.delta, state);
-                    outputChars += chunk.delta.length;
-                    noteToken();
-                    maybeEmitGeneration();
-                    maybeEmitPreview();
-                    break;
-                  case "tool-call-start":
-                    {
+                  if (next.done) break;
+                  const chunk = next.value;
+                  state.thread.instance.noteExecutionProgress?.();
+                  if (firstChunkAt === 0 && chunkCarriesPayload(chunk)) {
+                    firstChunkAt = Date.now();
+                    emitLogPatch({ time_to_first_token_ms: firstChunkAt - requestSentAt });
+                  }
+                  switch (chunk.type) {
+                    case "content-delta":
+                      content += chunk.delta;
+                      state.stream.sendContent(chunk.delta);
+                      this.emitContentChunk(chunk.delta, state);
+                      outputChars += chunk.delta.length;
                       noteToken();
-                      const entry = {
-                        id: chunk.id,
-                        name: chunk.name,
-                        argumentsDelta: "",
-                        extraContent: chunk.extraContent,
-                        startedFired: false,
-                        progressArg: void 0
-                      };
-                      toolCallsMap.set(chunk.id, entry);
-                      if (chunk.name) {
-                        streamedToolNames.push(chunk.name);
-                        emitLogPatch({ tools_called: JSON.stringify(streamedToolNames) });
-                      }
-                      const progressArg = await this.resolveProgressArgument(state, chunk.name);
-                      if (progressArg) {
-                        entry.progressArg = progressArg;
-                      } else {
-                        await this.fireToolCallStarted(state, entry, void 0);
-                      }
-                    }
-                    break;
-                  case "tool-call-delta":
-                    {
-                      const tc = toolCallsMap.get(chunk.id);
-                      if (tc) {
-                        tc.argumentsDelta += chunk.argumentsDelta;
-                        outputChars += chunk.argumentsDelta.length;
+                      maybeEmitGeneration();
+                      maybeEmitPreview();
+                      break;
+                    case "reasoning-delta":
+                      reasoning += chunk.delta;
+                      this.emitReasoningChunk(chunk.delta, state);
+                      outputChars += chunk.delta.length;
+                      noteToken();
+                      maybeEmitGeneration();
+                      maybeEmitPreview();
+                      break;
+                    case "tool-call-start":
+                      {
                         noteToken();
-                        maybeEmitGeneration();
-                        if (tc.progressArg && !tc.startedFired && tc.argumentsDelta.length <= PROGRESS_ARG_SCAN_CAP) {
-                          const value = await readCompletedArg(tc.argumentsDelta, tc.progressArg);
-                          if (value !== void 0) {
-                            await this.fireToolCallStarted(state, tc, value);
+                        const entry = {
+                          id: chunk.id,
+                          name: chunk.name,
+                          argumentsDelta: "",
+                          extraContent: chunk.extraContent,
+                          startedFired: false,
+                          progressArg: void 0
+                        };
+                        toolCallsMap.set(chunk.id, entry);
+                        if (chunk.name) {
+                          streamedToolNames.push(chunk.name);
+                          emitLogPatch({ tools_called: JSON.stringify(streamedToolNames) });
+                        }
+                        const progressArg = await this.resolveProgressArgument(state, chunk.name);
+                        if (progressArg) {
+                          entry.progressArg = progressArg;
+                        } else {
+                          await this.fireToolCallStarted(state, entry, void 0);
+                        }
+                      }
+                      break;
+                    case "tool-call-delta":
+                      {
+                        const tc = toolCallsMap.get(chunk.id);
+                        if (tc) {
+                          tc.argumentsDelta += chunk.argumentsDelta;
+                          outputChars += chunk.argumentsDelta.length;
+                          noteToken();
+                          maybeEmitGeneration();
+                          if (tc.progressArg && !tc.startedFired && tc.argumentsDelta.length <= PROGRESS_ARG_SCAN_CAP) {
+                            const value = await readCompletedArg(tc.argumentsDelta, tc.progressArg);
+                            if (value !== void 0) {
+                              await this.fireToolCallStarted(state, tc, value);
+                            }
                           }
                         }
                       }
-                    }
-                    break;
-                  case "tool-call-done":
-                    {
-                      const existing = toolCallsMap.get(chunk.id);
-                      toolCallsMap.set(chunk.id, {
-                        ...existing,
-                        id: chunk.id,
-                        name: existing?.name ?? "",
-                        argumentsDelta: JSON.stringify(chunk.arguments),
-                        extraContent: chunk.extraContent ?? existing?.extraContent
+                      break;
+                    case "tool-call-done":
+                      {
+                        const existing = toolCallsMap.get(chunk.id);
+                        toolCallsMap.set(chunk.id, {
+                          ...existing,
+                          id: chunk.id,
+                          name: existing?.name ?? "",
+                          argumentsDelta: JSON.stringify(chunk.arguments),
+                          extraContent: chunk.extraContent ?? existing?.extraContent
+                        });
+                      }
+                      break;
+                    case "finish":
+                      finishReason = chunk.finishReason;
+                      usage = chunk.usage;
+                      reasoningDetails = chunk.reasoningDetails;
+                      providerResponseId = chunk.responseId;
+                      break;
+                    case "image-done":
+                      images.push({
+                        id: chunk.image.id,
+                        toolName: chunk.image.toolName,
+                        data: chunk.image.data,
+                        mediaType: chunk.image.mediaType,
+                        revisedPrompt: chunk.image.revisedPrompt
                       });
-                    }
-                    break;
-                  case "finish":
-                    finishReason = chunk.finishReason;
-                    usage = chunk.usage;
-                    reasoningDetails = chunk.reasoningDetails;
-                    providerResponseId = chunk.responseId;
-                    break;
-                  case "image-done":
-                    images.push({
-                      id: chunk.image.id,
-                      toolName: chunk.image.toolName,
-                      data: chunk.image.data,
-                      mediaType: chunk.image.mediaType,
-                      revisedPrompt: chunk.image.revisedPrompt
-                    });
-                    break;
-                  case "web-search-done":
-                    webSearches.push(chunk.result);
-                    break;
-                  case "provider-tool-done":
-                    providerToolCalls.push(chunk.tool);
-                    break;
-                  case "error":
-                    throw new ProviderError(
-                      chunk.error,
-                      chunk.code || "unknown"
+                      break;
+                    case "web-search-done":
+                      webSearches.push(chunk.result);
+                      break;
+                    case "provider-tool-done":
+                      providerToolCalls.push(chunk.tool);
+                      break;
+                    case "error":
+                      throw new ProviderError(
+                        chunk.error,
+                        chunk.code || "unknown"
+                      );
+                  }
+                }
+              } finally {
+                if (onParentAbort && parentSignal) {
+                  parentSignal.removeEventListener("abort", onParentAbort);
+                }
+                try {
+                  const cleanup = iterator.return?.();
+                  if (cleanup) {
+                    await awaitBounded(
+                      Promise.resolve(cleanup),
+                      STREAM_CLEANUP_BUDGET_MS,
+                      "stream iterator cleanup"
                     );
+                  }
+                } catch {
                 }
               }
-            } finally {
-              if (onParentAbort && parentSignal) {
-                parentSignal.removeEventListener("abort", onParentAbort);
-              }
-              try {
-                const cleanup = iterator.return?.();
-                if (cleanup) {
-                  await awaitBounded(
-                    Promise.resolve(cleanup),
-                    STREAM_CLEANUP_BUDGET_MS,
-                    "stream iterator cleanup"
-                  );
+              for (const tc of toolCallsMap.values()) {
+                if (!tc.startedFired) {
+                  const progress = tc.progressArg ? await readCompletedArg(tc.argumentsDelta, tc.progressArg) : void 0;
+                  await this.fireToolCallStarted(state, tc, progress);
                 }
-              } catch {
-              }
-            }
-            for (const tc of toolCallsMap.values()) {
-              if (!tc.startedFired) {
-                const progress = tc.progressArg ? await readCompletedArg(tc.argumentsDelta, tc.progressArg) : void 0;
-                await this.fireToolCallStarted(state, tc, progress);
-              }
-            }
-            const toolCalls = [];
-            for (const tc of toolCallsMap.values()) {
-              try {
-                toolCalls.push({
-                  id: tc.id,
-                  name: tc.name,
-                  arguments: JSON.parse(tc.argumentsDelta || "{}"),
-                  extraContent: tc.extraContent
-                });
-              } catch {
-                toolCalls.push({
-                  id: tc.id,
-                  name: tc.name,
-                  arguments: {},
-                  extraContent: tc.extraContent
-                });
-              }
-            }
-            const responseId = `res_${crypto.randomUUID().substring(0, 12)}`;
-            const responseImages = images.length > 0 ? images.map((img) => ({
-              type: "image_url",
-              id: img.id,
-              toolName: img.toolName,
-              image_url: {
-                url: img.data.startsWith("data:") ? img.data : `data:${img.mediaType};base64,${img.data}`
               }
-            })) : void 0;
-            response = {
-              id: responseId,
-              model: modelName,
-              content: content || null,
-              reasoning_content: reasoning || null,
-              reasoning_details: reasoningDetails,
-              // Include reasoning details for multi-turn context
-              tool_calls: toolCalls.length > 0 ? convertToolCalls(toolCalls) : void 0,
-              images: responseImages,
-              finish_reason: finishReason,
-              usage: usage ? convertUsage(usage) : {
-                prompt_tokens: 0,
-                completion_tokens: 0,
-                total_tokens: 0
+              const toolCalls = [];
+              for (const tc of toolCallsMap.values()) {
+                try {
+                  toolCalls.push({
+                    id: tc.id,
+                    name: tc.name,
+                    arguments: JSON.parse(tc.argumentsDelta || "{}"),
+                    extraContent: tc.extraContent
+                  });
+                } catch {
+                  toolCalls.push({
+                    id: tc.id,
+                    name: tc.name,
+                    arguments: {},
+                    extraContent: tc.extraContent
+                  });
+                }
               }
-            };
-            response._provider = provider;
-            response._viaPlatform = viaPlatform;
-            if (platformProxyOrigin) {
-              const feePercent = getObservedRouterFeePercent(platformProxyOrigin);
-              if (feePercent !== null) {
-                response._routerFeePercent = feePercent;
+              const responseId = `res_${crypto.randomUUID().substring(0, 12)}`;
+              const responseImages = images.length > 0 ? images.map((img) => ({
+                type: "image_url",
+                id: img.id,
+                toolName: img.toolName,
+                image_url: {
+                  url: img.data.startsWith("data:") ? img.data : `data:${img.mediaType};base64,${img.data}`
+                }
+              })) : void 0;
+              response = {
+                id: responseId,
+                model: modelName,
+                content: content || null,
+                reasoning_content: reasoning || null,
+                reasoning_details: reasoningDetails,
+                // Include reasoning details for multi-turn context
+                tool_calls: toolCalls.length > 0 ? convertToolCalls(toolCalls) : void 0,
+                images: responseImages,
+                finish_reason: finishReason,
+                usage: usage ? convertUsage(usage) : {
+                  prompt_tokens: 0,
+                  completion_tokens: 0,
+                  total_tokens: 0
+                }
+              };
+              response._provider = provider;
+              response._viaPlatform = viaPlatform;
+              if (platformProxyOrigin) {
+                const feePercent = getObservedRouterFeePercent(platformProxyOrigin);
+                if (feePercent !== null) {
+                  response._routerFeePercent = feePercent;
+                }
               }
+              response._providerResponseId = providerResponseId;
+              response._timing = {
+                latencyMs: firstChunkAt > 0 ? firstChunkAt - requestSentAt : null,
+                generationMs: firstTokenAt > 0 ? Math.max(0, lastTokenAt - firstTokenAt) : null
+              };
+              response._aggregate_response = {
+                id: responseId,
+                model: modelName,
+                choices: [
+                  {
+                    index: 0,
+                    message: {
+                      role: "assistant",
+                      content: content || null,
+                      reasoning_content: reasoning || null,
+                      reasoning_details: reasoningDetails,
+                      tool_calls: toolCalls.length > 0 ? convertToolCalls(toolCalls) : void 0,
+                      // Include generated images in the aggregate response
+                      // Store ID for mapping to file paths later (don't store base64 data)
+                      images: images.length > 0 ? images.map((img) => ({
+                        type: "image_url",
+                        _id: img.id,
+                        // For path lookup
+                        image_url: {
+                          url: `[image:${img.id}]`
+                          // Placeholder, will be replaced with path
+                        }
+                      })) : void 0
+                    },
+                    finish_reason: finishReason
+                  }
+                ],
+                usage: response.usage,
+                // Also store image count for quick reference
+                image_count: images.length,
+                // Store web search results for logging
+                web_searches: webSearches.length > 0 ? webSearches : void 0,
+                // Store generic provider-executed tools for logging
+                provider_tools: providerToolCalls.length > 0 ? providerToolCalls : void 0
+              };
             }
-            response._providerResponseId = providerResponseId;
-            response._timing = {
-              latencyMs: firstChunkAt > 0 ? firstChunkAt - requestSentAt : null,
-              generationMs: firstTokenAt > 0 ? Math.max(0, lastTokenAt - firstTokenAt) : null
-            };
-            response._aggregate_response = {
-              id: responseId,
-              model: modelName,
-              choices: [
-                {
-                  index: 0,
-                  message: {
-                    role: "assistant",
-                    content: content || null,
-                    reasoning_content: reasoning || null,
-                    reasoning_details: reasoningDetails,
-                    tool_calls: toolCalls.length > 0 ? convertToolCalls(toolCalls) : void 0,
-                    // Include generated images in the aggregate response
-                    // Store ID for mapping to file paths later (don't store base64 data)
-                    images: images.length > 0 ? images.map((img) => ({
-                      type: "image_url",
-                      _id: img.id,
-                      // For path lookup
-                      image_url: {
-                        url: `[image:${img.id}]`
-                        // Placeholder, will be replaced with path
-                      }
-                    })) : void 0
-                  },
-                  finish_reason: finishReason
-                }
-              ],
-              usage: response.usage,
-              // Also store image count for quick reference
-              image_count: images.length,
-              // Store web search results for logging
-              web_searches: webSearches.length > 0 ? webSearches : void 0,
-              // Store generic provider-executed tools for logging
-              provider_tools: providerToolCalls.length > 0 ? providerToolCalls : void 0
-            };
+          );
+        } catch (error) {
+          if (onParentAbort && parentSignal) {
+            parentSignal.removeEventListener("abort", onParentAbort);
           }
-        );
+          throw attributeThrownError(error, {
+            provider: provider.name,
+            viaPlatform
+          });
+        }
         if (!response) {
           throw new Error("Provider stream returned no response");
         }
         return response;
       }
+      /** Persist and broadcast provider-route attribution before any response. */
+      static async logProviderRoute(state, logId, providerName, viaPlatform) {
+        try {
+          if (!state.storage?.sql) return;
+          const upstream = viaPlatform ? providerName : null;
+          await state.storage.sql.exec(
+            `UPDATE logs
+         SET standard_agents_router_used = ?1,
+             actual_provider = COALESCE(actual_provider, ?2)
+         WHERE id = ?3`,
+            viaPlatform ? 1 : 0,
+            upstream,
+            logId
+          );
+          state.emitLog?.({
+            type: "log_data",
+            log_id: logId,
+            data: {
+              id: logId,
+              standard_agents_router_used: viaPlatform,
+              ...upstream ? { actual_provider: upstream } : {}
+            }
+          });
+        } catch (error) {
+          console.error("Failed to update provider route attribution (non-fatal):", error);
+        }
+      }
       /**
        * Emit content chunk to WebSocket for real-time UI updates
        */
@@ -2742,6 +2849,7 @@ var init_LLMRequest = __esm({
        */
       static async logError(state, error, errorType, modelId, startTime, existingLogId) {
         try {
+          const attribution = resolveErrorAttribution(error);
           let rawErrorMessage = error instanceof Error ? error.message : String(error);
           const errorStack = error instanceof Error ? error.stack : void 0;
           if (error instanceof Error && error.name === "AbortError" && /operation was aborted/i.test(rawErrorMessage)) {
@@ -2783,8 +2891,12 @@ var init_LLMRequest = __esm({
               // Parameter that caused error
               "user_id",
               // User context
-              "response"
+              "response",
               // Raw response
+              "origin",
+              // Structured error origin from ProviderError/custom providers
+              "upstream"
+              // Actual upstream behind an adapter/router
             ];
             const metadata = {};
             for (const field of relevantFields) {
@@ -2835,6 +2947,7 @@ ${errorStack}` : ""}${errorDetails}`;
                 errorsArray.push({
                   message: truncatedError,
                   type: errorType,
+                  origin: attribution.origin,
                   timestamp: Date.now()
                 });
                 await state.storage.sql.exec(
@@ -2842,20 +2955,29 @@ ${errorStack}` : ""}${errorDetails}`;
             UPDATE logs SET
               error = ?1,
               error_type = ?2,
-              errors = ?3,
-              latency_ms = ?4,
-              is_complete = ?5
-            WHERE id = ?6
+              error_origin = ?3,
+              errors = ?4,
+              latency_ms = ?5,
+              is_complete = ?6,
+              actual_provider = COALESCE(actual_provider, ?7),
+              standard_agents_router_used = CASE
+                WHEN ?8 = 1 THEN 1
+                ELSE standard_agents_router_used
+              END
+            WHERE id = ?9
           `,
                   truncatedError,
                   // Keep last error in error field for backwards compatibility
                   errorType,
                   // Keep last error type
+                  attribution.origin,
                   JSON.stringify(errorsArray),
                   // All errors in array
                   Date.now() - startTime,
                   1,
                   // is_complete = true
+                  attribution.upstream ?? null,
+                  attribution.standardAgentsRouterUsed ? 1 : 0,
                   trackedLogId
                 );
               }
@@ -2868,6 +2990,9 @@ ${errorStack}` : ""}${errorDetails}`;
                   id: trackedLogId,
                   error: truncatedError,
                   error_type: errorType,
+                  error_origin: attribution.origin,
+                  ...attribution.upstream ? { actual_provider: attribution.upstream } : {},
+                  ...attribution.standardAgentsRouterUsed ? { standard_agents_router_used: true } : {},
                   latency_ms: Date.now() - startTime,
                   is_complete: true
                 }
@@ -2884,9 +3009,12 @@ ${errorStack}` : ""}${errorDetails}`;
               id,
               message_id: messageId || "00000000-0000-0000-0000-000000000000",
               provider: this.getProviderFromModel(modelId),
+              actual_provider: attribution.upstream ?? null,
+              standard_agents_router_used: attribution.standardAgentsRouterUsed,
               model: modelId,
               error: truncatedError,
               error_type: errorType,
+              error_origin: attribution.origin,
               latency_ms: Date.now() - startTime,
               is_complete: true,
               created_at: Date.now() * TIMESTAMP_MULTIPLIER
@@ -2897,16 +3025,19 @@ ${errorStack}` : ""}${errorDetails}`;
                   await state.storage.sql.exec(
                     `
               INSERT INTO logs (
-                id, message_id, provider, model,
-                error, error_type, latency_ms, is_complete, created_at
-              ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)
+                id, message_id, provider, actual_provider, standard_agents_router_used, model,
+                error, error_type, error_origin, latency_ms, is_complete, created_at
+              ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12)
             `,
                     logData.id,
                     messageId,
                     logData.provider,
+                    logData.actual_provider,
+                    logData.standard_agents_router_used ? 1 : 0,
                     logData.model,
                     logData.error,
                     logData.error_type,
+                    logData.error_origin,
                     logData.latency_ms,
                     1,
                     logData.created_at
@@ -6489,11 +6620,13 @@ ${errorStack}` : ""}`;
         UPDATE logs
         SET
           error = ?1,
-          error_type = ?2
-        WHERE id = ?3
+          error_type = ?2,
+          error_origin = ?3
+        WHERE id = ?4
       `,
             fullError,
             "tool_execution_error",
+            `tool:${toolName}`,
             parentLogId
           );
           if (state.emitLog) {
@@ -6503,7 +6636,8 @@ ${errorStack}` : ""}`;
               data: {
                 id: parentLogId,
                 error: fullError,
-                error_type: "tool_execution_error"
+                error_type: "tool_execution_error",
+                error_origin: `tool:${toolName}`
               }
             });
           }
@@ -7000,7 +7134,7 @@ var init_FlowEngine = __esm({
           const error = "Request did not complete \u2014 the response was interrupted (the worker was evicted or the provider stalled) before it finished.";
           const errorType = "interrupted_incomplete";
           await state.storage.sql.exec(
-            `UPDATE logs SET is_complete = 1, error = ?1, error_type = ?2 WHERE is_complete = 0`,
+            `UPDATE logs SET is_complete = 1, error = ?1, error_type = ?2, error_origin = 'runtime' WHERE is_complete = 0`,
             error,
             errorType
           );
@@ -7008,7 +7142,7 @@ var init_FlowEngine = __esm({
             state.emitLog?.({
               type: "log_data",
               log_id: row.id,
-              data: { id: row.id, is_complete: true, error, error_type: errorType }
+              data: { id: row.id, is_complete: true, error, error_type: errorType, error_origin: "runtime" }
             });
           }
           console.warn(
@@ -7544,7 +7678,7 @@ This usually points to something I can't fix from here \u2014 for example the wo
             pendingMessageId
           );
           await state.storage.sql.exec(
-            `UPDATE logs SET error = ?, error_type = ? WHERE id = ?`,
+            `UPDATE logs SET error = ?, error_type = ?, error_origin = 'runtime' WHERE id = ?`,
             "Interrupted by user",
             "user_interrupted",
             logId
@@ -11087,8 +11221,8 @@ ${errorStack}` : ""}`;
             `
         INSERT INTO logs (
           id, message_id, provider, model,
-          error, error_type, created_at
-        ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)
+          error, error_type, error_origin, created_at
+        ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, 'runtime', ?7)
       `,
             crypto.randomUUID(),
             messageId,
@@ -68862,7 +68996,7 @@ var config_get_default = defineController2(async ({ config, env: env2, req }) =>
 });
 
 // src/version.ts
-var BUILDER_VERSION = "0.40.9".length > 0 ? "0.40.9" : "dev";
+var BUILDER_VERSION = "0.40.11".length > 0 ? "0.40.11" : "dev";
 
 // src/api/diagnostics.get.ts
 init_LLMRequest();