graphlit-client 1.0.20250625001 → 1.0.20250627002

package/dist/generated/graphql-types.js

@@ -75,6 +75,8 @@ export var AssemblyAiModels;
 /** Authentication service type */
 export var AuthenticationServiceTypes;
 (function (AuthenticationServiceTypes) {
+    /** Arcade authentication service */
+    AuthenticationServiceTypes["Arcade"] = "ARCADE";
     /** Auth0 authentication service */
     AuthenticationServiceTypes["Auth0"] = "AUTH0";
     /** Clerk authentication service */
@@ -501,6 +503,8 @@ export var DeepgramModels;
     DeepgramModels["Nova2Voicemail"] = "NOVA2_VOICEMAIL";
     /** Nova 3 (General) */
     DeepgramModels["Nova3"] = "NOVA3";
+    /** Nova 3 (Medical) */
+    DeepgramModels["Nova3Medical"] = "NOVA3_MEDICAL";
     /** Whisper (Base) */
     DeepgramModels["WhisperBase"] = "WHISPER_BASE";
     /** Whisper (Large) */
@@ -737,6 +741,8 @@ export var EntityTypes;
     EntityTypes["Specification"] = "SPECIFICATION";
     /** User */
     EntityTypes["User"] = "USER";
+    /** View */
+    EntityTypes["View"] = "VIEW";
     /** Workflow */
     EntityTypes["Workflow"] = "WORKFLOW";
 })(EntityTypes || (EntityTypes = {}));
@@ -953,11 +959,34 @@ export var FileTypes;
     /** Video file */
     FileTypes["Video"] = "VIDEO";
 })(FileTypes || (FileTypes = {}));
+export var GitHubAuthenticationTypes;
+(function (GitHubAuthenticationTypes) {
+    GitHubAuthenticationTypes["Connector"] = "CONNECTOR";
+    GitHubAuthenticationTypes["OAuth"] = "O_AUTH";
+    GitHubAuthenticationTypes["PersonalAccessToken"] = "PERSONAL_ACCESS_TOKEN";
+})(GitHubAuthenticationTypes || (GitHubAuthenticationTypes = {}));
+export var GitHubIssueAuthenticationTypes;
+(function (GitHubIssueAuthenticationTypes) {
+    GitHubIssueAuthenticationTypes["Connector"] = "CONNECTOR";
+    GitHubIssueAuthenticationTypes["OAuth"] = "O_AUTH";
+    GitHubIssueAuthenticationTypes["PersonalAccessToken"] = "PERSONAL_ACCESS_TOKEN";
+})(GitHubIssueAuthenticationTypes || (GitHubIssueAuthenticationTypes = {}));
+export var GoogleCalendarAuthenticationTypes;
+(function (GoogleCalendarAuthenticationTypes) {
+    GoogleCalendarAuthenticationTypes["Connector"] = "CONNECTOR";
+    GoogleCalendarAuthenticationTypes["User"] = "USER";
+})(GoogleCalendarAuthenticationTypes || (GoogleCalendarAuthenticationTypes = {}));
 export var GoogleDriveAuthenticationTypes;
 (function (GoogleDriveAuthenticationTypes) {
+    GoogleDriveAuthenticationTypes["Connector"] = "CONNECTOR";
     GoogleDriveAuthenticationTypes["ServiceAccount"] = "SERVICE_ACCOUNT";
     GoogleDriveAuthenticationTypes["User"] = "USER";
 })(GoogleDriveAuthenticationTypes || (GoogleDriveAuthenticationTypes = {}));
+export var GoogleEmailAuthenticationTypes;
+(function (GoogleEmailAuthenticationTypes) {
+    GoogleEmailAuthenticationTypes["Connector"] = "CONNECTOR";
+    GoogleEmailAuthenticationTypes["User"] = "USER";
+})(GoogleEmailAuthenticationTypes || (GoogleEmailAuthenticationTypes = {}));
 /** Google model type */
 export var GoogleModels;
 (function (GoogleModels) {
@@ -1334,6 +1363,16 @@ export var MetadataTypes;
     /** Content metadata */
     MetadataTypes["Content"] = "CONTENT";
 })(MetadataTypes || (MetadataTypes = {}));
+export var MicrosoftCalendarAuthenticationTypes;
+(function (MicrosoftCalendarAuthenticationTypes) {
+    MicrosoftCalendarAuthenticationTypes["Connector"] = "CONNECTOR";
+    MicrosoftCalendarAuthenticationTypes["User"] = "USER";
+})(MicrosoftCalendarAuthenticationTypes || (MicrosoftCalendarAuthenticationTypes = {}));
+export var MicrosoftEmailAuthenticationTypes;
+(function (MicrosoftEmailAuthenticationTypes) {
+    MicrosoftEmailAuthenticationTypes["Connector"] = "CONNECTOR";
+    MicrosoftEmailAuthenticationTypes["User"] = "USER";
+})(MicrosoftEmailAuthenticationTypes || (MicrosoftEmailAuthenticationTypes = {}));
 /** Mistral model type */
 export var MistralModels;
 (function (MistralModels) {
@@ -1459,6 +1498,11 @@ export var OccurrenceTypes;
     OccurrenceTypes["Text"] = "TEXT";
     OccurrenceTypes["Time"] = "TIME";
 })(OccurrenceTypes || (OccurrenceTypes = {}));
+export var OneDriveAuthenticationTypes;
+(function (OneDriveAuthenticationTypes) {
+    OneDriveAuthenticationTypes["Connector"] = "CONNECTOR";
+    OneDriveAuthenticationTypes["User"] = "USER";
+})(OneDriveAuthenticationTypes || (OneDriveAuthenticationTypes = {}));
 /** OpenAI Image model type */
 export var OpenAiImageModels;
 (function (OpenAiImageModels) {
@@ -1871,6 +1915,7 @@ export var SearchTypes;
 export var SharePointAuthenticationTypes;
 (function (SharePointAuthenticationTypes) {
     SharePointAuthenticationTypes["Application"] = "APPLICATION";
+    SharePointAuthenticationTypes["Connector"] = "CONNECTOR";
     SharePointAuthenticationTypes["User"] = "USER";
 })(SharePointAuthenticationTypes || (SharePointAuthenticationTypes = {}));
 /** Site type */
@@ -2120,6 +2165,12 @@ export var UserTypes;
     /** Human user */
     UserTypes["Human"] = "HUMAN";
 })(UserTypes || (UserTypes = {}));
+/** View type */
+export var ViewTypes;
+(function (ViewTypes) {
+    /** Content view */
+    ViewTypes["Content"] = "CONTENT";
+})(ViewTypes || (ViewTypes = {}));
 /** Voyage model type */
 export var VoyageModels;
 (function (VoyageModels) {

package/dist/streaming/llm-formatters.js

@@ -108,9 +108,49 @@ export function formatMessagesForAnthropic(messages) {
                 systemPrompt = trimmedMessage;
                 break;
             case ConversationRoleTypes.Assistant:
-                const content = [];
-                // Add text content
-                if (trimmedMessage) {
+                const content = []; // Use any[] to allow thinking blocks
+                // Handle thinking blocks for extended thinking preservation
+                if (trimmedMessage && trimmedMessage.includes('<thinking')) {
+                    // Extract thinking content and signature if present
+                    const thinkingMatch = trimmedMessage.match(/<thinking(?:\s+signature="([^"]*)")?>([\s\S]*?)<\/thinking>/);
+                    if (thinkingMatch) {
+                        const signature = thinkingMatch[1]; // Optional signature
+                        const thinkingContent = thinkingMatch[2].trim();
+                        // Add thinking block for conversation history preservation
+                        if (thinkingContent) {
+                            const thinkingBlock = {
+                                type: "thinking",
+                                thinking: thinkingContent,
+                            };
+                            // Add signature if present (required by Anthropic API)
+                            if (signature) {
+                                thinkingBlock.signature = signature;
+                            }
+                            else {
+                                // Provide a default signature if none captured
+                                thinkingBlock.signature = "";
+                            }
+                            content.push(thinkingBlock);
+                        }
+                        // Remove thinking tags from the main text and add remaining content
+                        const textWithoutThinking = trimmedMessage.replace(/<thinking(?:\s+[^>]*)?>[\s\S]*?<\/thinking>/g, '').trim();
+                        if (textWithoutThinking) {
+                            content.push({
+                                type: "text",
+                                text: textWithoutThinking,
+                            });
+                        }
+                    }
+                    else {
+                        // No valid thinking blocks found, add as regular text
+                        content.push({
+                            type: "text",
+                            text: trimmedMessage,
+                        });
+                    }
+                }
+                else if (trimmedMessage) {
+                    // Add regular text content
                     content.push({
                         type: "text",
                         text: trimmedMessage,
@@ -341,6 +381,12 @@ export function formatMessagesForCohere(messages) {
  * Format GraphQL conversation messages for Mistral SDK
  */
 export function formatMessagesForMistral(messages) {
+    if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+        console.log(`[Mistral Formatter] Input: ${messages.length} messages`);
+        messages.forEach((msg, idx) => {
+            console.log(`  Input ${idx}: role=${msg.role}, hasToolCalls=${!!msg.toolCalls}, toolCallId=${msg.toolCallId}`);
+        });
+    }
     const formattedMessages = [];
     for (const message of messages) {
         if (!message.role)
@@ -360,7 +406,7 @@ export function formatMessagesForMistral(messages) {
             case ConversationRoleTypes.Assistant:
                 const assistantMessage = {
                     role: "assistant",
-                    content: trimmedMessage,
+                    content: trimmedMessage || "", // Mistral expects string, not null
                 };
                 // Add tool calls if present
                 if (message.toolCalls && message.toolCalls.length > 0) {
@@ -368,6 +414,7 @@ export function formatMessagesForMistral(messages) {
                         .filter((tc) => tc !== null)
                         .map((toolCall) => ({
                         id: toolCall.id,
+                        type: "function",
                         function: {
                             name: toolCall.name,
                             arguments: toolCall.arguments,
@@ -377,10 +424,16 @@ export function formatMessagesForMistral(messages) {
                 formattedMessages.push(assistantMessage);
                 break;
             case ConversationRoleTypes.Tool:
+                if (!message.toolCallId) {
+                    console.warn(`[Mistral] Tool message missing toolCallId, skipping`);
+                    break;
+                }
+                // Mistral expects tool_call_id (snake_case) and a name field
                 formattedMessages.push({
                     role: "tool",
+                    name: message.toolName || "unknown", // Access toolName from extended message
                     content: trimmedMessage,
-                    tool_call_id: message.toolCallId || "",
+                    tool_call_id: message.toolCallId, // Mistral uses snake_case!
                 });
                 break;
             default: // User messages
@@ -415,6 +468,16 @@ export function formatMessagesForMistral(messages) {
                 break;
         }
     }
+    if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+        console.log(`[Mistral Formatter] Output: ${formattedMessages.length} messages`);
+        formattedMessages.forEach((msg, idx) => {
+            const msgWithTools = msg;
+            console.log(`  Output ${idx}: role=${msg.role}, hasToolCalls=${!!msgWithTools.tool_calls}, toolCallId=${msgWithTools.tool_call_id}`);
+            if (msgWithTools.tool_calls) {
+                console.log(`    Tool calls: ${JSON.stringify(msgWithTools.tool_calls)}`);
+            }
+        });
+    }
     return formattedMessages;
 }
 /**

package/dist/streaming/providers.d.ts

@@ -1,48 +1,53 @@
-import { ConversationToolCall, Specification, ToolDefinitionInput } from "../generated/graphql-types.js";
-import { OpenAIMessage, AnthropicMessage, GoogleMessage, CohereMessage, MistralMessage, BedrockMessage } from "./llm-formatters.js";
+import { ConversationToolCall, Specification, ToolDefinitionInput, ConversationMessage } from "../generated/graphql-types.js";
+import { OpenAIMessage, AnthropicMessage, GoogleMessage, MistralMessage, BedrockMessage } from "./llm-formatters.js";
 import { StreamEvent } from "../types/internal.js";
 /**
  * Stream with OpenAI SDK
  */
 export declare function streamWithOpenAI(specification: Specification, messages: OpenAIMessage[], tools: ToolDefinitionInput[] | undefined, openaiClient: any, // OpenAI client instance
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void, abortSignal?: AbortSignal): Promise<void>;
 /**
  * Stream with Anthropic SDK
  */
-export declare function streamWithAnthropic(specification: Specification, messages: AnthropicMessage[], systemPrompt: string | undefined, tools: ToolDefinitionInput[] | undefined, anthropicClient: any, // Anthropic client instance
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void): Promise<void>;
+type AnthropicClient = import("@anthropic-ai/sdk").default;
+export declare function streamWithAnthropic(specification: Specification, messages: AnthropicMessage[], systemPrompt: string | undefined, tools: ToolDefinitionInput[] | undefined, anthropicClient: AnthropicClient, // Properly typed Anthropic client
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void, abortSignal?: AbortSignal, thinkingConfig?: {
+    type: "enabled";
+    budget_tokens: number;
+}): Promise<void>;
 /**
  * Stream with Google SDK
  */
 export declare function streamWithGoogle(specification: Specification, messages: GoogleMessage[], systemPrompt: string | undefined, tools: ToolDefinitionInput[] | undefined, googleClient: any, // Google GenerativeAI client instance
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void, abortSignal?: AbortSignal): Promise<void>;
 /**
  * Stream with Groq SDK (OpenAI-compatible)
  */
 export declare function streamWithGroq(specification: Specification, messages: OpenAIMessage[], tools: ToolDefinitionInput[] | undefined, groqClient: any, // Groq client instance (OpenAI-compatible)
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void, abortSignal?: AbortSignal): Promise<void>;
 /**
  * Stream with Cerebras SDK (OpenAI-compatible)
  */
 export declare function streamWithCerebras(specification: Specification, messages: OpenAIMessage[], tools: ToolDefinitionInput[] | undefined, cerebrasClient: any, // OpenAI client instance configured for Cerebras
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void, abortSignal?: AbortSignal): Promise<void>;
 /**
  * Stream with Deepseek SDK (OpenAI-compatible)
  */
 export declare function streamWithDeepseek(specification: Specification, messages: OpenAIMessage[], tools: ToolDefinitionInput[] | undefined, deepseekClient: any, // OpenAI client instance configured for Deepseek
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void, abortSignal?: AbortSignal): Promise<void>;
 /**
  * Stream with Cohere SDK
  */
-export declare function streamWithCohere(specification: Specification, messages: CohereMessage[], tools: ToolDefinitionInput[] | undefined, cohereClient: any, // CohereClient instance
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void): Promise<void>;
+export declare function streamWithCohere(specification: Specification, messages: ConversationMessage[], tools: ToolDefinitionInput[] | undefined, cohereClient: any, // CohereClient instance
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void, abortSignal?: AbortSignal): Promise<void>;
 /**
  * Stream with Mistral SDK
  */
 export declare function streamWithMistral(specification: Specification, messages: MistralMessage[], tools: ToolDefinitionInput[] | undefined, mistralClient: any, // Mistral client instance
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void, abortSignal?: AbortSignal): Promise<void>;
 /**
  * Stream with Bedrock SDK (for Claude models)
  */
 export declare function streamWithBedrock(specification: Specification, messages: BedrockMessage[], systemPrompt: string | undefined, tools: ToolDefinitionInput[] | undefined, bedrockClient: any, // BedrockRuntimeClient instance
-onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void): Promise<void>;
+onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[]) => void, abortSignal?: AbortSignal): Promise<void>;
+export {};