@standardagents/builder 0.17.0 → 0.17.2

package/dist/index.js

@@ -917,7 +917,7 @@ function resolvePlatformRouting(providerName, env) {
 var DEFAULT_PLATFORM_PROXY_ORIGIN, PROVIDER_BASE_PATHS;
 var init_platform_routing = __esm({
   "src/agents/providers/platform-routing.ts"() {
-    DEFAULT_PLATFORM_PROXY_ORIGIN = "https://proxy.standardagents.ai";
+    DEFAULT_PLATFORM_PROXY_ORIGIN = "https://api.standardagents.ai";
     PROVIDER_BASE_PATHS = {
       cloudflare: "/ai/v1"
     };
@@ -1454,6 +1454,23 @@ function convertUsage(usage) {
     provider: usage.provider
   };
 }
+function inferProviderFromModelId(model) {
+  const trimmed = model?.trim();
+  if (!trimmed) return null;
+  const slashIndex = trimmed.indexOf("/");
+  if (slashIndex <= 0) return null;
+  return trimmed.slice(0, slashIndex);
+}
+function inferInitialActualProvider(providerName, modelDef) {
+  if (providerName !== "openrouter") return null;
+  return inferProviderFromModelId(modelDef.model);
+}
+function normalizeProviderMetadataValue(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.toLowerCase() === "unknown") return void 0;
+  return trimmed;
+}
 var NON_VISION_PLACEHOLDER_TEXT, LLMRequest;
 var init_LLMRequest = __esm({
   "src/agents/LLMRequest.ts"() {
@@ -1622,6 +1639,7 @@ var init_LLMRequest = __esm({
             console.error("Failed to get provider name:", err);
           }
           const { requestBody, visionFiltering } = buildRequestBody(context, modelDef);
+          const initialActualProvider = inferInitialActualProvider(providerName, modelDef);
           const requestBodyForLog = {
             ...requestBody,
             messages: stripBase64FromMessages(
@@ -1640,6 +1658,7 @@ var init_LLMRequest = __esm({
             id,
             message_id: state.rootMessageId || crypto.randomUUID(),
             provider: providerName || this.getProviderFromModel(modelId),
+            actual_provider: initialActualProvider ?? void 0,
             model: modelId,
             model_name: modelDef.model,
             endpoint: "chat.completions",
@@ -1660,14 +1679,15 @@ var init_LLMRequest = __esm({
               await state.storage.sql.exec(
                 `
           INSERT INTO logs (
-            id, message_id, provider, model, model_name, endpoint,
+            id, message_id, provider, actual_provider, model, model_name, endpoint,
             request_body, tools_available, message_history_length, prompt_name,
             parent_log_id, retry_of_log_id, tools_schema, system_prompt, is_complete, created_at
-          ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16)
+          ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17)
         `,
                 logData.id,
                 logData.message_id,
                 logData.provider,
+                logData.actual_provider,
                 logData.model,
                 logData.model_name,
                 logData.endpoint,
@@ -1919,7 +1939,7 @@ var init_LLMRequest = __esm({
           const calculatedCost = calculateUsageCost(response.usage, resolvedPricing);
           const providerReportedCost = typeof response.usage.cost === "number" ? response.usage.cost : typeof response.usage.cost === "string" ? parseFloat(response.usage.cost) : null;
           const cost_total = providerReportedCost != null && !Number.isNaN(providerReportedCost) ? providerReportedCost : calculatedCost?.costTotal ?? null;
-          const actualProvider = response.usage.provider;
+          const actualProvider = normalizeProviderMetadataValue(response.usage.provider) ?? null;
           const aggregateResponse = response._aggregate_response;
           const responseBody = aggregateResponse ? JSON.stringify(aggregateResponse) : JSON.stringify(response);
           const providerTools = [];
@@ -2347,8 +2367,13 @@ ${errorStack}` : ""}${errorDetails}`;
         }).catch((err) => {
           console.error("Async metadata fetch failed (non-fatal):", err);
         });
-        state.rootState.pendingMetadataPromises = state.rootState.pendingMetadataPromises || [];
-        state.rootState.pendingMetadataPromises.push(metadataPromise);
+        const rootState = state.rootState || state;
+        rootState.pendingMetadataPromises = rootState.pendingMetadataPromises || [];
+        rootState.pendingMetadataPromises.push(metadataPromise);
+        if (rootState !== state) {
+          state.pendingMetadataPromises = state.pendingMetadataPromises || [];
+          state.pendingMetadataPromises.push(metadataPromise);
+        }
       }
       /**
        * Update log record with async metadata from provider.
@@ -2358,9 +2383,12 @@ ${errorStack}` : ""}${errorDetails}`;
           const updates = [];
           const values = [];
           let paramIndex = 1;
-          if (metadata.actual_provider !== void 0) {
+          const actualProvider = normalizeProviderMetadataValue(
+            metadata.actual_provider ?? metadata.actualProvider ?? metadata.providerName
+          );
+          if (actualProvider !== void 0) {
             updates.push(`actual_provider = ?${paramIndex++}`);
-            values.push(metadata.actual_provider);
+            values.push(actualProvider);
           }
           if (metadata.generation_cost !== void 0) {
             updates.push(`cost_total = ?${paramIndex++}`);
@@ -2378,7 +2406,7 @@ ${errorStack}` : ""}${errorDetails}`;
               log_id: logId,
               data: {
                 id: logId,
-                ...metadata.actual_provider !== void 0 && { actual_provider: metadata.actual_provider },
+                ...actualProvider !== void 0 && { actual_provider: actualProvider },
                 ...metadata.generation_cost !== void 0 && { cost_total: metadata.generation_cost }
               }
             });
@@ -3104,6 +3132,11 @@ var init_ToolExecutor = __esm({
         state.sequence.queue.push(...toolCalls);
         state.sequence.isHandling = true;
         while (state.sequence.queue.length > 0) {
+          if (state.stopped) {
+            state.sequence.queue = [];
+            state.sequence.isHandling = false;
+            break;
+          }
           if (await state.thread.instance.shouldStop() || state.abortController?.signal.aborted) {
             state.sequence.queue = [];
             state.sequence.isHandling = false;
@@ -3132,7 +3165,17 @@ var init_ToolExecutor = __esm({
               });
               continue;
             }
-            const result = await this.executeToolCall(call, state, toolMessageId);
+            const previousToolCall = state.currentToolCall;
+            state.currentToolCall = {
+              id: call.id,
+              name: call.function.name
+            };
+            let result;
+            try {
+              result = await this.executeToolCall(call, state, toolMessageId);
+            } finally {
+              state.currentToolCall = previousToolCall;
+            }
             if (result.status === "error") {
               const error = new Error(result.error || "Tool execution failed");
               if (result.stack) {
@@ -5001,6 +5044,11 @@ ${attachmentPaths}`;
             }
           }
           const toolStatus = processedResult.status === "success" ? "success" : "error";
+          const parentNotifications = this.consumeParentNotificationsForToolCall(
+            state,
+            call
+          );
+          const notificationContent = parentNotifications[parentNotifications.length - 1]?.content;
           let message = {
             id: messageId,
             role: "tool",
@@ -5014,15 +5062,20 @@ ${attachmentPaths}`;
             parent_id: state.parentMessageId || null,
             depth: state.depth,
             attachments: attachmentRefs && attachmentRefs.length > 0 ? JSON.stringify(attachmentRefs) : null,
-            subagent_id: typeof processedResult.subagent_id === "string" && processedResult.subagent_id.trim().length > 0 ? processedResult.subagent_id.trim() : null
+            subagent_id: typeof processedResult.subagent_id === "string" && processedResult.subagent_id.trim().length > 0 ? processedResult.subagent_id.trim() : null,
+            metadata: parentNotifications.length > 0 ? {
+              parent_notification: true,
+              parent_notifications: parentNotifications,
+              parent_notification_content: notificationContent
+            } : void 0
           };
           message = await FlowEngine2.runBeforeCreateMessageHook(state, message);
           message.created_at = Date.now() * TIMESTAMP_MULTIPLIER;
           const currentPrompt = state.promptPath.length > 0 ? state.promptPath[state.promptPath.length - 1] : null;
           await state.storage.sql.exec(
             `
-        INSERT INTO messages (id, role, content, name, tool_call_id, created_at, tool_status, parent_id, depth, attachments, subagent_id, prompt)
-        VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12)
+        INSERT INTO messages (id, role, content, name, tool_call_id, created_at, tool_status, parent_id, depth, attachments, subagent_id, prompt, metadata)
+        VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13)
       `,
             message.id,
             message.role,
@@ -5035,7 +5088,8 @@ ${attachmentPaths}`;
             message.depth,
             message.attachments,
             message.subagent_id ?? null,
-            currentPrompt
+            currentPrompt,
+            message.metadata ? JSON.stringify(message.metadata) : null
           );
           await FlowEngine2.runAfterCreateMessageHook(state, message);
           const parentLogId = state.currentLogId || null;
@@ -5100,6 +5154,23 @@ ${attachmentPaths}`;
           await this.logError(state, error, `storeToolResult:${call.function.name}`);
         }
       }
+      static consumeParentNotificationsForToolCall(state, call) {
+        const pending = state.parentNotifications ?? [];
+        if (pending.length === 0) return [];
+        const matched = [];
+        const remaining = [];
+        for (const notification of pending) {
+          const matchesCallId = notification.toolCallId === call.id;
+          const matchesToolName = !notification.toolCallId && notification.toolName === call.function.name;
+          if (matchesCallId || matchesToolName) {
+            matched.push(notification);
+          } else {
+            remaining.push(notification);
+          }
+        }
+        state.parentNotifications = remaining;
+        return matched;
+      }
       static async createSilentGeneratedAssetPathMessagesFromToolResult(state, sourceToolMessage, refs, enabled) {
         if (!enabled || !refs || refs.length === 0) {
           return;
@@ -5561,6 +5632,8 @@ var init_FlowEngine = __esm({
           stoppedBy: state.stoppedBy,
           stopReason: state.stopReason,
           stopReasonCode: state.stopReasonCode,
+          sessionStopped: state.sessionStopped,
+          sessionStopResult: state.sessionStopResult,
           stepCount: state.stepCount,
           stream: state.stream.httpStream
         };
@@ -5760,6 +5833,8 @@ var init_FlowEngine = __esm({
           stoppedBy: stateInput.stoppedBy,
           stopReason: stateInput.stopReason,
           stopReasonCode: stateInput.stopReasonCode,
+          sessionStopped: stateInput.sessionStopped,
+          sessionStopResult: stateInput.sessionStopResult,
           messageHistory: [],
           sequence: stateInput.sequence || {
             queue: [],
@@ -11729,34 +11804,79 @@ var init_ThreadStateImpl = __esm({
         this._metadata.tenvs = nextEnv;
       }
       async notifyParent(content) {
-        if (!content || !content.trim()) {
+        const trimmedContent = content?.trim();
+        if (!trimmedContent) {
           throw new Error("notifyParent requires non-empty content");
         }
-        const { parentThreadId, parentStub } = await this._getParentThreadStub();
-        if (typeof parentStub.queueMessage !== "function") {
-          throw new Error("notifyParent is not supported by this thread runtime");
+        if (this._flowState) {
+          const currentToolCall = this._flowState.currentToolCall;
+          const notification = {
+            content: trimmedContent,
+            toolCallId: currentToolCall?.id ?? null,
+            toolName: currentToolCall?.name ?? this._flowState.active?.tool ?? null,
+            created_at: Date.now() * 1e3
+          };
+          this._flowState.parentNotifications = [
+            ...this._flowState.parentNotifications ?? [],
+            notification
+          ];
+        }
+        const parentTarget = await this._getOptionalParentThreadStub();
+        if (parentTarget && typeof parentTarget.parentStub.queueMessage === "function") {
+          await parentTarget.parentStub.queueMessage(parentTarget.parentThreadId, {
+            role: "user",
+            content: trimmedContent,
+            silent: true,
+            metadata: { subagent_id: this.threadId }
+          });
         }
-        await parentStub.queueMessage(parentThreadId, {
-          role: "user",
-          content: content.trim(),
-          silent: true,
-          metadata: { subagent_id: this.threadId }
-        });
       }
       async setStatus(status) {
         if (!status || !status.trim()) {
           throw new Error("setStatus requires non-empty status");
         }
-        const { parentThreadId, parentStub } = await this._getParentThreadStub();
-        if (typeof parentStub.updateChildRegistryStatus !== "function") {
-          throw new Error("setStatus is not supported by this thread runtime");
+        const parentTarget = await this._getOptionalParentThreadStub();
+        if (!parentTarget || typeof parentTarget.parentStub.updateChildRegistryStatus !== "function") {
+          return;
         }
-        await parentStub.updateChildRegistryStatus(
-          parentThreadId,
+        await parentTarget.parentStub.updateChildRegistryStatus(
+          parentTarget.parentThreadId,
           this.threadId,
           status.trim()
         );
       }
+      async stopSession(options = {}) {
+        if (!this._flowState) {
+          throw new Error("stopSession requires active execution");
+        }
+        const notifyParent = options.notifyParent?.trim();
+        if (options.notifyParent !== void 0 && !notifyParent) {
+          throw new Error("stopSession notifyParent requires non-empty content");
+        }
+        const status = options.status?.trim();
+        if (options.status !== void 0 && !status) {
+          throw new Error("stopSession status requires non-empty status");
+        }
+        if (notifyParent) {
+          await this.notifyParent(notifyParent);
+        }
+        if (status) {
+          await this.setStatus(status);
+        }
+        const result = options.result?.trim() || "Session stopped.";
+        this._flowState.sessionStopped = true;
+        this._flowState.sessionStopResult = result;
+        this._flowState.stopped = true;
+        this._flowState.stoppedBy = this._flowState.currentSide;
+        this._flowState.stopReason = "Session stopped by state.stopSession()";
+        this._flowState.stopReasonCode = "state_stop_session";
+        this._flowState.emitTelemetry?.({
+          type: "stopped",
+          reason: this._flowState.stopReason,
+          side: this._flowState.currentSide,
+          timestamp: Date.now()
+        });
+      }
       async getChildThread(referenceId) {
         const agentBuilder = this._getAgentBuilderStub();
         const child = await agentBuilder.getThread(referenceId);
@@ -12169,19 +12289,47 @@ var init_ThreadStateImpl = __esm({
         return Object.keys(normalized).length > 0 ? normalized : null;
       }
       async _getParentThreadId() {
+        const parent = await this._getOptionalParentThreadId();
+        if (!parent) {
+          throw new Error(`Thread ${this.threadId} has no parent thread`);
+        }
+        return parent;
+      }
+      async _getOptionalParentThreadId() {
         const metadataParent = typeof this._metadata.parent === "string" && this._metadata.parent.trim().length > 0 ? this._metadata.parent.trim() : null;
         if (metadataParent) {
           return metadataParent;
         }
-        const agentBuilder = this._getAgentBuilderStub();
-        const thread = await agentBuilder.getThread(this.threadId);
+        let thread = null;
+        try {
+          const agentBuilder = this._getAgentBuilderStub();
+          thread = await agentBuilder.getThread(this.threadId);
+        } catch {
+          return null;
+        }
         const parent = thread && typeof thread.parent === "string" && thread.parent.trim().length > 0 ? thread.parent.trim() : null;
-        if (!parent) {
-          throw new Error(`Thread ${this.threadId} has no parent thread`);
+        if (parent) {
+          this._metadata.parent = parent;
         }
-        this._metadata.parent = parent;
         return parent;
       }
+      async _getOptionalParentThreadStub() {
+        const parentThreadId = await this._getOptionalParentThreadId();
+        if (!parentThreadId) {
+          return null;
+        }
+        try {
+          const threadNamespace = this._threadInstance.env.AGENT_BUILDER_THREAD;
+          if (!threadNamespace || typeof threadNamespace.idFromName !== "function" || typeof threadNamespace.get !== "function") {
+            return null;
+          }
+          const durableId = threadNamespace.idFromName(parentThreadId);
+          const parentStub = threadNamespace.get(durableId);
+          return { parentThreadId, parentStub };
+        } catch {
+          return null;
+        }
+      }
       async _getParentThreadStub() {
         const parentThreadId = await this._getParentThreadId();
         const durableId = this._threadInstance.env.AGENT_BUILDER_THREAD.idFromName(parentThreadId);
@@ -18882,6 +19030,18 @@ function readRawRequestBody(req) {
     req.on("error", reject);
   });
 }
+function resolveContainedFile(baseDir, requestPath) {
+  const resolvedBase = path8__default.resolve(baseDir);
+  const resolved = path8__default.resolve(resolvedBase, `.${path8__default.sep}${requestPath.replace(/^\/+/, "")}`);
+  if (resolved !== resolvedBase && !resolved.startsWith(resolvedBase + path8__default.sep)) {
+    return null;
+  }
+  try {
+    return fs8__default.existsSync(resolved) && fs8__default.statSync(resolved).isFile() ? resolved : null;
+  } catch {
+    return null;
+  }
+}
 function injectUiConfigIntoHtml(htmlContent) {
   const configScript = `<script>window.__AGENTBUILDER_CONFIG__ = { devMode: true };</script>`;
   return htmlContent.replace(/\/agents\//g, "/").replace("</head>", `${configScript}</head>`);
@@ -19024,6 +19184,15 @@ function createDevMiddleware(server, context) {
       if (isStaticAsset) {
         const cleanUrl = clientPath.split("?")[0];
         filePath = path8__default.join(clientDir, cleanUrl);
+        if (!fs8__default.existsSync(filePath)) {
+          const projectPublicFile = resolveContainedFile(
+            path8__default.resolve(server.config.root, "public"),
+            cleanUrl
+          );
+          if (projectPublicFile) {
+            filePath = projectPublicFile;
+          }
+        }
       } else {
         filePath = path8__default.join(clientDir, "index.html");
       }
@@ -20320,6 +20489,27 @@ export { CodeExecutionBridge, DurableAgentBuilder, DurableThread };
         }
       }
       copyRecursive(clientDir, mountDir);
+      const projectPublicDir = path8__default.resolve(process.cwd(), "public");
+      if (fs8__default.existsSync(projectPublicDir)) {
+        let copyPublicRecursive2 = function(src, dest) {
+          const entries = fs8__default.readdirSync(src, { withFileTypes: true });
+          for (const entry of entries) {
+            const srcPath = path8__default.join(src, entry.name);
+            const destPath = path8__default.join(dest, entry.name);
+            if (entry.isDirectory()) {
+              fs8__default.mkdirSync(destPath, { recursive: true });
+              copyPublicRecursive2(srcPath, destPath);
+            } else if (fs8__default.existsSync(destPath)) {
+              console.warn(
+                `[agentbuilder] Skipping public/ file that collides with a built UI asset: ${destPath}`
+              );
+            } else {
+              fs8__default.copyFileSync(srcPath, destPath);
+            }
+          }
+        };
+        copyPublicRecursive2(projectPublicDir, mountDir);
+      }
     }
   };
   return [
@@ -22233,6 +22423,7 @@ function createEndpointThreadStateBridge(state) {
     setEnv: (propertyName, value, options) => state.setEnv(propertyName, value, options),
     notifyParent: (content) => state.notifyParent(content),
     setStatus: (status) => state.setStatus(status),
+    stopSession: (options) => state.stopSession(options),
     queueTool: (toolName, args) => state.queueTool(toolName, args),
     invokeTool: (toolName, args) => state.invokeTool(toolName, args),
     scheduleEffect: (name, args, delay) => state.scheduleEffect(name, args, delay),
@@ -23452,6 +23643,15 @@ var DurableThread = class extends DurableObject {
     const terminalToolNames = await this.getTerminalSessionToolNames(agentId);
     const sessionFailToolNames = terminalToolNames.fail;
     const hasTerminalSessionTools = terminalToolNames.all.size > 0;
+    if (flowResult.sessionStopped) {
+      await emitParentHandoffStatus("result");
+      return {
+        status: "success",
+        result: flowResult.sessionStopResult?.trim() || "Session stopped.",
+        attachments: void 0,
+        terminal: true
+      };
+    }
     const latestInRunCursor = await this.ctx.storage.sql.exec(
       `
       SELECT role, name, content, tool_status, attachments
@@ -24031,27 +24231,30 @@ ${paths.join("\n")}`;
     if (!parentThreadId || !flowResult.stopped) {
       return;
     }
+    const sessionStopped = flowResult.sessionStopped === true;
     const terminalToolNames = await this.getTerminalSessionToolNames(agentName);
     const sessionFailToolNames = terminalToolNames.fail;
     const hasTerminalSessionTools = terminalToolNames.all.size > 0;
-    const latestTerminalMessage = hasTerminalSessionTools ? await this.getLatestTerminalSessionMessageAfter(
+    const latestTerminalMessage = !sessionStopped && hasTerminalSessionTools ? await this.getLatestTerminalSessionMessageAfter(
       previousTopLevelMessageId,
       terminalToolNames.all
     ) : null;
-    const latest = latestTerminalMessage ?? await this.getLatestTopLevelMessage();
-    if (!latest && !hasTerminalSessionTools) {
+    const latest = sessionStopped ? null : latestTerminalMessage ?? await this.getLatestTopLevelMessage();
+    if (!sessionStopped && !latest && !hasTerminalSessionTools) {
       return;
     }
-    if (latest && latest.id === previousTopLevelMessageId && !hasTerminalSessionTools) {
+    if (!sessionStopped && latest && latest.id === previousTopLevelMessageId && !hasTerminalSessionTools) {
       return;
     }
     const isTerminalSessionMessage = !!latest && latest.role === "tool" && !!latest.name && terminalToolNames.all.has(latest.name);
     const isFailSessionTerminal = isTerminalSessionMessage && !!latest.name && sessionFailToolNames.has(latest.name);
     const isSuccessfulTerminalSessionMessage = isTerminalSessionMessage && latest?.tool_status !== "error";
-    const isFailureWithoutTerminalMessage = hasTerminalSessionTools && !isSuccessfulTerminalSessionMessage;
+    const isFailureWithoutTerminalMessage = !sessionStopped && hasTerminalSessionTools && !isSuccessfulTerminalSessionMessage;
     const isErrorTerminal = latest?.tool_status === "error" || isFailSessionTerminal || isFailureWithoutTerminalMessage;
     let refs = [];
-    if (hasTerminalSessionTools) {
+    if (sessionStopped) {
+      refs = [];
+    } else if (hasTerminalSessionTools) {
       refs = this.parseAttachmentRefsJson(latestTerminalMessage?.attachments ?? null) ?? [];
     } else if (latest?.attachments) {
       refs = this.parseAttachmentRefsJson(latest.attachments) ?? [];
@@ -24069,7 +24272,7 @@ ${paths.join("\n")}`;
         parentStub,
         `from-subagent-${threadId}`
       );
-      const resultContent = isFailureWithoutTerminalMessage ? this.buildMissingTerminalSessionFailure(flowResult) : latest?.content || (isErrorTerminal ? "Subagent execution failed." : "Subagent completed.");
+      const resultContent = sessionStopped ? flowResult.sessionStopResult?.trim() || "Session stopped." : isFailureWithoutTerminalMessage ? this.buildMissingTerminalSessionFailure(flowResult) : latest?.content || (isErrorTerminal ? "Subagent execution failed." : "Subagent completed.");
       const attachmentSummary = this.formatSubagentAttachmentPathSummary(copiedRefs);
       const messageContent = isErrorTerminal ? `Subagent (reference: ${threadId}) has reported a failure:
 
@@ -24085,7 +24288,7 @@ ${resultContent}${attachmentSummary}`;
           metadata: { subagent_id: threadId }
         });
       }
-      const terminalChildRun = hasTerminalSessionTools;
+      const terminalChildRun = sessionStopped || hasTerminalSessionTools;
       await parentStub.updateChildRegistryStatus(
         parentThreadId,
         threadId,