@inkeep/agents-run-api 0.23.4 → 0.24.0

package/dist/index.cjs

@@ -4,7 +4,6 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var agentsCore = require('@inkeep/agents-core');
 var z6 = require('zod');
-var nanoid = require('nanoid');
 var child_process = require('child_process');
 var crypto = require('crypto');
 var fs = require('fs');
@@ -192,7 +191,7 @@ async function saveA2AMessageResponse(response, params) {
     return null;
   }
   return await agentsCore.createMessage(dbClient_default)({
-    id: nanoid.nanoid(),
+    id: agentsCore.generateId(),
     tenantId: params.tenantId,
     projectId: params.projectId,
     conversationId: params.conversationId,
@@ -1704,7 +1703,7 @@ async function handleMessageSend(c, agent, request) {
     const executionContext = agentsCore.getRequestExecutionContext(c);
     const { agentId } = executionContext;
     const task = {
-      id: nanoid.nanoid(),
+      id: agentsCore.generateId(),
       input: {
         parts: params.message.parts.map((part) => ({
           kind: part.kind,
@@ -1797,7 +1796,7 @@ async function handleMessageSend(c, agent, request) {
       const messageText = params.message.parts.filter((part) => part.kind === "text" && "text" in part && part.text).map((part) => part.text).join(" ");
       try {
         const messageData = {
-          id: nanoid.nanoid(),
+          id: agentsCore.generateId(),
           tenantId: agent.tenantId,
           projectId: agent.projectId,
           conversationId: effectiveContextId,
@@ -1879,7 +1878,7 @@ async function handleMessageSend(c, agent, request) {
             },
             artifacts: [
               {
-                artifactId: nanoid.nanoid(),
+                artifactId: agentsCore.generateId(),
                 parts: [
                   {
                     kind: "data",
@@ -1908,7 +1907,7 @@ async function handleMessageSend(c, agent, request) {
     if (params.configuration?.blocking === false) {
       const taskResponse = {
         id: task.id,
-        contextId: params.message.contextId || nanoid.nanoid(),
+        contextId: params.message.contextId || agentsCore.generateId(),
         status: taskStatus,
         artifacts: result.artifacts,
         kind: "task"
@@ -1920,7 +1919,7 @@ async function handleMessageSend(c, agent, request) {
       });
     }
     const messageResponse = {
-      messageId: nanoid.nanoid(),
+      messageId: agentsCore.generateId(),
       parts: result.artifacts?.[0]?.parts || [
         {
           kind: "text",
@@ -1965,7 +1964,7 @@ async function handleMessageStream(c, agent, request) {
       });
     }
     const task = {
-      id: nanoid.nanoid(),
+      id: agentsCore.generateId(),
       input: {
         parts: params.message.parts.map((part) => ({
           kind: part.kind,
@@ -1986,7 +1985,7 @@ async function handleMessageStream(c, agent, request) {
       try {
         const initialTask = {
           id: task.id,
-          contextId: params.message.contextId || nanoid.nanoid(),
+          contextId: params.message.contextId || agentsCore.generateId(),
           status: {
             state: agentsCore.TaskState.Working,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -2034,7 +2033,7 @@ async function handleMessageStream(c, agent, request) {
           }
         }
         const messageResponse = {
-          messageId: nanoid.nanoid(),
+          messageId: agentsCore.generateId(),
           parts: result.artifacts?.[0]?.parts || [
             {
               kind: "text",
@@ -2100,14 +2099,14 @@ async function handleTasksGet(c, _agent, request) {
     const params = request.params;
     const task = {
       id: params.id,
-      contextId: nanoid.nanoid(),
+      contextId: agentsCore.generateId(),
       status: {
         state: agentsCore.TaskState.Completed,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       },
       artifacts: [
         {
-          artifactId: nanoid.nanoid(),
+          artifactId: agentsCore.generateId(),
           parts: [
             {
               kind: "text",
@@ -2206,7 +2205,7 @@ async function handleTasksResubscribe(c, agent, request) {
       try {
         const task = {
           id: params.taskId,
-          contextId: nanoid.nanoid(),
+          contextId: agentsCore.generateId(),
           status: {
             state: agentsCore.TaskState.Completed,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -2463,7 +2462,7 @@ var _ToolSessionManager = class _ToolSessionManager {
    * Create a new tool session for an agent execution
    */
   createSession(tenantId, projectId, contextId, taskId) {
-    const sessionId = nanoid.nanoid();
+    const sessionId = agentsCore.generateId();
     return this.createSessionWithId(sessionId, tenantId, projectId, contextId, taskId);
   }
   /**
@@ -5562,7 +5561,7 @@ function errorOp(message, subAgentId, severity = "error", code) {
   };
 }
 function generateToolId() {
-  return `tool_${nanoid.nanoid(8)}`;
+  return `tool_${agentsCore.generateId(8)}`;
 }
 
 // src/utils/artifact-component-schema.ts
@@ -6672,7 +6671,7 @@ function createDelegateToAgentTool({
     description: generateDelegateToolDescription(delegateConfig.config),
     inputSchema: z6__default.default.object({ message: z6__default.default.string() }),
     execute: async (input, context) => {
-      const delegationId = `del_${nanoid.nanoid()}`;
+      const delegationId = `del_${agentsCore.generateId()}`;
       const activeSpan = api.trace.getActiveSpan();
       if (activeSpan) {
         activeSpan.setAttributes({
@@ -6769,7 +6768,7 @@ function createDelegateToAgentTool({
       const messageToSend = {
         role: "agent",
         parts: [{ text: input.message, kind: "text" }],
-        messageId: nanoid.nanoid(),
+        messageId: agentsCore.generateId(),
         kind: "message",
         contextId,
         metadata: {
@@ -6784,7 +6783,7 @@ function createDelegateToAgentTool({
       };
       logger14.info({ messageToSend }, "messageToSend");
       await agentsCore.createMessage(dbClient_default)({
-        id: nanoid.nanoid(),
+        id: agentsCore.generateId(),
         tenantId,
         projectId,
         conversationId: contextId,
@@ -9149,326 +9148,334 @@ var Agent = class {
     }
   }
   async generate(userMessage, runtimeContext) {
-    return tracer.startActiveSpan("agent.generate", async (span) => {
-      const contextId = runtimeContext?.contextId || "default";
-      const taskId = runtimeContext?.metadata?.taskId || "unknown";
-      const streamRequestId = runtimeContext?.metadata?.streamRequestId;
-      const sessionId = streamRequestId || "fallback-session";
-      try {
-        this.streamRequestId = streamRequestId;
-        this.streamHelper = streamRequestId ? getStreamHelper(streamRequestId) : void 0;
-        const conversationId = runtimeContext?.metadata?.conversationId;
-        if (conversationId) {
-          this.setConversationId(conversationId);
-        }
-        const [
-          mcpTools,
-          systemPrompt,
-          thinkingSystemPrompt,
-          functionTools,
-          relationTools,
-          defaultTools
-        ] = await tracer.startActiveSpan(
-          "agent.load_tools",
-          {
-            attributes: {
-              "subAgent.name": this.config.name,
-              "session.id": sessionId
-            }
-          },
-          async (childSpan) => {
-            try {
-              const result = await Promise.all([
-                this.getMcpTools(sessionId, streamRequestId),
-                this.buildSystemPrompt(runtimeContext, false),
-                // Normal prompt with data components
-                this.buildSystemPrompt(runtimeContext, true),
-                // Thinking prompt without data components
-                this.getFunctionTools(sessionId, streamRequestId),
-                Promise.resolve(this.getRelationTools(runtimeContext, sessionId)),
-                this.getDefaultTools(streamRequestId)
-              ]);
-              childSpan.setStatus({ code: api.SpanStatusCode.OK });
-              return result;
-            } catch (err) {
-              const errorObj = err instanceof Error ? err : new Error(String(err));
-              agentsCore.setSpanWithError(childSpan, errorObj);
-              throw err;
-            } finally {
-              childSpan.end();
-            }
-          }
-        );
-        const allTools = {
-          ...mcpTools,
-          ...functionTools,
-          ...relationTools,
-          ...defaultTools
-        };
-        const sanitizedTools = this.sanitizeToolsForAISDK(allTools);
-        let conversationHistory = "";
-        const historyConfig = this.config.conversationHistoryConfig ?? createDefaultConversationHistoryConfig();
-        if (historyConfig && historyConfig.mode !== "none") {
-          if (historyConfig.mode === "full") {
-            conversationHistory = await getFormattedConversationHistory({
-              tenantId: this.config.tenantId,
-              projectId: this.config.projectId,
-              conversationId: contextId,
-              currentMessage: userMessage,
-              options: historyConfig,
-              filters: {}
-            });
-          } else if (historyConfig.mode === "scoped") {
-            conversationHistory = await getFormattedConversationHistory({
-              tenantId: this.config.tenantId,
-              projectId: this.config.projectId,
-              conversationId: contextId,
-              currentMessage: userMessage,
-              options: historyConfig,
-              filters: {
-                subAgentId: this.config.id,
-                taskId
-              }
-            });
-          }
+    return tracer.startActiveSpan(
+      "agent.generate",
+      {
+        attributes: {
+          "subagent.id": this.config.id,
+          "subagent.name": this.config.name
         }
-        const primaryModelSettings = this.getPrimaryModel();
-        const modelSettings = ModelFactory.prepareGenerationConfig(primaryModelSettings);
-        let response;
-        let textResponse;
-        const hasStructuredOutput = this.config.dataComponents && this.config.dataComponents.length > 0;
-        const shouldStreamPhase1 = this.getStreamingHelper() && !hasStructuredOutput;
-        const MAX_ALLOWED_TIMEOUT_MS = 6e5;
-        const configuredTimeout = modelSettings.maxDuration ? Math.min(modelSettings.maxDuration * 1e3, MAX_ALLOWED_TIMEOUT_MS) : shouldStreamPhase1 ? CONSTANTS.PHASE_1_TIMEOUT_MS : CONSTANTS.NON_STREAMING_PHASE_1_TIMEOUT_MS;
-        const timeoutMs = Math.min(configuredTimeout, MAX_ALLOWED_TIMEOUT_MS);
-        if (modelSettings.maxDuration && modelSettings.maxDuration * 1e3 > MAX_ALLOWED_TIMEOUT_MS) {
-          logger19.warn(
+      },
+      async (span) => {
+        const contextId = runtimeContext?.contextId || "default";
+        const taskId = runtimeContext?.metadata?.taskId || "unknown";
+        const streamRequestId = runtimeContext?.metadata?.streamRequestId;
+        const sessionId = streamRequestId || "fallback-session";
+        try {
+          this.streamRequestId = streamRequestId;
+          this.streamHelper = streamRequestId ? getStreamHelper(streamRequestId) : void 0;
+          const conversationId = runtimeContext?.metadata?.conversationId;
+          if (conversationId) {
+            this.setConversationId(conversationId);
+          }
+          const [
+            mcpTools,
+            systemPrompt,
+            thinkingSystemPrompt,
+            functionTools,
+            relationTools,
+            defaultTools
+          ] = await tracer.startActiveSpan(
+            "agent.load_tools",
             {
-              requestedTimeout: modelSettings.maxDuration * 1e3,
-              appliedTimeout: timeoutMs,
-              maxAllowed: MAX_ALLOWED_TIMEOUT_MS
-            },
-            "Requested timeout exceeded maximum allowed, capping to 10 minutes"
-          );
-        }
-        const phase1SystemPrompt = hasStructuredOutput ? thinkingSystemPrompt : systemPrompt;
-        const messages = [];
-        messages.push({ role: "system", content: phase1SystemPrompt });
-        if (conversationHistory.trim() !== "") {
-          messages.push({ role: "user", content: conversationHistory });
-        }
-        messages.push({
-          role: "user",
-          content: userMessage
-        });
-        if (shouldStreamPhase1) {
-          const streamConfig = {
-            ...modelSettings,
-            toolChoice: "auto"
-            // Allow natural text + tools
-          };
-          const streamResult = ai.streamText({
-            ...streamConfig,
-            messages,
-            tools: sanitizedTools,
-            stopWhen: async ({ steps }) => {
-              const last = steps.at(-1);
-              if (last && "text" in last && last.text) {
-                try {
-                  await agentSessionManager.recordEvent(
-                    this.getStreamRequestId(),
-                    "agent_reasoning",
-                    this.config.id,
-                    {
-                      parts: [{ type: "text", content: last.text }]
-                    }
-                  );
-                } catch (error) {
-                  logger19.debug({ error }, "Failed to track agent reasoning");
-                }
-              }
-              if (steps.length >= 2) {
-                const previousStep = steps[steps.length - 2];
-                if (previousStep && "toolCalls" in previousStep && previousStep.toolCalls) {
-                  const hasTransferCall = previousStep.toolCalls.some(
-                    (tc) => tc.toolName.startsWith("transfer_to_")
-                  );
-                  if (hasTransferCall && "toolResults" in previousStep && previousStep.toolResults) {
-                    return true;
-                  }
-                }
+              attributes: {
+                "subAgent.name": this.config.name,
+                "session.id": sessionId
               }
-              return steps.length >= this.getMaxGenerationSteps();
             },
-            experimental_telemetry: {
-              isEnabled: true,
-              functionId: this.config.id,
-              recordInputs: true,
-              recordOutputs: true
-            },
-            abortSignal: AbortSignal.timeout(timeoutMs)
-          });
-          const streamHelper = this.getStreamingHelper();
-          if (!streamHelper) {
-            throw new Error("Stream helper is unexpectedly undefined in streaming context");
-          }
-          const session = toolSessionManager.getSession(sessionId);
-          const artifactParserOptions = {
-            sessionId,
-            taskId: session?.taskId,
-            projectId: session?.projectId,
-            artifactComponents: this.artifactComponents,
-            streamRequestId: this.getStreamRequestId(),
-            subAgentId: this.config.id
-          };
-          const parser = new IncrementalStreamParser(
-            streamHelper,
-            this.config.tenantId,
-            contextId,
-            artifactParserOptions
+            async (childSpan) => {
+              try {
+                const result = await Promise.all([
+                  this.getMcpTools(sessionId, streamRequestId),
+                  this.buildSystemPrompt(runtimeContext, false),
+                  // Normal prompt with data components
+                  this.buildSystemPrompt(runtimeContext, true),
+                  // Thinking prompt without data components
+                  this.getFunctionTools(sessionId, streamRequestId),
+                  Promise.resolve(this.getRelationTools(runtimeContext, sessionId)),
+                  this.getDefaultTools(streamRequestId)
+                ]);
+                childSpan.setStatus({ code: api.SpanStatusCode.OK });
+                return result;
+              } catch (err) {
+                const errorObj = err instanceof Error ? err : new Error(String(err));
+                agentsCore.setSpanWithError(childSpan, errorObj);
+                throw err;
+              } finally {
+                childSpan.end();
+              }
+            }
           );
-          for await (const event of streamResult.fullStream) {
-            switch (event.type) {
-              case "text-delta":
-                await parser.processTextChunk(event.text);
-                break;
-              case "tool-call":
-                parser.markToolResult();
-                break;
-              case "tool-result":
-                parser.markToolResult();
-                break;
-              case "finish":
-                if (event.finishReason === "tool-calls") {
-                  parser.markToolResult();
-                }
-                break;
-              case "error":
-                if (event.error instanceof Error) {
-                  throw event.error;
-                } else {
-                  const errorMessage = event.error?.error?.message;
-                  throw new Error(errorMessage);
+          const allTools = {
+            ...mcpTools,
+            ...functionTools,
+            ...relationTools,
+            ...defaultTools
+          };
+          const sanitizedTools = this.sanitizeToolsForAISDK(allTools);
+          let conversationHistory = "";
+          const historyConfig = this.config.conversationHistoryConfig ?? createDefaultConversationHistoryConfig();
+          if (historyConfig && historyConfig.mode !== "none") {
+            if (historyConfig.mode === "full") {
+              conversationHistory = await getFormattedConversationHistory({
+                tenantId: this.config.tenantId,
+                projectId: this.config.projectId,
+                conversationId: contextId,
+                currentMessage: userMessage,
+                options: historyConfig,
+                filters: {}
+              });
+            } else if (historyConfig.mode === "scoped") {
+              conversationHistory = await getFormattedConversationHistory({
+                tenantId: this.config.tenantId,
+                projectId: this.config.projectId,
+                conversationId: contextId,
+                currentMessage: userMessage,
+                options: historyConfig,
+                filters: {
+                  subAgentId: this.config.id,
+                  taskId
                 }
+              });
             }
           }
-          await parser.finalize();
-          response = await streamResult;
-          const collectedParts = parser.getCollectedParts();
-          if (collectedParts.length > 0) {
-            response.formattedContent = {
-              parts: collectedParts.map((part) => ({
-                kind: part.kind,
-                ...part.kind === "text" && { text: part.text },
-                ...part.kind === "data" && { data: part.data }
-              }))
-            };
+          const primaryModelSettings = this.getPrimaryModel();
+          const modelSettings = ModelFactory.prepareGenerationConfig(primaryModelSettings);
+          let response;
+          let textResponse;
+          const hasStructuredOutput = this.config.dataComponents && this.config.dataComponents.length > 0;
+          const shouldStreamPhase1 = this.getStreamingHelper() && !hasStructuredOutput;
+          const MAX_ALLOWED_TIMEOUT_MS = 6e5;
+          const configuredTimeout = modelSettings.maxDuration ? Math.min(modelSettings.maxDuration * 1e3, MAX_ALLOWED_TIMEOUT_MS) : shouldStreamPhase1 ? CONSTANTS.PHASE_1_TIMEOUT_MS : CONSTANTS.NON_STREAMING_PHASE_1_TIMEOUT_MS;
+          const timeoutMs = Math.min(configuredTimeout, MAX_ALLOWED_TIMEOUT_MS);
+          if (modelSettings.maxDuration && modelSettings.maxDuration * 1e3 > MAX_ALLOWED_TIMEOUT_MS) {
+            logger19.warn(
+              {
+                requestedTimeout: modelSettings.maxDuration * 1e3,
+                appliedTimeout: timeoutMs,
+                maxAllowed: MAX_ALLOWED_TIMEOUT_MS
+              },
+              "Requested timeout exceeded maximum allowed, capping to 10 minutes"
+            );
           }
-          const streamedContent = parser.getAllStreamedContent();
-          if (streamedContent.length > 0) {
-            response.streamedContent = {
-              parts: streamedContent.map((part) => ({
-                kind: part.kind,
-                ...part.kind === "text" && { text: part.text },
-                ...part.kind === "data" && { data: part.data }
-              }))
-            };
+          const phase1SystemPrompt = hasStructuredOutput ? thinkingSystemPrompt : systemPrompt;
+          const messages = [];
+          messages.push({ role: "system", content: phase1SystemPrompt });
+          if (conversationHistory.trim() !== "") {
+            messages.push({ role: "user", content: conversationHistory });
           }
-        } else {
-          let genConfig;
-          if (hasStructuredOutput) {
-            genConfig = {
-              ...modelSettings,
-              toolChoice: "required"
-              // Force tool usage, prevent text generation
-            };
-          } else {
-            genConfig = {
+          messages.push({
+            role: "user",
+            content: userMessage
+          });
+          if (shouldStreamPhase1) {
+            const streamConfig = {
               ...modelSettings,
               toolChoice: "auto"
-              // Allow both tools and text generation
+              // Allow natural text + tools
             };
-          }
-          response = await ai.generateText({
-            ...genConfig,
-            messages,
-            tools: sanitizedTools,
-            stopWhen: async ({ steps }) => {
-              const last = steps.at(-1);
-              if (last && "text" in last && last.text) {
-                try {
-                  await agentSessionManager.recordEvent(
-                    this.getStreamRequestId(),
-                    "agent_reasoning",
-                    this.config.id,
-                    {
-                      parts: [{ type: "text", content: last.text }]
-                    }
-                  );
-                } catch (error) {
-                  logger19.debug({ error }, "Failed to track agent reasoning");
+            const streamResult = ai.streamText({
+              ...streamConfig,
+              messages,
+              tools: sanitizedTools,
+              stopWhen: async ({ steps }) => {
+                const last = steps.at(-1);
+                if (last && "text" in last && last.text) {
+                  try {
+                    await agentSessionManager.recordEvent(
+                      this.getStreamRequestId(),
+                      "agent_reasoning",
+                      this.config.id,
+                      {
+                        parts: [{ type: "text", content: last.text }]
+                      }
+                    );
+                  } catch (error) {
+                    logger19.debug({ error }, "Failed to track agent reasoning");
+                  }
                 }
-              }
-              if (steps.length >= 2) {
-                const previousStep = steps[steps.length - 2];
-                if (previousStep && "toolCalls" in previousStep && previousStep.toolCalls) {
-                  const hasStopTool = previousStep.toolCalls.some(
-                    (tc) => tc.toolName.startsWith("transfer_to_") || tc.toolName === "thinking_complete"
-                  );
-                  if (hasStopTool && "toolResults" in previousStep && previousStep.toolResults) {
-                    return true;
+                if (steps.length >= 2) {
+                  const previousStep = steps[steps.length - 2];
+                  if (previousStep && "toolCalls" in previousStep && previousStep.toolCalls) {
+                    const hasTransferCall = previousStep.toolCalls.some(
+                      (tc) => tc.toolName.startsWith("transfer_to_")
+                    );
+                    if (hasTransferCall && "toolResults" in previousStep && previousStep.toolResults) {
+                      return true;
+                    }
                   }
                 }
+                return steps.length >= this.getMaxGenerationSteps();
+              },
+              experimental_telemetry: {
+                isEnabled: true,
+                functionId: this.config.id,
+                recordInputs: true,
+                recordOutputs: true
+              },
+              abortSignal: AbortSignal.timeout(timeoutMs)
+            });
+            const streamHelper = this.getStreamingHelper();
+            if (!streamHelper) {
+              throw new Error("Stream helper is unexpectedly undefined in streaming context");
+            }
+            const session = toolSessionManager.getSession(sessionId);
+            const artifactParserOptions = {
+              sessionId,
+              taskId: session?.taskId,
+              projectId: session?.projectId,
+              artifactComponents: this.artifactComponents,
+              streamRequestId: this.getStreamRequestId(),
+              subAgentId: this.config.id
+            };
+            const parser = new IncrementalStreamParser(
+              streamHelper,
+              this.config.tenantId,
+              contextId,
+              artifactParserOptions
+            );
+            for await (const event of streamResult.fullStream) {
+              switch (event.type) {
+                case "text-delta":
+                  await parser.processTextChunk(event.text);
+                  break;
+                case "tool-call":
+                  parser.markToolResult();
+                  break;
+                case "tool-result":
+                  parser.markToolResult();
+                  break;
+                case "finish":
+                  if (event.finishReason === "tool-calls") {
+                    parser.markToolResult();
+                  }
+                  break;
+                case "error":
+                  if (event.error instanceof Error) {
+                    throw event.error;
+                  } else {
+                    const errorMessage = event.error?.error?.message;
+                    throw new Error(errorMessage);
+                  }
               }
-              return steps.length >= this.getMaxGenerationSteps();
-            },
-            experimental_telemetry: {
-              isEnabled: true,
-              functionId: this.config.id,
-              recordInputs: true,
-              recordOutputs: true,
-              metadata: {
-                phase: "planning"
-              }
-            },
-            abortSignal: AbortSignal.timeout(timeoutMs)
-          });
-        }
-        if (response.steps) {
-          const resolvedSteps = await response.steps;
-          response = { ...response, steps: resolvedSteps };
-        }
-        if (hasStructuredOutput && !hasToolCallWithPrefix("transfer_to_")(response)) {
-          const thinkingCompleteCall = response.steps?.flatMap((s) => s.toolCalls || [])?.find((tc) => tc.toolName === "thinking_complete");
-          if (thinkingCompleteCall) {
-            const reasoningFlow = [];
-            if (response.steps) {
-              response.steps.forEach((step) => {
-                if (step.toolCalls && step.toolResults) {
-                  step.toolCalls.forEach((call, index) => {
-                    const result = step.toolResults[index];
-                    if (result) {
-                      const storedResult = toolSessionManager.getToolResult(
-                        sessionId,
-                        result.toolCallId
-                      );
-                      const toolName = storedResult?.toolName || call.toolName;
-                      if (toolName === "thinking_complete") {
-                        return;
+            }
+            await parser.finalize();
+            response = await streamResult;
+            const collectedParts = parser.getCollectedParts();
+            if (collectedParts.length > 0) {
+              response.formattedContent = {
+                parts: collectedParts.map((part) => ({
+                  kind: part.kind,
+                  ...part.kind === "text" && { text: part.text },
+                  ...part.kind === "data" && { data: part.data }
+                }))
+              };
+            }
+            const streamedContent = parser.getAllStreamedContent();
+            if (streamedContent.length > 0) {
+              response.streamedContent = {
+                parts: streamedContent.map((part) => ({
+                  kind: part.kind,
+                  ...part.kind === "text" && { text: part.text },
+                  ...part.kind === "data" && { data: part.data }
+                }))
+              };
+            }
+          } else {
+            let genConfig;
+            if (hasStructuredOutput) {
+              genConfig = {
+                ...modelSettings,
+                toolChoice: "required"
+                // Force tool usage, prevent text generation
+              };
+            } else {
+              genConfig = {
+                ...modelSettings,
+                toolChoice: "auto"
+                // Allow both tools and text generation
+              };
+            }
+            response = await ai.generateText({
+              ...genConfig,
+              messages,
+              tools: sanitizedTools,
+              stopWhen: async ({ steps }) => {
+                const last = steps.at(-1);
+                if (last && "text" in last && last.text) {
+                  try {
+                    await agentSessionManager.recordEvent(
+                      this.getStreamRequestId(),
+                      "agent_reasoning",
+                      this.config.id,
+                      {
+                        parts: [{ type: "text", content: last.text }]
                       }
-                      const actualResult = storedResult?.result || result.result || result;
-                      const actualArgs = storedResult?.args || call.args;
-                      const cleanResult = actualResult && typeof actualResult === "object" && !Array.isArray(actualResult) ? Object.fromEntries(
-                        Object.entries(actualResult).filter(
-                          ([key]) => key !== "_structureHints"
-                        )
-                      ) : actualResult;
-                      const input = actualArgs ? JSON.stringify(actualArgs, null, 2) : "No input";
-                      const output = typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, null, 2);
-                      let structureHintsFormatted = "";
-                      if (actualResult?._structureHints && this.artifactComponents && this.artifactComponents.length > 0) {
-                        const hints = actualResult._structureHints;
-                        structureHintsFormatted = `
+                    );
+                  } catch (error) {
+                    logger19.debug({ error }, "Failed to track agent reasoning");
+                  }
+                }
+                if (steps.length >= 2) {
+                  const previousStep = steps[steps.length - 2];
+                  if (previousStep && "toolCalls" in previousStep && previousStep.toolCalls) {
+                    const hasStopTool = previousStep.toolCalls.some(
+                      (tc) => tc.toolName.startsWith("transfer_to_") || tc.toolName === "thinking_complete"
+                    );
+                    if (hasStopTool && "toolResults" in previousStep && previousStep.toolResults) {
+                      return true;
+                    }
+                  }
+                }
+                return steps.length >= this.getMaxGenerationSteps();
+              },
+              experimental_telemetry: {
+                isEnabled: true,
+                functionId: this.config.id,
+                recordInputs: true,
+                recordOutputs: true,
+                metadata: {
+                  phase: "planning"
+                }
+              },
+              abortSignal: AbortSignal.timeout(timeoutMs)
+            });
+          }
+          if (response.steps) {
+            const resolvedSteps = await response.steps;
+            response = { ...response, steps: resolvedSteps };
+          }
+          if (hasStructuredOutput && !hasToolCallWithPrefix("transfer_to_")(response)) {
+            const thinkingCompleteCall = response.steps?.flatMap((s) => s.toolCalls || [])?.find((tc) => tc.toolName === "thinking_complete");
+            if (thinkingCompleteCall) {
+              const reasoningFlow = [];
+              if (response.steps) {
+                response.steps.forEach((step) => {
+                  if (step.toolCalls && step.toolResults) {
+                    step.toolCalls.forEach((call, index) => {
+                      const result = step.toolResults[index];
+                      if (result) {
+                        const storedResult = toolSessionManager.getToolResult(
+                          sessionId,
+                          result.toolCallId
+                        );
+                        const toolName = storedResult?.toolName || call.toolName;
+                        if (toolName === "thinking_complete") {
+                          return;
+                        }
+                        const actualResult = storedResult?.result || result.result || result;
+                        const actualArgs = storedResult?.args || call.args;
+                        const cleanResult = actualResult && typeof actualResult === "object" && !Array.isArray(actualResult) ? Object.fromEntries(
+                          Object.entries(actualResult).filter(
+                            ([key]) => key !== "_structureHints"
+                          )
+                        ) : actualResult;
+                        const input = actualArgs ? JSON.stringify(actualArgs, null, 2) : "No input";
+                        const output = typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, null, 2);
+                        let structureHintsFormatted = "";
+                        if (actualResult?._structureHints && this.artifactComponents && this.artifactComponents.length > 0) {
+                          const hints = actualResult._structureHints;
+                          structureHintsFormatted = `
 ### \u{1F4CA} Structure Hints for Artifact Creation
 
 **Terminal Field Paths (${hints.terminalPaths?.length || 0} found):**
@@ -9492,8 +9499,8 @@ ${hints.commonFields?.map((field) => `  \u2022 ${field}`).join("\n") || "  None
 
 **Forbidden Syntax:** ${hints.forbiddenSyntax || "Use these paths for artifact base selectors."}
 `;
-                      }
-                      const formattedResult = `## Tool: ${call.toolName}
+                        }
+                        const formattedResult = `## Tool: ${call.toolName}
 
 ### \u{1F527} TOOL_CALL_ID: ${result.toolCallId}
 
@@ -9502,130 +9509,61 @@ ${input}
 
 ### Output
 ${output}${structureHintsFormatted}`;
-                      reasoningFlow.push({
-                        role: "assistant",
-                        content: formattedResult
-                      });
-                    }
-                  });
-                }
-              });
-            }
-            const componentSchemas = [];
-            if (this.config.dataComponents && this.config.dataComponents.length > 0) {
-              this.config.dataComponents.forEach((dc) => {
-                const propsSchema = jsonSchemaToZod(dc.props);
-                componentSchemas.push(
-                  z6.z.object({
-                    id: z6.z.string(),
-                    name: z6.z.literal(dc.name),
-                    props: propsSchema
-                  })
-                );
-              });
-            }
-            if (this.artifactComponents.length > 0) {
-              const artifactCreateSchemas = ArtifactCreateSchema.getSchemas(
-                this.artifactComponents
-              );
-              componentSchemas.push(...artifactCreateSchemas);
-              componentSchemas.push(ArtifactReferenceSchema.getSchema());
-            }
-            let dataComponentsSchema;
-            if (componentSchemas.length === 1) {
-              dataComponentsSchema = componentSchemas[0];
-            } else {
-              dataComponentsSchema = z6.z.union(
-                componentSchemas
-              );
-            }
-            const structuredModelSettings = ModelFactory.prepareGenerationConfig(
-              this.getStructuredOutputModel()
-            );
-            const phase2TimeoutMs = structuredModelSettings.maxDuration ? structuredModelSettings.maxDuration * 1e3 : CONSTANTS.PHASE_2_TIMEOUT_MS;
-            const shouldStreamPhase2 = this.getStreamingHelper();
-            if (shouldStreamPhase2) {
-              const phase2Messages = [
-                {
-                  role: "system",
-                  content: await this.buildPhase2SystemPrompt(runtimeContext)
-                }
-              ];
-              if (conversationHistory.trim() !== "") {
-                phase2Messages.push({ role: "user", content: conversationHistory });
-              }
-              phase2Messages.push({ role: "user", content: userMessage });
-              phase2Messages.push(...reasoningFlow);
-              const streamResult = ai.streamObject({
-                ...structuredModelSettings,
-                messages: phase2Messages,
-                schema: z6.z.object({
-                  dataComponents: z6.z.array(dataComponentsSchema)
-                }),
-                experimental_telemetry: {
-                  isEnabled: true,
-                  functionId: this.config.id,
-                  recordInputs: true,
-                  recordOutputs: true,
-                  metadata: {
-                    phase: "structured_generation"
+                        reasoningFlow.push({
+                          role: "assistant",
+                          content: formattedResult
+                        });
+                      }
+                    });
                   }
-                },
-                abortSignal: AbortSignal.timeout(phase2TimeoutMs)
-              });
-              const streamHelper = this.getStreamingHelper();
-              if (!streamHelper) {
-                throw new Error("Stream helper is unexpectedly undefined in streaming context");
+                });
               }
-              const session = toolSessionManager.getSession(sessionId);
-              const artifactParserOptions = {
-                sessionId,
-                taskId: session?.taskId,
-                projectId: session?.projectId,
-                artifactComponents: this.artifactComponents,
-                streamRequestId: this.getStreamRequestId(),
-                subAgentId: this.config.id
-              };
-              const parser = new IncrementalStreamParser(
-                streamHelper,
-                this.config.tenantId,
-                contextId,
-                artifactParserOptions
-              );
-              for await (const delta of streamResult.partialObjectStream) {
-                if (delta) {
-                  await parser.processObjectDelta(delta);
-                }
+              const componentSchemas = [];
+              if (this.config.dataComponents && this.config.dataComponents.length > 0) {
+                this.config.dataComponents.forEach((dc) => {
+                  const propsSchema = jsonSchemaToZod(dc.props);
+                  componentSchemas.push(
+                    z6.z.object({
+                      id: z6.z.string(),
+                      name: z6.z.literal(dc.name),
+                      props: propsSchema
+                    })
+                  );
+                });
               }
-              await parser.finalize();
-              const structuredResponse = await streamResult;
-              const collectedParts = parser.getCollectedParts();
-              if (collectedParts.length > 0) {
-                response.formattedContent = {
-                  parts: collectedParts.map((part) => ({
-                    kind: part.kind,
-                    ...part.kind === "text" && { text: part.text },
-                    ...part.kind === "data" && { data: part.data }
-                  }))
-                };
+              if (this.artifactComponents.length > 0) {
+                const artifactCreateSchemas = ArtifactCreateSchema.getSchemas(
+                  this.artifactComponents
+                );
+                componentSchemas.push(...artifactCreateSchemas);
+                componentSchemas.push(ArtifactReferenceSchema.getSchema());
               }
-              response = {
-                ...response,
-                object: structuredResponse.object
-              };
-              textResponse = JSON.stringify(structuredResponse.object, null, 2);
-            } else {
-              const { withJsonPostProcessing: withJsonPostProcessing2 } = await Promise.resolve().then(() => (init_json_postprocessor(), json_postprocessor_exports));
-              const phase2Messages = [
-                { role: "system", content: await this.buildPhase2SystemPrompt(runtimeContext) }
-              ];
-              if (conversationHistory.trim() !== "") {
-                phase2Messages.push({ role: "user", content: conversationHistory });
+              let dataComponentsSchema;
+              if (componentSchemas.length === 1) {
+                dataComponentsSchema = componentSchemas[0];
+              } else {
+                dataComponentsSchema = z6.z.union(
+                  componentSchemas
+                );
               }
-              phase2Messages.push({ role: "user", content: userMessage });
-              phase2Messages.push(...reasoningFlow);
-              const structuredResponse = await ai.generateObject(
-                withJsonPostProcessing2({
+              const structuredModelSettings = ModelFactory.prepareGenerationConfig(
+                this.getStructuredOutputModel()
+              );
+              const phase2TimeoutMs = structuredModelSettings.maxDuration ? structuredModelSettings.maxDuration * 1e3 : CONSTANTS.PHASE_2_TIMEOUT_MS;
+              const shouldStreamPhase2 = this.getStreamingHelper();
+              if (shouldStreamPhase2) {
+                const phase2Messages = [
+                  {
+                    role: "system",
+                    content: await this.buildPhase2SystemPrompt(runtimeContext)
+                  }
+                ];
+                if (conversationHistory.trim() !== "") {
+                  phase2Messages.push({ role: "user", content: conversationHistory });
+                }
+                phase2Messages.push({ role: "user", content: userMessage });
+                phase2Messages.push(...reasoningFlow);
+                const streamResult = ai.streamObject({
                   ...structuredModelSettings,
                   messages: phase2Messages,
                   schema: z6.z.object({
@@ -9641,65 +9579,135 @@ ${output}${structureHintsFormatted}`;
                     }
                   },
                   abortSignal: AbortSignal.timeout(phase2TimeoutMs)
-                })
-              );
-              response = {
-                ...response,
-                object: structuredResponse.object
-              };
-              textResponse = JSON.stringify(structuredResponse.object, null, 2);
+                });
+                const streamHelper = this.getStreamingHelper();
+                if (!streamHelper) {
+                  throw new Error("Stream helper is unexpectedly undefined in streaming context");
+                }
+                const session = toolSessionManager.getSession(sessionId);
+                const artifactParserOptions = {
+                  sessionId,
+                  taskId: session?.taskId,
+                  projectId: session?.projectId,
+                  artifactComponents: this.artifactComponents,
+                  streamRequestId: this.getStreamRequestId(),
+                  subAgentId: this.config.id
+                };
+                const parser = new IncrementalStreamParser(
+                  streamHelper,
+                  this.config.tenantId,
+                  contextId,
+                  artifactParserOptions
+                );
+                for await (const delta of streamResult.partialObjectStream) {
+                  if (delta) {
+                    await parser.processObjectDelta(delta);
+                  }
+                }
+                await parser.finalize();
+                const structuredResponse = await streamResult;
+                const collectedParts = parser.getCollectedParts();
+                if (collectedParts.length > 0) {
+                  response.formattedContent = {
+                    parts: collectedParts.map((part) => ({
+                      kind: part.kind,
+                      ...part.kind === "text" && { text: part.text },
+                      ...part.kind === "data" && { data: part.data }
+                    }))
+                  };
+                }
+                response = {
+                  ...response,
+                  object: structuredResponse.object
+                };
+                textResponse = JSON.stringify(structuredResponse.object, null, 2);
+              } else {
+                const { withJsonPostProcessing: withJsonPostProcessing2 } = await Promise.resolve().then(() => (init_json_postprocessor(), json_postprocessor_exports));
+                const phase2Messages = [
+                  { role: "system", content: await this.buildPhase2SystemPrompt(runtimeContext) }
+                ];
+                if (conversationHistory.trim() !== "") {
+                  phase2Messages.push({ role: "user", content: conversationHistory });
+                }
+                phase2Messages.push({ role: "user", content: userMessage });
+                phase2Messages.push(...reasoningFlow);
+                const structuredResponse = await ai.generateObject(
+                  withJsonPostProcessing2({
+                    ...structuredModelSettings,
+                    messages: phase2Messages,
+                    schema: z6.z.object({
+                      dataComponents: z6.z.array(dataComponentsSchema)
+                    }),
+                    experimental_telemetry: {
+                      isEnabled: true,
+                      functionId: this.config.id,
+                      recordInputs: true,
+                      recordOutputs: true,
+                      metadata: {
+                        phase: "structured_generation"
+                      }
+                    },
+                    abortSignal: AbortSignal.timeout(phase2TimeoutMs)
+                  })
+                );
+                response = {
+                  ...response,
+                  object: structuredResponse.object
+                };
+                textResponse = JSON.stringify(structuredResponse.object, null, 2);
+              }
+            } else {
+              textResponse = response.text || "";
             }
           } else {
-            textResponse = response.text || "";
+            textResponse = response.steps[response.steps.length - 1].text || "";
           }
-        } else {
-          textResponse = response.steps[response.steps.length - 1].text || "";
-        }
-        span.setStatus({ code: api.SpanStatusCode.OK });
-        span.end();
-        let formattedContent = response.formattedContent || null;
-        if (!formattedContent) {
-          const session = toolSessionManager.getSession(sessionId);
-          const responseFormatter = new ResponseFormatter(this.config.tenantId, {
-            sessionId,
-            taskId: session?.taskId,
-            projectId: session?.projectId,
-            contextId,
-            artifactComponents: this.artifactComponents,
-            streamRequestId: this.getStreamRequestId(),
-            subAgentId: this.config.id
-          });
-          if (response.object) {
-            formattedContent = await responseFormatter.formatObjectResponse(
-              response.object,
-              contextId
-            );
-          } else if (textResponse) {
-            formattedContent = await responseFormatter.formatResponse(textResponse, contextId);
+          span.setStatus({ code: api.SpanStatusCode.OK });
+          span.end();
+          let formattedContent = response.formattedContent || null;
+          if (!formattedContent) {
+            const session = toolSessionManager.getSession(sessionId);
+            const responseFormatter = new ResponseFormatter(this.config.tenantId, {
+              sessionId,
+              taskId: session?.taskId,
+              projectId: session?.projectId,
+              contextId,
+              artifactComponents: this.artifactComponents,
+              streamRequestId: this.getStreamRequestId(),
+              subAgentId: this.config.id
+            });
+            if (response.object) {
+              formattedContent = await responseFormatter.formatObjectResponse(
+                response.object,
+                contextId
+              );
+            } else if (textResponse) {
+              formattedContent = await responseFormatter.formatResponse(textResponse, contextId);
+            }
           }
+          const formattedResponse = {
+            ...response,
+            formattedContent
+          };
+          if (streamRequestId) {
+            const generationType = response.object ? "object_generation" : "text_generation";
+            agentSessionManager.recordEvent(streamRequestId, "agent_generate", this.config.id, {
+              parts: (formattedContent?.parts || []).map((part) => ({
+                type: part.kind === "text" ? "text" : part.kind === "data" ? "tool_result" : "text",
+                content: part.text || JSON.stringify(part.data)
+              })),
+              generationType
+            });
+          }
+          return formattedResponse;
+        } catch (error) {
+          const errorToThrow = error instanceof Error ? error : new Error(String(error));
+          agentsCore.setSpanWithError(span, errorToThrow);
+          span.end();
+          throw errorToThrow;
         }
-        const formattedResponse = {
-          ...response,
-          formattedContent
-        };
-        if (streamRequestId) {
-          const generationType = response.object ? "object_generation" : "text_generation";
-          agentSessionManager.recordEvent(streamRequestId, "agent_generate", this.config.id, {
-            parts: (formattedContent?.parts || []).map((part) => ({
-              type: part.kind === "text" ? "text" : part.kind === "data" ? "tool_result" : "text",
-              content: part.text || JSON.stringify(part.data)
-            })),
-            generationType
-          });
-        }
-        return formattedResponse;
-      } catch (error) {
-        const errorToThrow = error instanceof Error ? error : new Error(String(error));
-        agentsCore.setSpanWithError(span, errorToThrow);
-        span.end();
-        throw errorToThrow;
       }
-    });
+    );
   }
 };
 
@@ -9990,7 +9998,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
                 },
                 artifacts: [
                   {
-                    artifactId: nanoid.nanoid(),
+                    artifactId: agentsCore.generateId(),
                     parts: [
                       {
                         kind: "data",
@@ -10023,7 +10031,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
         status: { state: agentsCore.TaskState.Completed },
         artifacts: [
           {
-            artifactId: nanoid.nanoid(),
+            artifactId: agentsCore.generateId(),
             parts
           }
         ]
@@ -11366,7 +11374,7 @@ var ExecutionHandler = class {
                 "ai.subAgent.name": currentAgentId
               });
               await agentsCore.createMessage(dbClient_default)({
-                id: nanoid.nanoid(),
+                id: agentsCore.generateId(),
                 tenantId,
                 projectId,
                 conversationId,
@@ -11756,7 +11764,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
         });
       }
       await agentsCore.createMessage(dbClient_default)({
-        id: nanoid.nanoid(),
+        id: agentsCore.generateId(),
         tenantId,
         projectId,
         conversationId,
@@ -11989,7 +11997,7 @@ app3.openapi(chatDataStreamRoute, async (c) => {
         });
       }
       await agentsCore.createMessage(dbClient_default)({
-        id: nanoid.nanoid(),
+        id: agentsCore.generateId(),
         tenantId,
         projectId,
         conversationId,
@@ -12445,7 +12453,7 @@ var processUserMessage = async (tenantId, projectId, conversationId, query) => {
     });
   }
   await agentsCore.createMessage(dbClient_default)({
-    id: nanoid.nanoid(),
+    id: agentsCore.generateId(),
     tenantId,
     projectId,
     conversationId,