@retrivora-ai/rag-engine 1.9.3 → 1.9.7

package/src/core/VectorPlugin.ts

@@ -5,6 +5,7 @@ import { Pipeline } from './Pipeline';
 import { ProviderHealthCheck, HealthCheckResult } from './ProviderHealthCheck';
 import { IngestDocument, ChatResponse } from '../types';
 import { ChatMessage } from '../types';
+import { wrapError, RetrivoraErrorCode } from '../exceptions';
 
 /**
  * VectorPlugin — main orchestrator class.
@@ -27,6 +28,8 @@ export class VectorPlugin {
     
     // Start validation early
     this.validationPromise = ConfigValidator.validateAndThrow(this.config);
+    // Prevent unhandled promise rejection warning
+    this.validationPromise.catch(() => {});
     
     this.pipeline = new Pipeline(this.config);
   }
@@ -70,31 +73,82 @@ export class VectorPlugin {
    * Run a chat query.
    */
   async chat(message: string, history: ChatMessage[] = [], namespace?: string): Promise<ChatResponse> {
-    await this.validationPromise;
-    return this.pipeline.ask(message, history, namespace);
+    try {
+      await this.validationPromise;
+    } catch (err) {
+      throw wrapError(err, 'CONFIGURATION_ERROR');
+    }
+    try {
+      return await this.pipeline.ask(message, history, namespace);
+    } catch (err) {
+      const msg = String(err);
+      let defaultCode: RetrivoraErrorCode = 'RETRIEVAL_FAILED';
+      if (msg.includes('Embed') || msg.includes('embed')) {
+        defaultCode = 'EMBEDDING_FAILED';
+      }
+      throw wrapError(err, defaultCode);
+    }
   }
 
   /**
    * Run a streaming chat query.
    */
   async *chatStream(message: string, history: ChatMessage[] = [], namespace?: string) {
-    await this.validationPromise;
-    yield* this.pipeline.askStream(message, history, namespace);
+    try {
+      await this.validationPromise;
+    } catch (err) {
+      throw wrapError(err, 'CONFIGURATION_ERROR');
+    }
+    try {
+      const stream = this.pipeline.askStream(message, history, namespace);
+      for await (const chunk of stream) {
+        yield chunk;
+      }
+    } catch (err) {
+      const msg = String(err);
+      let defaultCode: RetrivoraErrorCode = 'RETRIEVAL_FAILED';
+      if (msg.includes('Embed') || msg.includes('embed')) {
+        defaultCode = 'EMBEDDING_FAILED';
+      }
+      throw wrapError(err, defaultCode);
+    }
   }
 
   /**
    * Ingest documents into the vector database.
    */
   async ingest(documents: IngestDocument[], namespace?: string): Promise<Array<{ docId: string | number; chunksIngested: number }>> {
-    await this.validationPromise;
-    return this.pipeline.ingest(documents, namespace);
+    try {
+      await this.validationPromise;
+    } catch (err) {
+      throw wrapError(err, 'CONFIGURATION_ERROR');
+    }
+    try {
+      return await this.pipeline.ingest(documents, namespace);
+    } catch (err) {
+      const msg = String(err);
+      let defaultCode: RetrivoraErrorCode = 'RETRIEVAL_FAILED';
+      if (msg.includes('Embed') || msg.includes('embed')) {
+        defaultCode = 'EMBEDDING_FAILED';
+      }
+      throw wrapError(err, defaultCode);
+    }
   }
 
   /**
    * Get auto-suggestions based on a query prefix.
    */
   async getSuggestions(query: string, namespace?: string): Promise<string[]> {
-    await this.validationPromise;
-    return this.pipeline.getSuggestions(query, namespace);
+    try {
+      await this.validationPromise;
+    } catch (err) {
+      throw wrapError(err, 'CONFIGURATION_ERROR');
+    }
+    try {
+      return await this.pipeline.getSuggestions(query, namespace);
+    } catch (err) {
+      throw wrapError(err, 'RETRIEVAL_FAILED');
+    }
   }
 }
+

package/src/exceptions/index.ts

@@ -0,0 +1,111 @@
+/**
+ * Named SDK exceptions make failures machine-readable for host applications.
+ */
+
+export type RetrivoraErrorCode =
+  | 'PROVIDER_NOT_FOUND'
+  | 'EMBEDDING_FAILED'
+  | 'RETRIEVAL_FAILED'
+  | 'RATE_LIMITED'
+  | 'CONFIGURATION_ERROR'
+  | 'AUTHENTICATION_ERROR';
+
+export class RetrivoraError extends Error {
+  readonly code: RetrivoraErrorCode;
+  readonly details?: unknown;
+
+  constructor(message: string, code: RetrivoraErrorCode, details?: unknown) {
+    super(message);
+    this.name = new.target.name;
+    this.code = code;
+    this.details = details;
+  }
+}
+
+export class ProviderNotFoundException extends RetrivoraError {
+  constructor(providerType: string, provider: string, details?: unknown) {
+    super(`Unsupported ${providerType} provider: ${provider}`, 'PROVIDER_NOT_FOUND', details);
+  }
+}
+
+export class EmbeddingFailedException extends RetrivoraError {
+  constructor(message = 'Embedding generation failed', details?: unknown) {
+    super(message, 'EMBEDDING_FAILED', details);
+  }
+}
+
+export class RetrievalException extends RetrivoraError {
+  constructor(message = 'Retrieval failed', details?: unknown) {
+    super(message, 'RETRIEVAL_FAILED', details);
+  }
+}
+
+export class RateLimitException extends RetrivoraError {
+  constructor(message = 'Provider rate limit exceeded', details?: unknown) {
+    super(message, 'RATE_LIMITED', details);
+  }
+}
+
+export class ConfigurationException extends RetrivoraError {
+  constructor(message: string, details?: unknown) {
+    super(message, 'CONFIGURATION_ERROR', details);
+  }
+}
+
+export class AuthenticationException extends RetrivoraError {
+  constructor(message = 'Provider authentication failed', details?: unknown) {
+    super(message, 'AUTHENTICATION_ERROR', details);
+  }
+}
+
+/**
+ * Wraps any unknown error into an appropriate RetrivoraError subclass.
+ */
+export function wrapError(
+  err: unknown,
+  defaultCode: RetrivoraErrorCode,
+  defaultMessage?: string,
+): RetrivoraError {
+  if (err instanceof RetrivoraError) {
+    return err;
+  }
+
+  const error = err as any;
+  const message = error?.message || defaultMessage || String(err);
+  const status = error?.status || error?.statusCode || error?.response?.status;
+  const code = error?.code;
+
+  // 1. Rate Limit Recognition
+  if (status === 429 || /rate[- ]?limit/i.test(message) || code === 'RATE_LIMIT_EXCEEDED') {
+    return new RateLimitException(message, err);
+  }
+
+  // 2. Authentication Recognition
+  if (
+    status === 401 ||
+    status === 403 ||
+    /unauthorized|auth|api[- ]?key/i.test(message) ||
+    code === 'INVALID_API_KEY'
+  ) {
+    return new AuthenticationException(message, err);
+  }
+
+  // Fallback Mapping based on defaultCode
+  switch (defaultCode) {
+    case 'PROVIDER_NOT_FOUND':
+      return new ProviderNotFoundException('provider', message, err);
+    case 'EMBEDDING_FAILED':
+      return new EmbeddingFailedException(message, err);
+    case 'RETRIEVAL_FAILED':
+      return new RetrievalException(message, err);
+    case 'RATE_LIMITED':
+      return new RateLimitException(message, err);
+    case 'CONFIGURATION_ERROR':
+      return new ConfigurationException(message, err);
+    case 'AUTHENTICATION_ERROR':
+      return new AuthenticationException(message, err);
+    default:
+      return new RetrivoraError(message, defaultCode, err);
+  }
+}
+

package/src/handlers/index.ts

@@ -162,6 +162,8 @@ export function createStreamHandler(configOrPlugin?: Partial<RagConfig> | Vector
             if (!isActive) break;
             if (typeof chunk === 'string') {
               enqueue(sseTextFrame(chunk));
+            } else if (chunk && typeof chunk === 'object' && 'type' in chunk && (chunk as any).type === 'thinking') {
+              enqueue(`data: ${JSON.stringify(chunk)}\n\n`);
             } else {
               // Retrieval metadata object — always the final frame
               enqueue(sseMetaFrame(chunk));
@@ -411,5 +413,76 @@ export function createSuggestionsHandler(configOrPlugin?: Partial<RagConfig> | V
   };
 }
 
+/**
+ * createRagHandler — factory that returns GET and POST handlers for a catch-all route
+ * (e.g. `src/app/api/retrivora/[[...retrivora]]/route.ts`).
+ */
+export function createRagHandler(configOrPlugin?: Partial<RagConfig> | VectorPlugin) {
+  const plugin =
+    configOrPlugin instanceof VectorPlugin
+      ? configOrPlugin
+      : new VectorPlugin(configOrPlugin);
+
+  const chatHandler = createChatHandler(plugin);
+  const streamHandler = createStreamHandler(plugin);
+  const uploadHandler = createUploadHandler(plugin);
+  const healthHandler = createHealthHandler(plugin);
+  const suggestionsHandler = createSuggestionsHandler(plugin);
+
+  async function routePostRequest(req: NextRequest, segment: string) {
+    switch (segment) {
+      case 'chat':
+        return streamHandler(req);
+      case 'chat-sync':
+        return chatHandler(req);
+      case 'upload':
+        return uploadHandler(req);
+      case 'suggestions':
+        return suggestionsHandler(req);
+      case 'health':
+        return healthHandler();
+      default:
+        return NextResponse.json({ error: `Not Found: POST segment "${segment}" not supported.` }, { status: 404 });
+    }
+  }
+
+  async function routeGetRequest(req: NextRequest, segment: string) {
+    if (segment === 'health') {
+      return healthHandler();
+    }
+    return NextResponse.json({ error: `Method Not Allowed: GET is only supported for "health" segment.` }, { status: 405 });
+  }
+
+  async function getSegment(context: any): Promise<string> {
+    const resolvedParams = typeof context?.params?.then === 'function'
+      ? await context.params
+      : context?.params;
+    
+    const segments: string[] = resolvedParams?.retrivora || [];
+    return segments[0] || 'chat';
+  }
+
+  return {
+    GET: async (req: NextRequest, context: any) => {
+      try {
+        const segment = await getSegment(context);
+        return await routeGetRequest(req, segment);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : 'GET Routing failed';
+        return NextResponse.json({ error: msg }, { status: 500 });
+      }
+    },
+    POST: async (req: NextRequest, context: any) => {
+      try {
+        const segment = await getSegment(context);
+        return await routePostRequest(req, segment);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : 'POST Routing failed';
+        return NextResponse.json({ error: msg }, { status: 500 });
+      }
+    }
+  };
+}
+
 // Re-export SSE helpers so host apps can use them in custom handlers
 export { sseFrame, sseTextFrame, sseMetaFrame, sseErrorFrame, sseUIFrame, sseObservabilityFrame };

package/src/hooks/useRagChat.ts

@@ -25,11 +25,12 @@ import { useStoredMessages } from './useStoredMessages';
 // ─── SSE Frame Parser ──────────────────────────────────────────────────────────
 
 interface SseTextFrame         { type: 'text';             text: string }
-interface SseMetaFrame         { type: 'metadata';         sources?: VectorMatch[] }
+interface SseThinkingFrame     { type: 'thinking';         text: string }
+interface SseMetaFrame         { type: 'metadata';         sources?: VectorMatch[]; thinkingMs?: number }
 interface SseErrorFrame        { type: 'error';            error: string }
 interface SseUiFrame           { type: 'ui_transformation'; data: unknown }
 interface SseObservabilityFrame { type: 'observability';   data: ObservabilityTrace }
-type SseFrame = SseTextFrame | SseMetaFrame | SseErrorFrame | SseUiFrame | SseObservabilityFrame;
+type SseFrame = SseTextFrame | SseThinkingFrame | SseMetaFrame | SseErrorFrame | SseUiFrame | SseObservabilityFrame;
 
 /**
  * Parse all complete SSE frames from a raw chunk string.
@@ -114,7 +115,10 @@ export function useRagChat(
 
         const response = await fetch(apiUrl, {
           method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
+          headers: { 
+            'Content-Type': 'application/json',
+            ...(options.headers || {})
+          },
           signal: controller.signal,
           body: JSON.stringify({
             message: trimmed,
@@ -135,6 +139,8 @@ export function useRagChat(
         const reader = response.body.getReader();
         const decoder = new TextDecoder();
         let assistantContent = '';
+        let thinkingContent = '';
+        let thinkingMs: number | undefined;
         let sources: VectorMatch[] = [];
         let uiTransformation: unknown = null;
         let trace: ObservabilityTrace | undefined;
@@ -146,14 +152,20 @@ export function useRagChat(
         // O(N) ReactMarkdown re-parses where N = number of token chunks.
         let pendingFlush = false;
         const pendingContentRef = { current: '' };
+        const pendingThinkingRef = { current: '' };
 
         const flushTextUpdate = (msgId: string) => {
           pendingFlush = false;
           const snapshot = pendingContentRef.current;
+          const thinkingSnapshot = pendingThinkingRef.current;
           setMessages((prev) =>
             prev.map((msg) =>
               msg.id === msgId
-                ? { ...msg, content: snapshot }
+                ? { 
+                    ...msg, 
+                    content: snapshot,
+                    thinking: thinkingSnapshot || undefined,
+                  }
                 : msg
             )
           );
@@ -199,8 +211,13 @@ export function useRagChat(
               pendingContentRef.current = assistantContent;
               // Schedule a batched RAF flush instead of immediate setMessages
               scheduleFlush(assistantMessageId);
+            } else if (frame.type === 'thinking' && frame.text) {
+              thinkingContent += frame.text;
+              pendingThinkingRef.current = thinkingContent;
+              scheduleFlush(assistantMessageId);
             } else if (frame.type === 'metadata') {
               sources = frame.sources ?? [];
+              thinkingMs = (frame as any).thinkingMs;
               hasNonTextFrame = true;
             } else if (frame.type === 'ui_transformation') {
               uiTransformation = frame.data;
@@ -222,6 +239,8 @@ export function useRagChat(
                   ? {
                       ...msg,
                       content: assistantContent,
+                      thinking: thinkingContent || undefined,
+                      thinkingMs: thinkingMs,
                       sources: sources.length > 0 ? sources : msg.sources,
                       uiTransformation: uiTransformation || (msg as RagMessage).uiTransformation,
                     }
@@ -235,7 +254,11 @@ export function useRagChat(
         if (buffer.trim()) {
           for (const frame of parseSseChunk(buffer)) {
             if (frame.type === 'text' && frame.text) assistantContent += frame.text;
-            else if (frame.type === 'metadata') sources = frame.sources ?? [];
+            else if (frame.type === 'thinking' && frame.text) thinkingContent += frame.text;
+            else if (frame.type === 'metadata') {
+              sources = frame.sources ?? [];
+              thinkingMs = (frame as any).thinkingMs;
+            }
             else if (frame.type === 'observability') trace = (frame as SseObservabilityFrame).data;
           }
         }
@@ -248,6 +271,8 @@ export function useRagChat(
           sources: sources.length > 0 ? sources : undefined,
           uiTransformation: uiTransformation ?? undefined,
           trace,
+          thinking: thinkingContent || undefined,
+          thinkingMs: thinkingMs,
           createdAt: new Date().toISOString(),
         };
         setMessages((prev) =>

package/src/index.ts

@@ -1,3 +1,5 @@
+'use client';
+
 /**
  * Package entry point — public API exported to consumers of this npm package.
  * This entry point is CLIENT-SAFE and can be imported in React Client Components.
@@ -21,9 +23,33 @@ export { useRagChat } from './hooks/useRagChat';
 export { addSynonyms } from './utils/synonyms';
 
 // ── Types (Interfaces/Types only, no Node.js deps) ─────────────
-export type { RagConfig, VectorDBConfig, VectorDBProvider, LLMConfig, LLMProvider, EmbeddingConfig, EmbeddingProvider, UIConfig, RAGConfig } from './config/RagConfig';
+export type {
+  RagConfig,
+  UniversalRagConfig,
+  RetrievalConfig,
+  WorkflowConfig,
+  VectorDBConfig,
+  VectorDBProvider,
+  LLMConfig,
+  LLMProvider,
+  EmbeddingConfig,
+  EmbeddingProvider,
+  UIConfig,
+  RAGConfig,
+} from './config/RagConfig';
 export type { ILLMProvider, EmbedOptions } from './llm/ILLMProvider';
 export type { Chunk, ChunkOptions } from './rag/DocumentChunker';
+export type { Retrivora } from './core/Retrivora';
+export type { RetrivoraErrorCode } from './exceptions';
+export {
+  RetrivoraError,
+  ProviderNotFoundException,
+  EmbeddingFailedException,
+  RetrievalException,
+  RateLimitException,
+  ConfigurationException,
+  AuthenticationException,
+} from './exceptions';
 export type { 
   VectorMatch, 
   UpsertDocument, 

package/src/lib/plugin.ts

@@ -0,0 +1,24 @@
+/**
+ * lib/plugin.ts — Singleton VectorPlugin for this Next.js application.
+ *
+ * All API route handlers import this module to share ONE plugin instance
+ * (and therefore one pipeline + one DB connection pool) across the process.
+ *
+ * Why a singleton?
+ * - Prevents a new MongoDB/Postgres connection being opened on every request.
+ * - Ensures the LRU embedding cache is shared across all chat requests.
+ * - In serverless environments (Vercel) the module is cached per function
+ *   instance, so cold-starts initialize once and stay warm.
+ *
+ * To swap provider at runtime, change .env.local and restart the dev server.
+ */
+
+import { VectorPlugin } from '@/core/VectorPlugin';
+import { getRagConfig } from '@/config/serverConfig';
+
+// Build config once from environment variables at module load time.
+const ragConfig = getRagConfig();
+
+// Create and export the singleton.
+// VectorPlugin is lazy — it doesn't open connections until the first request.
+export const plugin = new VectorPlugin(ragConfig);

package/src/llm/LLMFactory.ts

@@ -6,6 +6,7 @@ import { OllamaProvider } from './providers/OllamaProvider';
 import { GeminiProvider } from './providers/GeminiProvider';
 import { UniversalLLMAdapter } from './providers/UniversalLLMAdapter';
 import { IProviderValidator, IProviderHealthChecker } from '../core/ProviderInterfaces';
+import { ProviderNotFoundException } from '../exceptions';
 
 interface LLMProviderStatic {
   getValidator?: () => IProviderValidator;
@@ -81,10 +82,13 @@ export class LLMFactory {
         if (llmConfig.baseUrl || (llmConfig.options as Record<string, unknown>)?.baseUrl) {
           return new UniversalLLMAdapter(llmConfig);
         }
-        throw new Error(
-          `[LLMFactory] Unknown provider "${llmConfig.provider}". ` +
-          `Built-in providers: ${LLMFactory.listProviders().join(', ')}. ` +
-          `Register a custom provider with LLMFactory.register().`
+        throw new ProviderNotFoundException(
+          'llm',
+          llmConfig.provider ?? 'undefined',
+          {
+            message: `Unknown provider "${llmConfig.provider}". Register a custom provider with LLMFactory.register().`,
+            available: LLMFactory.listProviders()
+          }
         );
       }
     }

package/src/llm/providers/AnthropicProvider.ts

@@ -8,6 +8,7 @@ import { ChatMessage, ChatOptions } from '../../types';
 import { LLMConfig, EmbeddingConfig } from '../../config/RagConfig';
 import { IProviderValidator, IProviderHealthChecker, HealthCheckResult } from '../../core/ProviderInterfaces';
 import { ValidationError } from '../../core/ConfigValidator';
+import { buildSystemContent } from '../utils';
 
 export class AnthropicProvider implements ILLMProvider {
   private readonly client: Anthropic;
@@ -75,63 +76,112 @@ export class AnthropicProvider implements ILLMProvider {
   }
 
   async chat(messages: ChatMessage[], context: string, options?: ChatOptions): Promise<string> {
-    const resolvedPrompt = options?.systemPrompt ??
+    const basePrompt =
+      options?.systemPrompt ??
       this.llmConfig.systemPrompt ??
-      `You are a helpful assistant. Use the context below to answer the user's question accurately.\n\nContext:\n${context}`;
+      'You are a helpful assistant. Use the context below to answer the user\'s question accurately.';
 
-    const system = resolvedPrompt.includes('{{context}}')
-      ? resolvedPrompt.replace('{{context}}', context)
-      : options?.systemPrompt
-        ? resolvedPrompt // per-call: context is already in the user message
-        : `${resolvedPrompt}\n\nContext:\n${context}`;
+    const system = buildSystemContent(basePrompt, context);
 
     const anthropicMessages: Anthropic.MessageParam[] = messages.map((m) => ({
       role: m.role === 'assistant' ? 'assistant' : 'user',
       content: m.content,
     }));
 
+    const isClaude37 = this.llmConfig.model.includes('claude-3-7-sonnet');
+    const isThinkingEnabled = this.llmConfig.options?.thinking === true || 
+                              this.llmConfig.options?.thinking === 'enabled' ||
+                              (isClaude37 && this.llmConfig.options?.thinking !== false);
+
+    const extraParams: any = {};
+    if (isThinkingEnabled && isClaude37) {
+      extraParams.betas = ['interleaved-thinking-2025-05-14'];
+      const maxTokens = options?.maxTokens ?? this.llmConfig.maxTokens ?? 4096;
+      const budget = Math.min(
+        typeof this.llmConfig.options?.thinkingBudget === 'number'
+          ? this.llmConfig.options?.thinkingBudget
+          : 2048,
+        maxTokens - 1
+      );
+      extraParams.thinking = {
+        type: 'enabled',
+        budget_tokens: budget,
+      };
+      extraParams.max_tokens = Math.max(maxTokens, budget + 1024);
+    }
+
     const response = await this.client.messages.create({
       model: this.llmConfig.model,
       max_tokens: options?.maxTokens ?? this.llmConfig.maxTokens ?? 1024,
       system,
       messages: anthropicMessages,
-    });
+      ...extraParams,
+    } as any);
 
-    const block = response.content[0];
-    return block.type === 'text' ? block.text : '';
+    let reply = '';
+    for (const block of response.content) {
+      if (block.type === 'text') {
+        reply += block.text;
+      }
+    }
+    return reply;
   }
 
   async *chatStream(messages: ChatMessage[], context: string, options?: ChatOptions): AsyncIterable<string> {
-    const resolvedPrompt = options?.systemPrompt ??
+    const basePrompt =
+      options?.systemPrompt ??
       this.llmConfig.systemPrompt ??
-      `You are a helpful assistant. Use the context below to answer the user's question accurately.\n\nContext:\n${context}`;
+      'You are a helpful assistant. Use the context below to answer the user\'s question accurately.';
 
-    const system = resolvedPrompt.includes('{{context}}')
-      ? resolvedPrompt.replace('{{context}}', context)
-      : options?.systemPrompt
-        ? resolvedPrompt
-        : `${resolvedPrompt}\n\nContext:\n${context}`;
+    const system = buildSystemContent(basePrompt, context);
 
     const anthropicMessages: Anthropic.MessageParam[] = messages.map((m) => ({
       role: m.role === 'assistant' ? 'assistant' : 'user',
       content: m.content,
     }));
 
+    const isClaude37 = this.llmConfig.model.includes('claude-3-7-sonnet');
+    const isThinkingEnabled = this.llmConfig.options?.thinking === true || 
+                              this.llmConfig.options?.thinking === 'enabled' ||
+                              (isClaude37 && this.llmConfig.options?.thinking !== false);
+
+    const extraParams: any = {};
+    if (isThinkingEnabled && isClaude37) {
+      extraParams.betas = ['interleaved-thinking-2025-05-14'];
+      const maxTokens = options?.maxTokens ?? this.llmConfig.maxTokens ?? 4096;
+      const budget = Math.min(
+        typeof this.llmConfig.options?.thinkingBudget === 'number'
+          ? this.llmConfig.options?.thinkingBudget
+          : 2048,
+        maxTokens - 1
+      );
+      extraParams.thinking = {
+        type: 'enabled',
+        budget_tokens: budget,
+      };
+      extraParams.max_tokens = Math.max(maxTokens, budget + 1024);
+    }
+
     const stream = await this.client.messages.create({
       model: this.llmConfig.model,
       max_tokens: options?.maxTokens ?? this.llmConfig.maxTokens ?? 1024,
       system,
       messages: anthropicMessages,
       stream: true,
-    });
+      ...extraParams,
+    } as any) as any;
 
     if (!stream) {
       throw new Error('[AnthropicProvider] messages.create stream is undefined');
     }
 
     for await (const chunk of stream) {
-      if (chunk.type === 'content_block_delta' && chunk.delta.type === 'text_delta') {
-        yield chunk.delta.text;
+      if (chunk.type === 'content_block_delta') {
+        if (chunk.delta.type === 'text_delta') {
+          yield chunk.delta.text;
+        } else if ((chunk.delta as any).type === 'thinking_delta') {
+          yield `\x00THINKING\x00${(chunk.delta as any).thinking}`;
+        }
       }
     }
   }