graphlit-client 1.0.20250611016 → 1.0.20250611017

package/README.md

@@ -8,17 +8,20 @@ The official TypeScript/JavaScript SDK for the [Graphlit Platform](https://www.g
 ## 🚀 What is Graphlit?
 
 Graphlit is a cloud platform that handles the complex parts of building AI applications:
+
 - **Ingest any content** - PDFs, websites, audio, video, and more
 - **Chat with your data** - Using RAG (Retrieval-Augmented Generation)
 - **Extract insights** - Summaries, entities, and metadata
 - **Build knowledge graphs** - Automatically connect related information
 
 ## ✨ What's New in v1.1.0
+
 - **Real-time streaming** - Watch AI responses appear word-by-word
 - **Tool calling** - Let AI execute functions and retrieve data
 - **Better performance** - Native integration with OpenAI, Anthropic, and Google
 
 ## 📋 Table of Contents
+
 - [Quick Start](#quick-start)
 - [Basic Examples](#basic-examples)
 - [Common Use Cases](#common-use-cases)
@@ -35,7 +38,7 @@ npm install graphlit-client
 
 # Set your credentials (get free account at https://portal.graphlit.dev)
 export GRAPHLIT_ORGANIZATION_ID=your_org_id
-export GRAPHLIT_ENVIRONMENT_ID=your_env_id  
+export GRAPHLIT_ENVIRONMENT_ID=your_env_id
 export GRAPHLIT_JWT_SECRET=your_secret
 ```
 
@@ -50,8 +53,8 @@ const spec = await client.createSpecification({
   type: Types.SpecificationTypes.Completion,
   serviceType: Types.ModelServiceTypes.OpenAi,
   openAI: {
-    model: Types.OpenAiModels.Gpt4O_128K
-  }
+    model: Types.OpenAiModels.Gpt4O_128K,
+  },
 });
 
 // Start chatting with AI
@@ -63,7 +66,7 @@ await client.streamAgent(
     }
   },
   undefined, // conversationId (optional)
-  { id: spec.createSpecification.id } // specification
+  { id: spec.createSpecification.id }, // specification
 );
 ```
 
@@ -81,7 +84,7 @@ Install the LLM SDK for streaming responses:
 # For OpenAI streaming
 npm install openai
 
-# For Anthropic streaming  
+# For Anthropic streaming
 npm install @anthropic-ai/sdk
 
 # For Google streaming
@@ -121,8 +124,8 @@ const spec = await client.createSpecification({
   serviceType: Types.ModelServiceTypes.OpenAi,
   openAI: {
     model: Types.OpenAiModels.Gpt4O_128K,
-    temperature: 0.7
-  }
+    temperature: 0.7,
+  },
 });
 
 // Chat with streaming
@@ -135,7 +138,7 @@ await client.streamAgent(
     }
   },
   undefined, // conversationId
-  { id: spec.createSpecification.id } // specification
+  { id: spec.createSpecification.id }, // specification
 );
 ```
 
@@ -154,8 +157,8 @@ const spec = await client.createSpecification({
   type: Types.SpecificationTypes.Completion,
   serviceType: Types.ModelServiceTypes.OpenAi,
   openAI: {
-    model: Types.OpenAiModels.Gpt4O_128K
-  }
+    model: Types.OpenAiModels.Gpt4O_128K,
+  },
 });
 
 // Upload a PDF synchronously to ensure it's ready
@@ -163,17 +166,17 @@ const content = await client.ingestUri(
   "https://arxiv.org/pdf/1706.03762.pdf", // Attention Is All You Need paper
   "AI Research Paper", // name
   undefined, // id
-  true // isSynchronous - waits for processing
+  true, // isSynchronous - waits for processing
 );
 
 console.log(`✅ Uploaded: ${content.ingestUri.id}`);
 
 // Wait a moment for content to be fully indexed
-await new Promise(resolve => setTimeout(resolve, 5000));
+await new Promise((resolve) => setTimeout(resolve, 5000));
 
 // Create a conversation that filters to this specific content
 const conversation = await client.createConversation({
-  filter: { contents: [{ id: content.ingestUri.id }] }
+  filter: { contents: [{ id: content.ingestUri.id }] },
 });
 
 // Ask questions about the PDF
@@ -185,7 +188,7 @@ await client.streamAgent(
     }
   },
   conversation.createConversation.id, // conversationId with content filter
-  { id: spec.createSpecification.id } // specification
+  { id: spec.createSpecification.id }, // specification
 );
 ```
 
@@ -199,22 +202,22 @@ const webpage = await client.ingestUri(
   "https://en.wikipedia.org/wiki/Artificial_intelligence", // uri
   "AI Wikipedia Page", // name
   undefined, // id
-  true // isSynchronous
+  true, // isSynchronous
 );
 
 // Wait for content to be indexed
-await new Promise(resolve => setTimeout(resolve, 5000));
+await new Promise((resolve) => setTimeout(resolve, 5000));
 
 // Create a conversation filtered to this content
 const conversation = await client.createConversation({
-  filter: { contents: [{ id: webpage.ingestUri.id }] }
+  filter: { contents: [{ id: webpage.ingestUri.id }] },
 });
 
 // Ask about the specific content
 const response = await client.promptAgent(
   "Summarize the key points about AI from this Wikipedia page",
   conversation.createConversation.id, // conversationId with filter
-  { id: spec.createSpecification.id } // specification (create one as shown above)
+  { id: spec.createSpecification.id }, // specification (create one as shown above)
 );
 
 console.log(response.message);
@@ -236,22 +239,22 @@ const weatherTool: Types.ToolDefinitionInput = {
   schema: JSON.stringify({
     type: "object",
     properties: {
-      city: { type: "string", description: "City name" }
+      city: { type: "string", description: "City name" },
     },
-    required: ["city"]
-  })
+    required: ["city"],
+  }),
 };
 
 // Tool implementation
 const toolHandlers = {
   get_weather: async (args: { city: string }) => {
     // Call your weather API here
-    return { 
+    return {
       city: args.city,
-      temperature: 72, 
-      condition: "sunny" 
+      temperature: 72,
+      condition: "sunny",
     };
-  }
+  },
 };
 
 // Create a specification for tool calling
@@ -260,8 +263,8 @@ const spec = await client.createSpecification({
   type: Types.SpecificationTypes.Completion,
   serviceType: Types.ModelServiceTypes.OpenAi,
   openAI: {
-    model: Types.OpenAiModels.Gpt4O_128K
-  }
+    model: Types.OpenAiModels.Gpt4O_128K,
+  },
 });
 
 // Chat with tools
@@ -277,7 +280,7 @@ await client.streamAgent(
   undefined, // conversationId
   { id: spec.createSpecification.id }, // specification
   [weatherTool], // tools
-  toolHandlers // handlers
+  toolHandlers, // handlers
 );
 ```
 
@@ -308,40 +311,40 @@ class KnowledgeAssistant {
       serviceType: Types.ModelServiceTypes.OpenAi,
       openAI: {
         model: Types.OpenAiModels.Gpt4O_128K,
-        temperature: 0.7
-      }
+        temperature: 0.7,
+      },
     });
     this.specificationId = spec.createSpecification?.id;
   }
 
   async uploadDocuments(urls: string[]) {
     console.log("📚 Uploading documents...");
-    
+
     for (const url of urls) {
       const content = await this.client.ingestUri(
         url, // uri
-        url.split('/').pop() || "Document", // name
+        url.split("/").pop() || "Document", // name
         undefined, // id
-        true // isSynchronous - wait for processing
+        true, // isSynchronous - wait for processing
       );
       this.contentIds.push(content.ingestUri.id);
     }
-    
+
     console.log("✅ Documents uploaded!");
-    
+
     // Wait for content to be indexed
-    await new Promise(resolve => setTimeout(resolve, 5000));
+    await new Promise((resolve) => setTimeout(resolve, 5000));
   }
 
   async ask(question: string) {
     // Create conversation with content filter if not exists
     if (!this.conversationId && this.contentIds.length > 0) {
       const conversation = await this.client.createConversation({
-        filter: { contents: this.contentIds.map(id => ({ id })) }
+        filter: { contents: this.contentIds.map((id) => ({ id })) },
       });
       this.conversationId = conversation.createConversation?.id;
     }
-    
+
     await this.client.streamAgent(
       question,
       (event) => {
@@ -352,7 +355,7 @@ class KnowledgeAssistant {
         }
       },
       this.conversationId, // Maintains conversation context
-      { id: this.specificationId! } // specification
+      { id: this.specificationId! }, // specification
     );
   }
 }
@@ -364,7 +367,7 @@ await assistant.initialize();
 // Upload your documents
 await assistant.uploadDocuments([
   "https://arxiv.org/pdf/2103.15348.pdf",
-  "https://arxiv.org/pdf/1706.03762.pdf"
+  "https://arxiv.org/pdf/1706.03762.pdf",
 ]);
 
 // Ask questions
@@ -382,18 +385,18 @@ const document = await client.ingestUri(
   "https://example.com/document.pdf", // uri
   "Document #12345", // name
   undefined, // id
-  true // isSynchronous
+  true, // isSynchronous
 );
 
 // Wait for content to be indexed
-await new Promise(resolve => setTimeout(resolve, 5000));
+await new Promise((resolve) => setTimeout(resolve, 5000));
 
 // Extract specific data
 const extraction = await client.extractContents(
   "Extract the key information from this document",
   undefined, // tools
   undefined, // specification
-  { contents: [{ id: document.ingestUri.id }] } // filter
+  { contents: [{ id: document.ingestUri.id }] }, // filter
 );
 
 console.log("Extracted data:", extraction.extractContents);
@@ -410,20 +413,22 @@ const ids: string[] = [];
 for (const url of documentUrls) {
   const content = await client.ingestUri(
     url, // uri
-    url.split('/').pop() || "Document", // name
+    url.split("/").pop() || "Document", // name
     undefined, // id
-    true // isSynchronous
+    true, // isSynchronous
   );
   ids.push(content.ingestUri.id);
 }
 
 // Generate a summary across all documents
 const summary = await client.summarizeContents(
-  [{
-    type: Types.SummarizationTypes.Custom,
-    prompt: "Create an executive summary of these documents"
-  }], // summarizations
-  { contents: ids.map(id => ({ id })) } // filter
+  [
+    {
+      type: Types.SummarizationTypes.Custom,
+      prompt: "Create an executive summary of these documents",
+    },
+  ], // summarizations
+  { contents: ids.map((id) => ({ id })) }, // filter
 );
 
 console.log("Summary:", summary.summarizeContents);
@@ -437,13 +442,13 @@ const content = await client.ingestUri(
   "https://example.com/large-document.pdf", // uri
   undefined, // name
   undefined, // id
-  true // isSynchronous
+  true, // isSynchronous
 );
 console.log("✅ Content ready!");
 
 // Option 2: Asynchronous processing (for large files)
 const content = await client.ingestUri(
-  "https://example.com/very-large-video.mp4" // uri
+  "https://example.com/very-large-video.mp4", // uri
   // isSynchronous defaults to false
 );
 
@@ -452,15 +457,116 @@ let isReady = false;
 while (!isReady) {
   const status = await client.isContentDone(content.ingestUri.id);
   isReady = status.isContentDone?.result || false;
-  
+
   if (!isReady) {
     console.log("⏳ Still processing...");
-    await new Promise(resolve => setTimeout(resolve, 2000));
+    await new Promise((resolve) => setTimeout(resolve, 2000));
   }
 }
 console.log("✅ Content ready!");
 ```
 
+## Advanced Agent Features
+
+### Using Content Filters
+
+Control what content the agent can access during conversations:
+
+```typescript
+// Example 1: Chat with specific documents only
+const result = await client.promptAgent(
+  "What are the main points in these documents?",
+  undefined, // conversationId - will create new
+  { id: specificationId },
+  undefined, // tools
+  undefined, // toolHandlers
+  undefined, // options
+  undefined, // mimeType
+  undefined, // data
+  {
+    // Only allow retrieval from specific content
+    contents: [{ id: "content-id-1" }, { id: "content-id-2" }],
+  },
+);
+
+// Example 2: Streaming with content filter
+await client.streamAgent(
+  "Explain the technical details",
+  (event) => {
+    if (event.type === "message_update") {
+      process.stdout.write(event.message.message);
+    }
+  },
+  undefined, // conversationId
+  { id: specificationId },
+  undefined, // tools
+  undefined, // toolHandlers
+  undefined, // options
+  undefined, // mimeType
+  undefined, // data
+  {
+    // Filter by collection
+    collections: [{ id: "technical-docs-collection" }],
+  },
+);
+```
+
+### Using Augmented Filters
+
+Force specific content into the LLM context without retrieval:
+
+```typescript
+// Example: Chat with a specific file always in context
+const fileContent = await client.getContent("file-content-id");
+
+await client.streamAgent(
+  "What patterns do you see in this code?",
+  (event) => {
+    if (event.type === "message_update") {
+      process.stdout.write(event.message.message);
+    }
+  },
+  undefined, // conversationId
+  { id: specificationId },
+  undefined, // tools
+  undefined, // toolHandlers
+  undefined, // options
+  undefined, // mimeType
+  undefined, // data
+  undefined, // contentFilter
+  {
+    // Force this content into context
+    contents: [{ id: fileContent.content.id }],
+  },
+);
+```
+
+### Combining Filters
+
+Use both filters for precise control:
+
+```typescript
+// Chat about specific code with documentation available
+await client.promptAgent(
+  "How does this code implement the algorithm described in the docs?",
+  undefined,
+  { id: specificationId },
+  undefined,
+  undefined,
+  undefined,
+  undefined,
+  undefined,
+  {
+    // Can retrieve from documentation
+    collections: [{ id: "algorithm-docs" }],
+  },
+  {
+    // Always include the specific code file
+    contents: [{ id: "implementation-file-id" }],
+  },
+);
+```
+
 ## Advanced Workflows
 
 ### Creating Workflows for Content Processing
@@ -478,29 +584,31 @@ const summarizationSpec = await client.createSpecification({
   type: Types.SpecificationTypes.Summarization,
   serviceType: Types.ModelServiceTypes.OpenAi,
   openAI: {
-    model: Types.OpenAiModels.Gpt4O_128K
-  }
+    model: Types.OpenAiModels.Gpt4O_128K,
+  },
 });
 
 // Create a workflow that summarizes all content
 const workflow = await client.createWorkflow({
   name: "Document Intelligence",
   preparation: {
-    summarizations: [{
-      type: Types.SummarizationTypes.Summary,
-      specification: { id: summarizationSpec.createSpecification.id }
-    }]
-  }
+    summarizations: [
+      {
+        type: Types.SummarizationTypes.Summary,
+        specification: { id: summarizationSpec.createSpecification.id },
+      },
+    ],
+  },
 });
 
 // Set workflow as default for project
 await client.updateProject({
-  workflow: { id: workflow.createWorkflow.id }
+  workflow: { id: workflow.createWorkflow.id },
 });
 
 // Now all content will be automatically summarized
 const content = await client.ingestUri(
-  "https://example.com/report.pdf" // uri
+  "https://example.com/report.pdf", // uri
 );
 ```
 
@@ -520,8 +628,8 @@ const conversationSpec = await client.createSpecification({
   openAI: {
     model: Types.OpenAiModels.Gpt4O_128K,
     temperature: 0.7,
-    completionTokenLimit: 2000
-  }
+    completionTokenLimit: 2000,
+  },
 });
 
 // Use the specification in conversations
@@ -533,7 +641,7 @@ await client.streamAgent(
     }
   },
   undefined,
-  { id: conversationSpec.createSpecification.id }
+  { id: conversationSpec.createSpecification.id },
 );
 ```
 
@@ -546,6 +654,7 @@ const client = new Graphlit(organizationId?, environmentId?, jwtSecret?);
 ```
 
 #### Content Operations
+
 - `ingestUri(uri, name?, id?, isSynchronous?, ...)` - Ingest content from URL
 - `ingestText(text, name?, textType?, ...)` - Ingest text content directly
 - `queryContents(filter?)` - Search and query content
@@ -555,18 +664,21 @@ const client = new Graphlit(organizationId?, environmentId?, jwtSecret?);
 - `summarizeContents(summarizations, filter?)` - Summarize content
 - `isContentDone(id)` - Check if content processing is complete
 
-#### Conversation Operations  
+#### Conversation Operations
+
 - `createConversation(input?)` - Create a new conversation
 - `streamAgent(prompt, handler, ...)` - Stream AI responses
 - `promptAgent(prompt, ...)` - Get AI response without streaming
 - `deleteConversation(id)` - Delete conversation
 
 #### Specification Operations
+
 - `createSpecification(input)` - Create AI model configuration
 - `querySpecifications(filter?)` - List specifications
 - `deleteSpecification(id)` - Delete specification
 
 #### Workflow Operations
+
 - `createWorkflow(input)` - Create content processing workflow
 - `queryWorkflows(filter?)` - List workflows
 - `updateProject(input)` - Update project settings
@@ -574,12 +686,12 @@ const client = new Graphlit(organizationId?, environmentId?, jwtSecret?);
 ### Event Types
 
 ```typescript
-type AgentStreamEvent = 
+type AgentStreamEvent =
   | { type: "conversation_started"; conversationId: string }
   | { type: "message_update"; message: { message: string } }
   | { type: "tool_update"; toolCall: any; status: string }
   | { type: "conversation_completed"; message: { message: string } }
-  | { type: "error"; error: { message: string; recoverable: boolean } }
+  | { type: "error"; error: { message: string; recoverable: boolean } };
 ```
 
 ## Testing & Examples
@@ -613,4 +725,4 @@ npm test test/readme-simple.test.ts
 
 ## License
 
-MIT License - see LICENSE file for details.
+MIT License - see LICENSE file for details.

package/dist/client.d.ts

@@ -319,7 +319,7 @@ declare class Graphlit {
      * @param specification - Optional specification to check compatibility
      * @returns true if streaming is available, false otherwise
      */
-    supportsStreaming(specification?: Types.Specification | Types.EntityReferenceInput): boolean;
+    supportsStreaming(specification?: Types.Specification): boolean;
     /**
      * Execute an agent with non-streaming response
      * @param prompt - The user prompt
@@ -328,10 +328,15 @@ declare class Graphlit {
      * @param tools - Optional tool definitions
      * @param toolHandlers - Optional tool handler functions
      * @param options - Agent options
+     * @param mimeType - Optional MIME type for multimodal input
+     * @param data - Optional base64 encoded data for multimodal input
+     * @param contentFilter - Optional filter for content retrieval during conversation
+     * @param augmentedFilter - Optional filter to force specific content into LLM context
+     * @param correlationId - Optional correlation ID for tracking
      * @returns Complete agent result with message and tool calls
      */
     promptAgent(prompt: string, conversationId?: string, specification?: Types.EntityReferenceInput, tools?: Types.ToolDefinitionInput[], toolHandlers?: Record<string, ToolHandler>, options?: AgentOptions, mimeType?: string, data?: string, // base64 encoded
-    correlationId?: string): Promise<AgentResult>;
+    contentFilter?: Types.ContentCriteriaInput, augmentedFilter?: Types.ContentCriteriaInput, correlationId?: string): Promise<AgentResult>;
     /**
      * Execute an agent with streaming response
      * @param prompt - The user prompt
@@ -341,10 +346,15 @@ declare class Graphlit {
      * @param tools - Optional tool definitions
      * @param toolHandlers - Optional tool handler functions
      * @param options - Stream agent options
+     * @param mimeType - Optional MIME type for multimodal input
+     * @param data - Optional base64 encoded data for multimodal input
+     * @param contentFilter - Optional filter for content retrieval during conversation
+     * @param augmentedFilter - Optional filter to force specific content into LLM context
+     * @param correlationId - Optional correlation ID for tracking
      * @throws Error if streaming is not supported
      */
     streamAgent(prompt: string, onEvent: (event: AgentStreamEvent) => void, conversationId?: string, specification?: Types.EntityReferenceInput, tools?: Types.ToolDefinitionInput[], toolHandlers?: Record<string, ToolHandler>, options?: StreamAgentOptions, mimeType?: string, data?: string, // base64 encoded
-    correlationId?: string): Promise<void>;
+    contentFilter?: Types.ContentCriteriaInput, augmentedFilter?: Types.ContentCriteriaInput, correlationId?: string): Promise<void>;
     /**
      * Execute the streaming agent workflow with tool calling loop
      */

package/dist/client.js

@@ -24,7 +24,8 @@ catch (e) {
 }
 try {
     Anthropic =
-        optionalRequire("@anthropic-ai/sdk").default || optionalRequire("@anthropic-ai/sdk");
+        optionalRequire("@anthropic-ai/sdk").default ||
+            optionalRequire("@anthropic-ai/sdk");
 }
 catch (e) {
     // Anthropic SDK not installed
@@ -1421,8 +1422,8 @@ class Graphlit {
      */
     supportsStreaming(specification) {
         // If we have a full specification, check its service type
-        if (specification && "modelService" in specification) {
-            const serviceType = specification.modelService;
+        if (specification) {
+            const serviceType = specification.serviceType;
             switch (serviceType) {
                 case Types.ModelServiceTypes.OpenAi:
                     return typeof OpenAI !== "undefined";
@@ -1434,11 +1435,10 @@ class Graphlit {
                     return false;
             }
         }
-        // If we only have a reference or no specification, check if any client is available
+        // If we have no specification, check if OpenAI client is available
+        // We default to OpenAI GPT-4o if no specification provider.
         const hasOpenAI = typeof OpenAI !== "undefined";
-        const hasAnthropic = typeof Anthropic !== "undefined";
-        const hasGoogle = typeof GoogleGenerativeAI !== "undefined";
-        return hasOpenAI || hasAnthropic || hasGoogle;
+        return hasOpenAI;
     }
     /**
      * Execute an agent with non-streaming response
@@ -1448,10 +1448,15 @@ class Graphlit {
      * @param tools - Optional tool definitions
      * @param toolHandlers - Optional tool handler functions
      * @param options - Agent options
+     * @param mimeType - Optional MIME type for multimodal input
+     * @param data - Optional base64 encoded data for multimodal input
+     * @param contentFilter - Optional filter for content retrieval during conversation
+     * @param augmentedFilter - Optional filter to force specific content into LLM context
+     * @param correlationId - Optional correlation ID for tracking
      * @returns Complete agent result with message and tool calls
      */
     async promptAgent(prompt, conversationId, specification, tools, toolHandlers, options, mimeType, data, // base64 encoded
-    correlationId) {
+    contentFilter, augmentedFilter, correlationId) {
         const startTime = Date.now();
         const maxRounds = options?.maxToolRounds || DEFAULT_MAX_TOOL_ROUNDS;
         const timeout = options?.timeout || 300000; // 5 minutes default
@@ -1466,6 +1471,8 @@ class Graphlit {
                     name: `Agent conversation`,
                     specification: specification,
                     tools: tools,
+                    filter: contentFilter,
+                    augmentedFilter: augmentedFilter,
                 }, correlationId);
                 actualConversationId = createResponse.createConversation?.id;
                 if (!actualConversationId) {
@@ -1535,10 +1542,15 @@ class Graphlit {
      * @param tools - Optional tool definitions
      * @param toolHandlers - Optional tool handler functions
      * @param options - Stream agent options
+     * @param mimeType - Optional MIME type for multimodal input
+     * @param data - Optional base64 encoded data for multimodal input
+     * @param contentFilter - Optional filter for content retrieval during conversation
+     * @param augmentedFilter - Optional filter to force specific content into LLM context
+     * @param correlationId - Optional correlation ID for tracking
      * @throws Error if streaming is not supported
      */
     async streamAgent(prompt, onEvent, conversationId, specification, tools, toolHandlers, options, mimeType, data, // base64 encoded
-    correlationId) {
+    contentFilter, augmentedFilter, correlationId) {
         const maxRounds = options?.maxToolRounds || DEFAULT_MAX_TOOL_ROUNDS;
         const abortSignal = options?.abortSignal;
         let uiAdapter;
@@ -1553,7 +1565,7 @@ class Graphlit {
                     .specification
                 : undefined;
             // Check streaming support
-            if (!this.supportsStreaming(fullSpec)) {
+            if (fullSpec && !this.supportsStreaming(fullSpec)) {
                 throw new Error("Streaming is not supported for this specification. " +
                     "Use promptAgent() instead or configure a streaming client.");
             }
@@ -1564,6 +1576,8 @@ class Graphlit {
                     name: `Streaming agent conversation`,
                     specification: specification,
                     tools: tools,
+                    filter: contentFilter,
+                    augmentedFilter: augmentedFilter,
                 }, correlationId);
                 actualConversationId = createResponse.createConversation?.id;
                 if (!actualConversationId) {
@@ -1621,10 +1635,15 @@ class Graphlit {
         });
         // Format conversation once at the beginning
         const formatResponse = await this.formatConversation(prompt, conversationId, { id: specification.id }, tools, true, correlationId);
-        const formattedPrompt = formatResponse.formatConversation?.message?.message;
-        if (!formattedPrompt) {
+        const formattedMessage = formatResponse.formatConversation?.message;
+        if (!formattedMessage?.message) {
             throw new Error("Failed to format conversation");
         }
+        if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+            console.log("\n📋 [formatConversation] Response:");
+            console.log("Formatted message:", formattedMessage.message);
+            console.log("Full formatConversation response:", JSON.stringify(formatResponse.formatConversation, null, 2));
+        }
         // Build message array with conversation history
         const messages = [];
         // Add system prompt if specified
@@ -1636,23 +1655,19 @@ class Graphlit {
                 timestamp: new Date().toISOString(),
             });
         }
-        // Get conversation history to maintain context
-        const conversationResponse = await this.getConversation(conversationId);
-        const conversation = conversationResponse.conversation;
-        if (conversation?.messages && conversation.messages.length > 0) {
-            // Add all previous messages (formatConversation already added the current prompt)
-            const previousMessages = conversation.messages;
-            messages.push(...previousMessages);
-        }
-        else {
-            // If no history, just add the current user message
+        // Use the formatted message from formatConversation which already includes
+        // all context, RAG results, and conversation history
+        if (formattedMessage) {
             messages.push({
                 __typename: "ConversationMessage",
-                role: Types.ConversationRoleTypes.User,
-                message: formattedPrompt,
-                timestamp: new Date().toISOString(),
+                role: formattedMessage.role || Types.ConversationRoleTypes.User,
+                message: formattedMessage.message,
+                timestamp: formattedMessage.timestamp || new Date().toISOString(),
             });
         }
+        else {
+            throw new Error("No formatted message returned from formatConversation");
+        }
         const serviceType = getServiceType(specification);
         // Handle tool calling loop locally
         while (currentRound < maxRounds) {
@@ -1664,6 +1679,11 @@ class Graphlit {
             // Stream with appropriate provider
             if (serviceType === Types.ModelServiceTypes.OpenAi && OpenAI) {
                 const openaiMessages = formatMessagesForOpenAI(messages);
+                if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                    console.log("\n🔍 [OpenAI] Formatted messages being sent to LLM:");
+                    console.log(JSON.stringify(openaiMessages, null, 2));
+                    console.log("Total messages:", openaiMessages.length);
+                }
                 await this.streamWithOpenAI(specification, openaiMessages, tools, uiAdapter, (message, calls) => {
                     roundMessage = message;
                     toolCalls = calls;
@@ -1672,6 +1692,12 @@ class Graphlit {
             else if (serviceType === Types.ModelServiceTypes.Anthropic &&
                 Anthropic) {
                 const { system, messages: anthropicMessages } = formatMessagesForAnthropic(messages);
+                if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                    console.log("\n🔍 [Anthropic] Formatted messages being sent to LLM:");
+                    console.log("System prompt:", system);
+                    console.log(JSON.stringify(anthropicMessages, null, 2));
+                    console.log("Total messages:", anthropicMessages.length);
+                }
                 await this.streamWithAnthropic(specification, anthropicMessages, system, tools, uiAdapter, (message, calls) => {
                     roundMessage = message;
                     toolCalls = calls;
@@ -1680,6 +1706,11 @@ class Graphlit {
             else if (serviceType === Types.ModelServiceTypes.Google &&
                 GoogleGenerativeAI) {
                 const googleMessages = formatMessagesForGoogle(messages);
+                if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                    console.log("\n🔍 [Google] Formatted messages being sent to LLM:");
+                    console.log(JSON.stringify(googleMessages, null, 2));
+                    console.log("Total messages:", googleMessages.length);
+                }
                 // Google doesn't use system prompts separately, they're incorporated into messages
                 await this.streamWithGoogle(specification, googleMessages, undefined, // systemPrompt - Google handles this differently
                 tools, uiAdapter, (message, calls) => {
@@ -2065,8 +2096,7 @@ class Graphlit {
             return result.data;
         }
         catch (error) {
-            if (error instanceof ApolloError &&
-                error.graphQLErrors.length > 0) {
+            if (error instanceof ApolloError && error.graphQLErrors.length > 0) {
                 const errorMessage = error.graphQLErrors
                     .map((err) => this.prettyPrintGraphQLError(err))
                     .join("\n");
@@ -2102,8 +2132,7 @@ class Graphlit {
             return result.data;
         }
         catch (error) {
-            if (error instanceof ApolloError &&
-                error.graphQLErrors.length > 0) {
+            if (error instanceof ApolloError && error.graphQLErrors.length > 0) {
                 const errorMessage = error.graphQLErrors
                     .map((err) => this.prettyPrintGraphQLError(err))
                     .join("\n");

package/dist/streaming/providers.js

@@ -23,6 +23,15 @@ onEvent, onComplete) {
         if (!modelName) {
             throw new Error(`No model name found for OpenAI specification: ${specification.name}`);
         }
+        if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+            console.log("\n🤖 [OpenAI] Model Configuration:");
+            console.log("  Service: OpenAI");
+            console.log("  Model:", modelName);
+            console.log("  Temperature:", specification.openAI?.temperature);
+            console.log("  Max Tokens:", specification.openAI?.completionTokenLimit);
+            console.log("  Tools:", tools?.length || 0);
+            console.log("  Specification Name:", specification.name);
+        }
         const streamConfig = {
             model: modelName,
             messages,
@@ -49,8 +58,25 @@ onEvent, onComplete) {
         const stream = await openaiClient.chat.completions.create(streamConfig);
         for await (const chunk of stream) {
             const delta = chunk.choices[0]?.delta;
+            // Debug log chunk details
+            if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                console.log(`[OpenAI] Chunk:`, JSON.stringify(chunk, null, 2));
+                if (delta?.content) {
+                    console.log(`[OpenAI] Content delta: "${delta.content}" (${delta.content.length} chars)`);
+                }
+                if (delta?.tool_calls) {
+                    console.log(`[OpenAI] Tool calls:`, delta.tool_calls);
+                }
+                if (chunk.choices[0]?.finish_reason) {
+                    console.log(`[OpenAI] Finish reason: ${chunk.choices[0].finish_reason}`);
+                }
+            }
             if (delta?.content) {
                 fullMessage += delta.content;
+                if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                    console.log(`[OpenAI] Message accumulated: ${fullMessage.length} chars total`);
+                    console.log(`[OpenAI] Current full message: "${fullMessage}"`);
+                }
                 onEvent({
                     type: "token",
                     token: delta.content,
@@ -66,6 +92,9 @@ onEvent, onComplete) {
                             name: "",
                             arguments: "",
                         };
+                        if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                            console.log(`[OpenAI] Starting new tool call: ${toolCalls[index].id}`);
+                        }
                         onEvent({
                             type: "tool_call_start",
                             toolCall: {
@@ -76,9 +105,17 @@ onEvent, onComplete) {
                     }
                     if (toolCallDelta.function?.name) {
                         toolCalls[index].name = toolCallDelta.function.name;
+                        if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                            console.log(`[OpenAI] Tool name: ${toolCallDelta.function.name}`);
+                        }
                     }
                     if (toolCallDelta.function?.arguments) {
                         toolCalls[index].arguments += toolCallDelta.function.arguments;
+                        // Debug logging for partial JSON accumulation
+                        if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                            console.log(`[OpenAI] Tool ${toolCalls[index].name} - Partial JSON chunk: "${toolCallDelta.function.arguments}"`);
+                            console.log(`[OpenAI] Tool ${toolCalls[index].name} - Total accumulated: ${toolCalls[index].arguments.length} chars`);
+                        }
                         onEvent({
                             type: "tool_call_delta",
                             toolCallId: toolCalls[index].id,
@@ -90,6 +127,19 @@ onEvent, onComplete) {
         }
         // Emit complete events for tool calls
         for (const toolCall of toolCalls) {
+            // Log the final JSON for debugging
+            if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                console.log(`[OpenAI] Tool ${toolCall.name} complete with arguments (${toolCall.arguments.length} chars):`);
+                console.log(toolCall.arguments);
+                // Validate JSON
+                try {
+                    JSON.parse(toolCall.arguments);
+                    console.log(`[OpenAI] ✅ Valid JSON for ${toolCall.name}`);
+                }
+                catch (e) {
+                    console.error(`[OpenAI] ❌ Invalid JSON for ${toolCall.name}: ${e}`);
+                }
+            }
             onEvent({
                 type: "tool_call_complete",
                 toolCall: {
@@ -99,6 +149,13 @@ onEvent, onComplete) {
                 },
             });
         }
+        // Final summary logging
+        if (process.env.DEBUG_GRAPHLIT_STREAMING && toolCalls.length > 0) {
+            console.log(`[OpenAI] Successfully processed ${toolCalls.length} tool calls`);
+        }
+        if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+            console.log(`[OpenAI] Streaming complete. Final message: "${fullMessage}" (${fullMessage.length} chars)`);
+        }
         onComplete(fullMessage, toolCalls);
     }
     catch (error) {
@@ -121,6 +178,16 @@ onEvent, onComplete) {
         if (!modelName) {
             throw new Error(`No model name found for Anthropic specification: ${specification.name}`);
         }
+        if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+            console.log("\n🤖 [Anthropic] Model Configuration:");
+            console.log("  Service: Anthropic");
+            console.log("  Model:", modelName);
+            console.log("  Temperature:", specification.anthropic?.temperature);
+            console.log("  Max Tokens:", specification.anthropic?.completionTokenLimit || 8192);
+            console.log("  System Prompt:", systemPrompt ? "Yes" : "No");
+            console.log("  Tools:", tools?.length || 0);
+            console.log("  Specification Name:", specification.name);
+        }
         const streamConfig = {
             model: modelName,
             messages,
@@ -144,7 +211,7 @@ onEvent, onComplete) {
         let activeContentBlock = false;
         for await (const chunk of stream) {
             // Debug log all chunk types
-            if (process.env.DEBUG_STREAMING) {
+            if (process.env.DEBUG_GRAPHLIT_STREAMING) {
                 console.log(`[Anthropic] Received chunk type: ${chunk.type}`);
             }
             if (chunk.type === "content_block_start") {
@@ -167,6 +234,9 @@ onEvent, onComplete) {
             }
             else if (chunk.type === "content_block_delta") {
                 if (chunk.delta.type === "text_delta") {
+                    if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                        console.log(`[Anthropic] Text delta: "${chunk.delta.text}"`);
+                    }
                     fullMessage += chunk.delta.text;
                     onEvent({
                         type: "token",
@@ -179,7 +249,7 @@ onEvent, onComplete) {
                     if (currentTool) {
                         currentTool.arguments += chunk.delta.partial_json;
                         // Debug logging for partial JSON accumulation
-                        if (process.env.DEBUG_STREAMING) {
+                        if (process.env.DEBUG_GRAPHLIT_STREAMING) {
                             console.log(`[Anthropic] Tool ${currentTool.name} - Partial JSON chunk: "${chunk.delta.partial_json}"`);
                             console.log(`[Anthropic] Tool ${currentTool.name} - Total accumulated: ${currentTool.arguments.length} chars`);
                         }
@@ -197,7 +267,7 @@ onEvent, onComplete) {
                 const currentTool = toolCalls[toolCalls.length - 1];
                 if (currentTool) {
                     // Log the final JSON for debugging
-                    if (process.env.DEBUG_STREAMING ||
+                    if (process.env.DEBUG_GRAPHLIT_STREAMING ||
                         !isValidJSON(currentTool.arguments)) {
                         console.log(`[Anthropic] Tool ${currentTool.name} complete with arguments (${currentTool.arguments.length} chars):`);
                         console.log(currentTool.arguments);
@@ -210,7 +280,7 @@ onEvent, onComplete) {
                         // Validate JSON
                         try {
                             JSON.parse(currentTool.arguments);
-                            if (process.env.DEBUG_STREAMING) {
+                            if (process.env.DEBUG_GRAPHLIT_STREAMING) {
                                 console.log(`[Anthropic] ✅ Valid JSON for ${currentTool.name}`);
                             }
                         }
@@ -288,6 +358,16 @@ onEvent, onComplete) {
         if (!modelName) {
             throw new Error(`No model name found for Google specification: ${specification.name}`);
         }
+        if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+            console.log("\n🤖 [Google] Model Configuration:");
+            console.log("  Service: Google");
+            console.log("  Model:", modelName);
+            console.log("  Temperature:", specification.google?.temperature);
+            console.log("  Max Tokens:", specification.google?.completionTokenLimit);
+            console.log("  System Prompt:", systemPrompt ? "Yes" : "No");
+            console.log("  Tools:", tools?.length || 0);
+            console.log("  Specification Name:", specification.name);
+        }
         const streamConfig = {
             model: modelName,
             messages,
@@ -337,6 +417,13 @@ onEvent, onComplete) {
         const result = await chat.sendMessageStream(prompt);
         for await (const chunk of result.stream) {
             const text = chunk.text();
+            // Debug log chunk details
+            if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                console.log(`[Google] Raw chunk:`, JSON.stringify(chunk, null, 2));
+                if (text) {
+                    console.log(`[Google] Text delta: "${text}" (${text.length} chars)`);
+                }
+            }
             if (text) {
                 fullMessage += text;
                 onEvent({
@@ -351,6 +438,10 @@ onEvent, onComplete) {
                 if (candidate?.content?.parts) {
                     for (const part of candidate.content.parts) {
                         if (part.functionCall) {
+                            if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                                console.log(`[Google] Received function call: ${part.functionCall.name}`);
+                                console.log(`[Google] Function args:`, JSON.stringify(part.functionCall.args || {}));
+                            }
                             const toolCall = {
                                 id: `google_tool_${Date.now()}_${toolCalls.length}`,
                                 name: part.functionCall.name,
@@ -370,6 +461,19 @@ onEvent, onComplete) {
                                 toolCallId: toolCall.id,
                                 argumentDelta: toolCall.arguments,
                             });
+                            // Log completion and validate JSON
+                            if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                                console.log(`[Google] Tool ${toolCall.name} complete with arguments (${toolCall.arguments.length} chars):`);
+                                console.log(toolCall.arguments);
+                                // Validate JSON
+                                try {
+                                    JSON.parse(toolCall.arguments);
+                                    console.log(`[Google] ✅ Valid JSON for ${toolCall.name}`);
+                                }
+                                catch (e) {
+                                    console.error(`[Google] ❌ Invalid JSON for ${toolCall.name}: ${e}`);
+                                }
+                            }
                             onEvent({
                                 type: "tool_call_complete",
                                 toolCall: {
@@ -384,12 +488,18 @@ onEvent, onComplete) {
             }
             catch (error) {
                 // Silently ignore parsing errors
+                if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                    console.error(`[Google] Error parsing chunk for function calls:`, error);
+                }
             }
         }
         // Google might also return function calls or additional text in the final response
         try {
             const response = await result.response;
             const candidate = response.candidates?.[0];
+            if (process.env.DEBUG_GRAPHLIT_STREAMING && candidate?.content?.parts) {
+                console.log(`[Google] Processing final response with ${candidate.content.parts.length} parts`);
+            }
             if (candidate?.content?.parts) {
                 for (const part of candidate.content.parts) {
                     // Check for any final text we might have missed
@@ -397,6 +507,9 @@ onEvent, onComplete) {
                         const finalText = part.text;
                         // Only add if it's not already included in fullMessage
                         if (!fullMessage.endsWith(finalText)) {
+                            if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                                console.log(`[Google] Adding final text: ${finalText.length} chars`);
+                            }
                             fullMessage += finalText;
                             onEvent({
                                 type: "token",
@@ -407,6 +520,9 @@ onEvent, onComplete) {
                     // Check for function calls
                     if (part.functionCall &&
                         !toolCalls.some((tc) => tc.name === part.functionCall.name)) {
+                        if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                            console.log(`[Google] Found function call in final response: ${part.functionCall.name}`);
+                        }
                         const toolCall = {
                             id: `google_tool_${Date.now()}_${toolCalls.length}`,
                             name: part.functionCall.name,
@@ -434,7 +550,14 @@ onEvent, onComplete) {
             }
         }
         catch (error) {
-            // Silently ignore parsing errors
+            // Log parsing errors when debugging
+            if (process.env.DEBUG_GRAPHLIT_STREAMING) {
+                console.error(`[Google] Error processing final response:`, error);
+            }
+        }
+        // Final summary logging
+        if (process.env.DEBUG_GRAPHLIT_STREAMING && toolCalls.length > 0) {
+            console.log(`[Google] Successfully processed ${toolCalls.length} tool calls`);
         }
         onComplete(fullMessage, toolCalls);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphlit-client",
-  "version": "1.0.20250611016",
+  "version": "1.0.20250611017",
   "description": "Graphlit API Client for TypeScript",
   "type": "module",
   "main": "./dist/client.js",