@standardagents/builder 0.11.7 → 0.11.9

package/dist/built-in-routes.js

@@ -2899,8 +2899,22 @@ ${errorLines.join("\n")}`);
           }
           const agentType = agentDef.type;
           if (agentType === "ai_human") {
+            let args2 = {};
+            try {
+              args2 = JSON.parse(call.function.arguments);
+            } catch {
+            }
+            const parentToolConfigs = state.prompt._tools || [];
+            const toolConfig = parentToolConfigs.find(
+              (t) => typeof t === "string" ? t === agentName : t.name === agentName
+            );
             state.pendingHandoff = {
-              agentId: agentName
+              agentId: agentName,
+              args: args2,
+              toolConfig: typeof toolConfig === "object" ? {
+                initUserMessageProperty: toolConfig.initUserMessageProperty,
+                initAttachmentsProperty: toolConfig.initAttachmentsProperty
+              } : void 0
             };
             const text3 = "Handoff complete";
             return {
@@ -3042,10 +3056,11 @@ ${attachmentPaths}`;
           };
           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)
-        VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)
+        INSERT INTO messages (id, role, content, name, tool_call_id, created_at, tool_status, parent_id, depth, attachments, prompt)
+        VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)
       `,
             message.id,
             message.role,
@@ -3056,7 +3071,8 @@ ${attachmentPaths}`;
             message.tool_status,
             message.parent_id,
             message.depth,
-            message.attachments
+            message.attachments,
+            currentPrompt
           );
           await FlowEngine2.runAfterCreateMessageHook(state, message);
           const parentLogId = state.currentLogId || null;
@@ -4611,13 +4627,15 @@ var init_FlowEngine = __esm({
                 status: "completed"
               };
               interruptionMessage = await this.runBeforeCreateMessageHook(state, interruptionMessage);
+              const currentPromptName = state.promptPath.length > 0 ? state.promptPath[state.promptPath.length - 1] : null;
               await state.storage.sql.exec(
-                `INSERT INTO messages (id, role, content, created_at, status) VALUES (?, ?, ?, ?, ?)`,
+                `INSERT INTO messages (id, role, content, created_at, status, prompt) VALUES (?, ?, ?, ?, ?, ?)`,
                 interruptionMessage.id,
                 interruptionMessage.role,
                 interruptionMessage.content,
                 interruptionMessage.created_at,
-                interruptionMessage.status
+                interruptionMessage.status,
+                currentPromptName
               );
               await this.runAfterCreateMessageHook(state, interruptionMessage);
               if (state.emitMessage) {
@@ -4903,8 +4921,8 @@ var init_FlowEngine = __esm({
           );
           return !hasExistingResult;
         });
-        if (toolsToExecute && toolsToExecute.length > 0) {
-          await ToolExecutor.executeSequence(state, toolsToExecute);
+        if (toolsToExecute && toolsToExecute.length > 0 || state.sequence.queue.length > 0) {
+          await ToolExecutor.executeSequence(state, toolsToExecute || []);
         }
         if (await state.thread.instance.shouldStop() || state.abortController?.signal.aborted) {
           throw new Error("aborted");
@@ -5002,10 +5020,72 @@ var init_FlowEngine = __esm({
           state.agentConfig = agentConfig;
           state.prompts.sideA = sideAPrompt;
           state.prompts.sideB = sideBPrompt;
-          state.extraMessages = [];
+          const args = state.pendingHandoff?.args || {};
+          const toolConfig = state.pendingHandoff?.toolConfig;
+          const initUserMessageProperty = toolConfig?.initUserMessageProperty;
+          const initAttachmentsProperty = toolConfig?.initAttachmentsProperty;
+          state.context = { ...state.context, ...args };
+          let userMessageContent;
+          let userMessageAttachments;
+          if (initUserMessageProperty && args[initUserMessageProperty] !== void 0) {
+            const propertyValue = args[initUserMessageProperty];
+            userMessageContent = typeof propertyValue === "string" ? propertyValue : JSON.stringify(propertyValue);
+          }
+          if (initAttachmentsProperty && args[initAttachmentsProperty] !== void 0) {
+            const attachmentValue = args[initAttachmentsProperty];
+            const attachmentPaths = Array.isArray(attachmentValue) ? attachmentValue : [attachmentValue];
+            const resolvedAttachments = [];
+            for (const attachmentPath of attachmentPaths) {
+              if (typeof attachmentPath === "string" && attachmentPath.startsWith("/attachments/")) {
+                try {
+                  const statResult = await state.thread.instance.statFile(attachmentPath);
+                  if (statResult.success && statResult.file) {
+                    resolvedAttachments.push({
+                      id: crypto.randomUUID(),
+                      type: "file",
+                      path: attachmentPath,
+                      name: statResult.file.name,
+                      mimeType: statResult.file.mimeType,
+                      width: statResult.file.width ?? void 0,
+                      height: statResult.file.height ?? void 0
+                    });
+                  }
+                } catch (e) {
+                  console.error(`[FlowEngine] Failed to resolve attachment ${attachmentPath}:`, e);
+                }
+              }
+            }
+            if (resolvedAttachments.length > 0) {
+              userMessageAttachments = JSON.stringify(resolvedAttachments);
+            }
+          }
           state.currentSide = "a";
           state.prompt = state.prompts.sideA;
           state.promptPath = [sideAPrompt.name];
+          if (userMessageContent || userMessageAttachments) {
+            const handoffMessageId = crypto.randomUUID();
+            const handoffTimestamp = Date.now() * 1e3;
+            const handoffMessage = {
+              id: handoffMessageId,
+              role: "user",
+              content: userMessageContent || "",
+              created_at: handoffTimestamp,
+              attachments: userMessageAttachments
+            };
+            await state.storage.sql.exec(
+              `INSERT INTO messages (id, role, content, attachments, created_at, prompt) VALUES (?, ?, ?, ?, ?, ?)`,
+              handoffMessage.id,
+              handoffMessage.role,
+              handoffMessage.content,
+              handoffMessage.attachments || null,
+              handoffMessage.created_at,
+              sideAPrompt.name
+            );
+            state.messageHistory.push(handoffMessage);
+            if (state.emitMessage) {
+              state.emitMessage(handoffMessage);
+            }
+          }
           state.pendingHandoff = void 0;
           state.emitTelemetry?.({
             type: "agent_handoff",
@@ -5348,26 +5428,35 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
               );
               tools.push(...selectedTools);
               const foundToolNames = new Set(selectedTools.map((t) => t.function.name));
+              const { z: z182 } = await import('zod');
               for (const toolName of regularToolNames) {
                 if (foundToolNames.has(toolName)) continue;
                 try {
                   const agentDef = await state.thread.instance.loadAgent(toolName);
                   if (agentDef && agentDef.type === "ai_human") {
+                    let parameters;
+                    const sideAPromptName = agentDef.sideA?.prompt;
+                    if (sideAPromptName) {
+                      try {
+                        const promptDef = await state.thread.instance.loadPrompt(sideAPromptName);
+                        if (promptDef.requiredSchema) {
+                          const jsonSchema = z182.toJSONSchema(promptDef.requiredSchema);
+                          parameters = {
+                            type: "object",
+                            properties: jsonSchema.properties || {},
+                            required: jsonSchema.required || []
+                          };
+                        }
+                      } catch (promptError) {
+                        console.error(`Error loading prompt schema for agent ${toolName}:`, promptError);
+                      }
+                    }
                     tools.push({
                       type: "function",
                       function: {
-                        name: agentDef.title || toolName,
+                        name: toolName,
                         description: agentDef.toolDescription || `Hand off conversation to ${agentDef.title || toolName} agent`,
-                        parameters: {
-                          type: "object",
-                          properties: {
-                            input: {
-                              type: "string",
-                              description: "Input message for the agent"
-                            }
-                          },
-                          required: ["input"]
-                        }
+                        parameters
                       }
                     });
                   }
@@ -5602,25 +5691,34 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
         const tools = [];
         try {
           const agentNames = state.thread.instance.getAgentNames();
+          const { z: z182 } = await import('zod');
           for (const name of agentNames) {
             try {
               const agentDef = await state.thread.instance.loadAgent(name);
               if (agentDef.exposeAsTool) {
+                let parameters;
+                const sideAPromptName = agentDef.sideA?.prompt;
+                if (sideAPromptName) {
+                  try {
+                    const promptDef = await state.thread.instance.loadPrompt(sideAPromptName);
+                    if (promptDef.requiredSchema) {
+                      const jsonSchema = z182.toJSONSchema(promptDef.requiredSchema);
+                      parameters = {
+                        type: "object",
+                        properties: jsonSchema.properties || {},
+                        required: jsonSchema.required || []
+                      };
+                    }
+                  } catch (promptError) {
+                    console.error(`Error loading prompt schema for agent ${name}:`, promptError);
+                  }
+                }
                 tools.push({
                   type: "function",
                   function: {
-                    name: agentDef.title || name,
+                    name,
                     description: agentDef.toolDescription || `Execute the ${agentDef.title || name} agent`,
-                    parameters: {
-                      type: "object",
-                      properties: {
-                        input: {
-                          type: "string",
-                          description: "Input message for the agent"
-                        }
-                      },
-                      required: ["input"]
-                    }
+                    parameters
                   }
                 });
               }
@@ -5874,13 +5972,14 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
         const now = Date.now() * TIMESTAMP_MULTIPLIER;
         message.created_at = now;
         message.request_sent_at = now;
+        const currentPrompt = state.promptPath.length > 0 ? state.promptPath[state.promptPath.length - 1] : null;
         await state.storage.sql.exec(
           `
       INSERT INTO messages (
         id, role, content, tool_calls, log_id, created_at,
-        request_sent_at, response_completed_at, status, parent_id, depth, reasoning_content
+        request_sent_at, response_completed_at, status, parent_id, depth, reasoning_content, prompt
       )
-      VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12)
+      VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13)
     `,
           message.id,
           message.role,
@@ -5893,8 +5992,9 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
           message.status,
           message.parent_id,
           message.depth,
-          null
+          null,
           // reasoning_content - will be set when message is updated with LLM response
+          currentPrompt
         );
         await this.runAfterCreateMessageHook(state, message);
         state.messageHistory.push(message);
@@ -6152,10 +6252,11 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
               depth: state.depth,
               attachments: JSON.stringify([attachmentRef])
             };
+            const currentPromptForAttachment = 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)
-          VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)
+          INSERT INTO messages (id, role, content, name, tool_call_id, created_at, tool_status, parent_id, depth, attachments, prompt)
+          VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)
           `,
               toolMessage.id,
               toolMessage.role,
@@ -6166,7 +6267,8 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
               toolMessage.tool_status,
               toolMessage.parent_id,
               toolMessage.depth,
-              toolMessage.attachments
+              toolMessage.attachments,
+              currentPromptForAttachment
             );
             state.messageHistory.push(toolMessage);
             if (state.emitMessage) {
@@ -6696,8 +6798,9 @@ async function injectMessage(flow, options) {
     }
     message.created_at = targetMessage.created_at - 1;
   }
+  const currentPrompt = flow.promptPath.length > 0 ? flow.promptPath[flow.promptPath.length - 1] : null;
   await flow.storage.sql.exec(
-    `INSERT INTO messages (id, role, content, name, tool_call_id, created_at, status, silent, parent_id, depth) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    `INSERT INTO messages (id, role, content, name, tool_call_id, created_at, status, silent, parent_id, depth, prompt) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
     messageId,
     message.role,
     message.content,
@@ -6707,7 +6810,8 @@ async function injectMessage(flow, options) {
     message.status,
     silent ? 1 : 0,
     message.parent_id,
-    message.depth
+    message.depth,
+    currentPrompt
   );
   if (!silent) {
     flow.messageHistory.push(message);
@@ -22712,6 +22816,26 @@ var tools_get_default = defineController(async ({ url, tools, prompts, promptNam
       })
     );
   }
+  if (agents && agentNames) {
+    await Promise.all(
+      agentNames.map(async (name) => {
+        try {
+          const loader = agents[name];
+          if (!loader) return;
+          const definition = await loader();
+          const agentToolType = definition.type === "ai_human" ? "handoff" : "subagent";
+          result[name] = {
+            description: definition.toolDescription || `Execute the ${definition.title || name} agent`,
+            schema: null,
+            hasError: false,
+            type: agentToolType
+          };
+        } catch (error) {
+          console.error(`Error loading agent ${name}:`, error);
+        }
+      })
+    );
+  }
   return Response.json(result);
 });