@tanstack/ai-anthropic 0.8.6 → 0.8.8

package/dist/esm/adapters/text.js

@@ -1,8 +1,8 @@
+import { EventType } from "@tanstack/ai";
 import { BaseTextAdapter } from "@tanstack/ai/adapters";
 import { convertToolsToProviderFormat } from "../tools/tool-converter.js";
 import { validateTextProviderOptions } from "../text/text-provider-options.js";
 import { createAnthropicClient, generateId, getAnthropicApiKeyFromEnv } from "../utils/client.js";
-const asChunk = (chunk) => chunk;
 class AnthropicTextAdapter extends BaseTextAdapter {
   constructor(config, model) {
     super({}, model);
@@ -40,8 +40,8 @@ class AnthropicTextAdapter extends BaseTextAdapter {
         error,
         source: "anthropic.chatStream"
       });
-      yield asChunk({
-        type: "RUN_ERROR",
+      yield {
+        type: EventType.RUN_ERROR,
         model: options.model,
         timestamp: Date.now(),
         message: err.message || "Unknown error occurred",
@@ -50,7 +50,7 @@ class AnthropicTextAdapter extends BaseTextAdapter {
           message: err.message || "Unknown error occurred",
           code: err.code || String(err.status)
         }
-      });
+      };
     }
   }
   /**
@@ -378,7 +378,6 @@ class AnthropicTextAdapter extends BaseTextAdapter {
     let accumulatedContent = "";
     let accumulatedThinking = "";
     let accumulatedSignature = "";
-    const timestamp = Date.now();
     const toolCallsMap = /* @__PURE__ */ new Map();
     let currentToolIndex = -1;
     const runId = options.runId ?? genId();
@@ -398,13 +397,14 @@ class AnthropicTextAdapter extends BaseTextAdapter {
         });
         if (!hasEmittedRunStarted) {
           hasEmittedRunStarted = true;
-          yield asChunk({
-            type: "RUN_STARTED",
+          yield {
+            type: EventType.RUN_STARTED,
             runId,
             threadId,
             model,
-            timestamp
-          });
+            timestamp: Date.now(),
+            parentRunId: options.parentRunId
+          };
         }
         if (event.type === "content_block_start") {
           currentBlockType = event.content_block.type;
@@ -421,84 +421,84 @@ class AnthropicTextAdapter extends BaseTextAdapter {
             accumulatedSignature = "";
             stepId = genId();
             reasoningMessageId = genId();
-            yield asChunk({
-              type: "REASONING_START",
+            yield {
+              type: EventType.REASONING_START,
               messageId: reasoningMessageId,
               model,
-              timestamp
-            });
-            yield asChunk({
-              type: "REASONING_MESSAGE_START",
+              timestamp: Date.now()
+            };
+            yield {
+              type: EventType.REASONING_MESSAGE_START,
               messageId: reasoningMessageId,
               role: "reasoning",
               model,
-              timestamp
-            });
-            yield asChunk({
-              type: "STEP_STARTED",
+              timestamp: Date.now()
+            };
+            yield {
+              type: EventType.STEP_STARTED,
               stepName: stepId,
               stepId,
               model,
-              timestamp,
+              timestamp: Date.now(),
               stepType: "thinking"
-            });
+            };
           }
         } else if (event.type === "content_block_delta") {
           if (event.delta.type === "text_delta") {
             if (reasoningMessageId && !hasClosedReasoning) {
               hasClosedReasoning = true;
-              yield asChunk({
-                type: "REASONING_MESSAGE_END",
+              yield {
+                type: EventType.REASONING_MESSAGE_END,
                 messageId: reasoningMessageId,
                 model,
-                timestamp
-              });
-              yield asChunk({
-                type: "REASONING_END",
+                timestamp: Date.now()
+              };
+              yield {
+                type: EventType.REASONING_END,
                 messageId: reasoningMessageId,
                 model,
-                timestamp
-              });
+                timestamp: Date.now()
+              };
             }
             if (!hasEmittedTextMessageStart) {
               hasEmittedTextMessageStart = true;
-              yield asChunk({
-                type: "TEXT_MESSAGE_START",
+              yield {
+                type: EventType.TEXT_MESSAGE_START,
                 messageId,
                 model,
-                timestamp,
+                timestamp: Date.now(),
                 role: "assistant"
-              });
+              };
             }
             const delta = event.delta.text;
             accumulatedContent += delta;
-            yield asChunk({
-              type: "TEXT_MESSAGE_CONTENT",
+            yield {
+              type: EventType.TEXT_MESSAGE_CONTENT,
               messageId,
               model,
-              timestamp,
+              timestamp: Date.now(),
               delta,
               content: accumulatedContent
-            });
+            };
           } else if (event.delta.type === "thinking_delta") {
             const delta = event.delta.thinking;
             accumulatedThinking += delta;
-            yield asChunk({
-              type: "REASONING_MESSAGE_CONTENT",
+            yield {
+              type: EventType.REASONING_MESSAGE_CONTENT,
               messageId: reasoningMessageId,
               delta,
               model,
-              timestamp
-            });
-            yield asChunk({
-              type: "STEP_FINISHED",
+              timestamp: Date.now()
+            };
+            yield {
+              type: EventType.STEP_FINISHED,
               stepName: stepId || genId(),
               stepId: stepId || genId(),
               model,
-              timestamp,
+              timestamp: Date.now(),
               delta,
               content: accumulatedThinking
-            });
+            };
           } else if (event.delta.type === "signature_delta") {
             accumulatedSignature += event.delta.signature || "";
           } else if (event.delta.type === "input_json_delta") {
@@ -506,55 +506,55 @@ class AnthropicTextAdapter extends BaseTextAdapter {
             if (existing) {
               if (!existing.started) {
                 existing.started = true;
-                yield asChunk({
-                  type: "TOOL_CALL_START",
+                yield {
+                  type: EventType.TOOL_CALL_START,
                   toolCallId: existing.id,
                   toolCallName: existing.name,
                   toolName: existing.name,
                   model,
-                  timestamp,
+                  timestamp: Date.now(),
                   index: currentToolIndex
-                });
+                };
               }
               existing.input += event.delta.partial_json;
-              yield asChunk({
-                type: "TOOL_CALL_ARGS",
+              yield {
+                type: EventType.TOOL_CALL_ARGS,
                 toolCallId: existing.id,
                 model,
-                timestamp,
+                timestamp: Date.now(),
                 delta: event.delta.partial_json,
                 args: existing.input
-              });
+              };
             }
           }
         } else if (event.type === "content_block_stop") {
           if (currentBlockType === "thinking") {
             if (accumulatedSignature && stepId) {
-              yield asChunk({
-                type: "STEP_FINISHED",
+              yield {
+                type: EventType.STEP_FINISHED,
                 stepName: stepId,
                 stepId,
                 model,
-                timestamp,
+                timestamp: Date.now(),
                 delta: "",
                 content: accumulatedThinking,
                 signature: accumulatedSignature
-              });
+              };
             }
           } else if (currentBlockType === "tool_use") {
             const existing = toolCallsMap.get(currentToolIndex);
             if (existing) {
               if (!existing.started) {
                 existing.started = true;
-                yield asChunk({
-                  type: "TOOL_CALL_START",
+                yield {
+                  type: EventType.TOOL_CALL_START,
                   toolCallId: existing.id,
                   toolCallName: existing.name,
                   toolName: existing.name,
                   model,
-                  timestamp,
+                  timestamp: Date.now(),
                   index: currentToolIndex
-                });
+                };
               }
               let parsedInput = {};
               try {
@@ -563,118 +563,117 @@ class AnthropicTextAdapter extends BaseTextAdapter {
               } catch {
                 parsedInput = {};
               }
-              yield asChunk({
-                type: "TOOL_CALL_END",
+              yield {
+                type: EventType.TOOL_CALL_END,
                 toolCallId: existing.id,
                 toolCallName: existing.name,
                 toolName: existing.name,
                 model,
-                timestamp,
+                timestamp: Date.now(),
                 input: parsedInput
-              });
+              };
               hasEmittedTextMessageStart = false;
             }
           } else {
             if (hasEmittedTextMessageStart && accumulatedContent) {
-              yield asChunk({
-                type: "TEXT_MESSAGE_END",
+              yield {
+                type: EventType.TEXT_MESSAGE_END,
                 messageId,
                 model,
-                timestamp
-              });
+                timestamp: Date.now()
+              };
             }
           }
           currentBlockType = null;
         } else if (event.type === "message_stop") {
           if (reasoningMessageId && !hasClosedReasoning) {
             hasClosedReasoning = true;
-            yield asChunk({
-              type: "REASONING_MESSAGE_END",
+            yield {
+              type: EventType.REASONING_MESSAGE_END,
               messageId: reasoningMessageId,
               model,
-              timestamp
-            });
-            yield asChunk({
-              type: "REASONING_END",
+              timestamp: Date.now()
+            };
+            yield {
+              type: EventType.REASONING_END,
               messageId: reasoningMessageId,
               model,
-              timestamp
-            });
+              timestamp: Date.now()
+            };
           }
           if (!hasEmittedRunFinished) {
-            yield asChunk({
-              type: "RUN_FINISHED",
+            yield {
+              type: EventType.RUN_FINISHED,
               runId,
               threadId,
               model,
-              timestamp,
+              timestamp: Date.now(),
               finishReason: "stop"
-            });
+            };
           }
         } else if (event.type === "message_delta") {
           if (event.delta.stop_reason) {
             hasEmittedRunFinished = true;
             if (reasoningMessageId && !hasClosedReasoning) {
               hasClosedReasoning = true;
-              yield asChunk({
-                type: "REASONING_MESSAGE_END",
+              yield {
+                type: EventType.REASONING_MESSAGE_END,
                 messageId: reasoningMessageId,
                 model,
-                timestamp
-              });
-              yield asChunk({
-                type: "REASONING_END",
+                timestamp: Date.now()
+              };
+              yield {
+                type: EventType.REASONING_END,
                 messageId: reasoningMessageId,
                 model,
-                timestamp
-              });
+                timestamp: Date.now()
+              };
             }
             switch (event.delta.stop_reason) {
               case "tool_use": {
-                yield asChunk({
-                  type: "RUN_FINISHED",
+                yield {
+                  type: EventType.RUN_FINISHED,
                   runId,
                   threadId,
                   model,
-                  timestamp,
+                  timestamp: Date.now(),
                   finishReason: "tool_calls",
                   usage: {
                     promptTokens: event.usage.input_tokens || 0,
                     completionTokens: event.usage.output_tokens || 0,
                     totalTokens: (event.usage.input_tokens || 0) + (event.usage.output_tokens || 0)
                   }
-                });
+                };
                 break;
               }
               case "max_tokens": {
-                yield asChunk({
-                  type: "RUN_ERROR",
-                  runId,
+                yield {
+                  type: EventType.RUN_ERROR,
                   model,
-                  timestamp,
+                  timestamp: Date.now(),
                   message: "The response was cut off because the maximum token limit was reached.",
                   code: "max_tokens",
                   error: {
                     message: "The response was cut off because the maximum token limit was reached.",
                     code: "max_tokens"
                   }
-                });
+                };
                 break;
               }
               default: {
-                yield asChunk({
-                  type: "RUN_FINISHED",
+                yield {
+                  type: EventType.RUN_FINISHED,
                   runId,
                   threadId,
                   model,
-                  timestamp,
+                  timestamp: Date.now(),
                   finishReason: "stop",
                   usage: {
                     promptTokens: event.usage.input_tokens || 0,
                     completionTokens: event.usage.output_tokens || 0,
                     totalTokens: (event.usage.input_tokens || 0) + (event.usage.output_tokens || 0)
                   }
-                });
+                };
               }
             }
           }
@@ -686,18 +685,17 @@ class AnthropicTextAdapter extends BaseTextAdapter {
         error,
         source: "anthropic.processAnthropicStream"
       });
-      yield asChunk({
-        type: "RUN_ERROR",
-        runId,
+      yield {
+        type: EventType.RUN_ERROR,
         model,
-        timestamp,
+        timestamp: Date.now(),
         message: err.message || "Unknown error occurred",
         code: err.code || String(err.status),
         error: {
           message: err.message || "Unknown error occurred",
           code: err.code || String(err.status)
         }
-      });
+      };
     }
   }
 }