@runtypelabs/sdk 1.8.2 → 1.9.0

package/dist/index.cjs

@@ -6239,6 +6239,75 @@ Do NOT redo any of the above work.`
       (state.lastOutput || "").slice(0, 1800) || "- No final output recorded yet."
     ].join("\n");
   }
+  isAssistantToolCallMessage(message) {
+    return Boolean(message?.role === "assistant" && message.toolCalls && message.toolCalls.length > 0);
+  }
+  isToolResultMessage(message) {
+    return Boolean(message?.role === "tool" && message.toolResults && message.toolResults.length > 0);
+  }
+  /**
+   * Replay only complete adjacent tool-call/result pairs so provider validation
+   * never sees an orphaned tool result after history trimming or resume.
+   */
+  sanitizeReplayHistoryMessages(messages) {
+    const sanitized = [];
+    for (let index = 0; index < messages.length; index++) {
+      const message = messages[index];
+      if (this.isAssistantToolCallMessage(message)) {
+        const nextMessage = messages[index + 1];
+        if (!this.isToolResultMessage(nextMessage)) {
+          continue;
+        }
+        const matchedResultIds = new Set(
+          nextMessage.toolResults.filter(
+            (toolResult) => message.toolCalls.some((toolCall) => toolCall.toolCallId === toolResult.toolCallId)
+          ).map((toolResult) => toolResult.toolCallId)
+        );
+        if (matchedResultIds.size === 0) {
+          continue;
+        }
+        const matchedToolCalls = message.toolCalls.filter(
+          (toolCall) => matchedResultIds.has(toolCall.toolCallId)
+        );
+        const matchedToolResults = nextMessage.toolResults.filter(
+          (toolResult) => matchedResultIds.has(toolResult.toolCallId)
+        );
+        sanitized.push(
+          matchedToolCalls.length === message.toolCalls.length ? message : { ...message, toolCalls: matchedToolCalls }
+        );
+        sanitized.push(
+          matchedToolResults.length === nextMessage.toolResults.length ? nextMessage : { ...nextMessage, toolResults: matchedToolResults }
+        );
+        index += 1;
+        continue;
+      }
+      if (this.isToolResultMessage(message)) {
+        continue;
+      }
+      sanitized.push(message);
+    }
+    return sanitized;
+  }
+  /**
+   * Keep replay trimming on a pair boundary. If the trim cut would start on a
+   * tool-result message, slide back to include the matching assistant tool call.
+   */
+  trimReplayHistoryMessages(messages, maxMessages) {
+    if (messages.length <= maxMessages) {
+      return {
+        historyMessages: messages,
+        trimmedCount: 0
+      };
+    }
+    let startIndex = messages.length - maxMessages;
+    while (startIndex > 0 && messages[startIndex]?.role === "tool") {
+      startIndex -= 1;
+    }
+    return {
+      historyMessages: messages.slice(startIndex),
+      trimmedCount: startIndex
+    };
+  }
   /**
    * Build messages for a session, injecting progress context for continuation sessions.
    * Optionally accepts continuation context for marathon resume scenarios.
@@ -6341,6 +6410,9 @@ Do NOT redo any of the above work.`
     const candidateBlock = wf.buildCandidateBlock?.(state) ?? "";
     const multiSessionInstruction = `This is a multi-session task (session ${sessionIndex + 1}/${maxSessions}). When you have fully completed the task, end your response with TASK_COMPLETE on its own line.`;
     if (continuationContext && sessionIndex === 0) {
+      const replayHistoryMessages = this.sanitizeReplayHistoryMessages(
+        continuationContext.previousMessages
+      );
       const defaultContinueMessage = "Continue the task. Review your prior work above and proceed with any remaining work. If everything is already complete, respond with TASK_COMPLETE.";
       const userMessage = continuationContext.newUserMessage || defaultContinueMessage;
       const userContent = [
@@ -6353,7 +6425,7 @@ Do NOT redo any of the above work.`
         multiSessionInstruction
       ].join("\n");
       const fullHistoryMessages = [
-        ...continuationContext.previousMessages,
+        ...replayHistoryMessages,
         {
           role: "system",
           content: "IMPORTANT: You are continuing a previously completed task. The conversation above shows your prior work. Do NOT redo any of it. Build on what was already accomplished. If there is nothing new to do, respond with TASK_COMPLETE."
@@ -6365,7 +6437,7 @@ Do NOT redo any of the above work.`
       ];
       const summaryText = this.generateCompactSummary(state, compactInstructions);
       const breakdown = this.buildContextBudgetBreakdown({
-        historyMessages: continuationContext.previousMessages,
+        historyMessages: replayHistoryMessages,
         currentTurnContent: userContent,
         localTools: compactionOptions?.localTools,
         builtinToolSchemas: compactionOptions?.builtinToolSchemas || [],
@@ -6455,16 +6527,19 @@ Do NOT redo any of the above work.`
         "Do not redo previous work. If the task is already complete, respond with TASK_COMPLETE."
       ].join("\n");
       const MAX_HISTORY_MESSAGES = 60;
-      let historyMessages = state.messages;
+      let historyMessages = this.sanitizeReplayHistoryMessages(state.messages);
       if (historyMessages.length > MAX_HISTORY_MESSAGES) {
-        const trimmedCount = historyMessages.length - MAX_HISTORY_MESSAGES;
-        historyMessages = [
-          {
-            role: "system",
-            content: `[${trimmedCount} earlier messages trimmed to stay within context limits. Original task: ${(state.originalMessage || originalMessage).slice(0, 500)}]`
-          },
-          ...historyMessages.slice(-MAX_HISTORY_MESSAGES)
-        ];
+        const trimmedHistory = this.trimReplayHistoryMessages(historyMessages, MAX_HISTORY_MESSAGES);
+        historyMessages = trimmedHistory.historyMessages;
+        if (trimmedHistory.trimmedCount > 0) {
+          historyMessages = [
+            {
+              role: "system",
+              content: `[${trimmedHistory.trimmedCount} earlier messages trimmed to stay within context limits. Original task: ${(state.originalMessage || originalMessage).slice(0, 500)}]`
+            },
+            ...historyMessages
+          ];
+        }
       }
       const summaryText = this.generateCompactSummary(state, compactInstructions);
       const breakdown = this.buildContextBudgetBreakdown({
@@ -6726,6 +6801,42 @@ var FlowBuilder = class {
     );
     return this;
   }
+  /**
+   * Add a crawl step
+   */
+  crawl(config) {
+    this.addStep(
+      "crawl",
+      config.name,
+      {
+        url: config.url,
+        limit: config.limit,
+        depth: config.depth,
+        source: config.source,
+        formats: config.formats,
+        render: config.render,
+        maxAge: config.maxAge,
+        modifiedSince: config.modifiedSince,
+        options: config.options,
+        authenticate: config.authenticate,
+        cookies: config.cookies,
+        setExtraHTTPHeaders: config.setExtraHTTPHeaders,
+        gotoOptions: config.gotoOptions,
+        waitForSelector: config.waitForSelector,
+        rejectResourceTypes: config.rejectResourceTypes,
+        rejectRequestPattern: config.rejectRequestPattern,
+        userAgent: config.userAgent,
+        jsonOptions: config.jsonOptions,
+        outputVariable: config.outputVariable,
+        errorHandling: config.errorHandling,
+        streamOutput: config.streamOutput,
+        pollIntervalMs: config.pollIntervalMs,
+        completionTimeoutMs: config.completionTimeoutMs
+      },
+      config.enabled
+    );
+    return this;
+  }
   /**
    * Add a fetch URL step
    */
@@ -7068,7 +7179,7 @@ var ClientFlowBuilder = class extends FlowBuilder {
     this.boundClient = client;
     this.createFlow({ name });
   }
-  async run(arg1, arg2, arg3, arg4) {
+  async run(arg1, arg2, arg3, _arg4) {
     const config = this.build();
     let runOptions;
     let runCallbacks;