graphlit-client 1.0.20250610009 → 1.0.20250610010

package/dist/client.d.ts

@@ -2,40 +2,6 @@ import { ApolloClient, NormalizedCacheObject } from "@apollo/client/core";
 import * as Types from "./generated/graphql-types.js";
 import { AgentOptions, AgentResult, StreamAgentOptions, ToolHandler } from "./types/agent.js";
 import { AgentStreamEvent } from "./types/ui-events.js";
-export type StreamEvent = {
-    type: "start";
-    conversationId: string;
-} | {
-    type: "token";
-    token: string;
-} | {
-    type: "message";
-    message: string;
-} | {
-    type: "tool_call_start";
-    toolCall: {
-        id: string;
-        name: string;
-    };
-} | {
-    type: "tool_call_delta";
-    toolCallId: string;
-    argumentDelta: string;
-} | {
-    type: "tool_call_complete";
-    toolCall: {
-        id: string;
-        name: string;
-        arguments: string;
-    };
-} | {
-    type: "complete";
-    messageId?: string;
-    conversationId?: string;
-} | {
-    type: "error";
-    error: string;
-};
 export type { AgentOptions, AgentResult, StreamAgentOptions, ToolCallResult, UsageInfo, AgentError, } from "./types/agent.js";
 export type { AgentStreamEvent } from "./types/ui-events.js";
 declare class Graphlit {
@@ -376,7 +342,7 @@ declare class Graphlit {
      * @param options - Stream agent options
      * @throws Error if streaming is not supported
      */
-    streamAgent(prompt: string, onEvent: (event: StreamEvent | AgentStreamEvent) => void, conversationId?: string, specification?: Types.EntityReferenceInput, tools?: Types.ToolDefinitionInput[], toolHandlers?: Record<string, ToolHandler>, options?: StreamAgentOptions, mimeType?: string, data?: string, // base64 encoded
+    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>;
     /**
      * Execute the streaming agent workflow with tool calling loop
@@ -417,4 +383,3 @@ declare class Graphlit {
 }
 export { Graphlit };
 export * as Types from "./generated/graphql-types.js";
-export { StreamEventAggregator, AggregatedEvent, formatSSEEvent, createSSEStream, wrapToolHandlers, enhanceToolCalls, ConversationMetrics, ToolResultEmitter, ServerMapping, } from "./stream-helpers.js";

package/dist/client.js

@@ -2113,5 +2113,3 @@ class Graphlit {
 }
 export { Graphlit };
 export * as Types from "./generated/graphql-types.js";
-// Export streaming helpers
-export { StreamEventAggregator, formatSSEEvent, createSSEStream, wrapToolHandlers, enhanceToolCalls, ConversationMetrics, } from "./stream-helpers.js";

package/dist/streaming/providers.d.ts

@@ -1,6 +1,6 @@
 import { ConversationToolCall, Specification, ToolDefinitionInput } from "../generated/graphql-types.js";
-import { StreamEvent } from "../client.js";
 import { OpenAIMessage, AnthropicMessage, GoogleMessage } from "./llm-formatters.js";
+import { StreamEvent } from "../types/internal.js";
 /**
  * Stream with OpenAI SDK
  */

package/dist/streaming/ui-event-adapter.d.ts

@@ -1,5 +1,5 @@
 import { AgentStreamEvent } from "../types/ui-events.js";
-import { StreamEvent } from "../client.js";
+import { StreamEvent } from "../types/internal.js";
 import { ChunkingStrategy } from "./chunk-buffer.js";
 /**
  * Adapter that transforms low-level streaming events into high-level UI events

package/dist/types/internal.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Internal types used by the streaming implementation
+ * These are not exported to consumers of the library
+ */
+/**
+ * Low-level streaming events used internally by providers
+ * These get transformed into AgentStreamEvent by UIEventAdapter
+ */
+export type StreamEvent = {
+    type: "start";
+    conversationId: string;
+} | {
+    type: "token";
+    token: string;
+} | {
+    type: "message";
+    message: string;
+} | {
+    type: "tool_call_start";
+    toolCall: {
+        id: string;
+        name: string;
+    };
+} | {
+    type: "tool_call_delta";
+    toolCallId: string;
+    argumentDelta: string;
+} | {
+    type: "tool_call_complete";
+    toolCall: {
+        id: string;
+        name: string;
+        arguments: string;
+    };
+} | {
+    type: "complete";
+    messageId?: string;
+    conversationId?: string;
+} | {
+    type: "error";
+    error: string;
+};

package/dist/types/internal.js

@@ -0,0 +1,5 @@
+/**
+ * Internal types used by the streaming implementation
+ * These are not exported to consumers of the library
+ */
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphlit-client",
-  "version": "1.0.20250610009",
+  "version": "1.0.20250610010",
   "description": "Graphlit API Client for TypeScript",
   "main": "dist/client.js",
   "types": "dist/client.d.ts",

package/dist/stream-helpers.d.ts

@@ -1,106 +0,0 @@
-import { StreamEvent } from "./client.js";
-import { ConversationRoleTypes } from "./generated/graphql-types.js";
-export declare class StreamEventAggregator {
-    private conversationId;
-    private messageBuffer;
-    private toolCallsBuffer;
-    private isFirstAssistantMessage;
-    private hasReceivedToolCalls;
-    private tokenBuffer;
-    /**
-     * Process a stream event and return any complete messages ready for the UI
-     */
-    processEvent(event: StreamEvent): AggregatedEvent | null;
-    /**
-     * Reset the aggregator for a new conversation
-     */
-    reset(): void;
-    /**
-     * Get current state (useful for debugging)
-     */
-    getState(): {
-        conversationId: string;
-        messageBuffer: string;
-        toolCallsCount: number;
-        hasReceivedToolCalls: boolean;
-        isFirstAssistantMessage: boolean;
-        tokenCount: number;
-    };
-}
-/**
- * Aggregated event types that are ready for UI consumption
- */
-export type AggregatedEvent = {
-    type: "conversationStarted";
-    conversationId: string;
-} | {
-    type: "token";
-    token: string;
-    accumulated: string;
-} | {
-    type: "assistantMessage";
-    message: {
-        message?: string | null;
-        role?: ConversationRoleTypes | null;
-        toolCalls?: any[];
-    };
-    isFinal: boolean;
-    conversationId?: string;
-} | {
-    type: "streamComplete";
-    conversationId?: string;
-} | {
-    type: "error";
-    error: string;
-};
-/**
- * Helper to create an SSE response with proper formatting
- */
-export declare function formatSSEEvent(data: any, eventName?: string): string;
-/**
- * Helper to create a TransformStream for SSE with built-in ping support
- */
-export declare function createSSEStream(options?: {
-    pingInterval?: number;
-}): {
-    readable: ReadableStream<any>;
-    sendEvent: (data: any, eventName?: string) => Promise<void>;
-    close: () => Promise<void>;
-    writer: WritableStreamDefaultWriter<any>;
-};
-/**
- * Helper to wrap tool handlers with result emission
- */
-export interface ToolResultEmitter {
-    (toolCallId: string, result: any, status: "complete" | "error" | "blocked", duration: number): void;
-}
-export declare function wrapToolHandlers(handlers: Record<string, (args: any) => Promise<any>>, emitResult: ToolResultEmitter): Record<string, (args: any) => Promise<any>>;
-/**
- * Helper to enhance tool calls with server information
- */
-export interface ServerMapping {
-    toolName: string;
-    serverName: string;
-    serverId: string;
-}
-export declare function enhanceToolCalls(toolCalls: any[], serverMappings: ServerMapping[]): any[];
-/**
- * Helper to track conversation metrics
- */
-export declare class ConversationMetrics {
-    private startTime;
-    private tokenCount;
-    private toolCallCount;
-    private errorCount;
-    recordToken(): void;
-    recordToolCall(): void;
-    recordError(): void;
-    getMetrics(): {
-        duration: number;
-        tokenCount: number;
-        toolCallCount: number;
-        errorCount: number;
-        tokensPerSecond: number;
-    };
-    reset(): void;
-}

package/dist/stream-helpers.js

@@ -1,237 +0,0 @@
-import { ConversationRoleTypes, } from "./generated/graphql-types.js";
-export class StreamEventAggregator {
-    conversationId = "";
-    messageBuffer = "";
-    toolCallsBuffer = new Map();
-    isFirstAssistantMessage = true;
-    hasReceivedToolCalls = false;
-    tokenBuffer = [];
-    /**
-     * Process a stream event and return any complete messages ready for the UI
-     */
-    processEvent(event) {
-        switch (event.type) {
-            case "start":
-                this.conversationId = event.conversationId;
-                return {
-                    type: "conversationStarted",
-                    conversationId: event.conversationId,
-                };
-            case "token":
-                this.messageBuffer += event.token;
-                this.tokenBuffer.push(event.token);
-                return {
-                    type: "token",
-                    token: event.token,
-                    accumulated: this.messageBuffer,
-                };
-            case "message":
-                // SDK provides accumulated message - we can use this instead of our buffer
-                this.messageBuffer = event.message;
-                return null; // Don't emit, wait for complete event
-            case "tool_call_start":
-                this.hasReceivedToolCalls = true;
-                this.toolCallsBuffer.set(event.toolCall.id, {
-                    id: event.toolCall.id,
-                    name: event.toolCall.name,
-                    argumentsBuffer: "",
-                    isComplete: false,
-                    startTime: Date.now(),
-                });
-                return null; // Buffer until complete
-            case "tool_call_delta":
-                const toolCall = this.toolCallsBuffer.get(event.toolCallId);
-                if (toolCall) {
-                    toolCall.argumentsBuffer += event.argumentDelta;
-                }
-                return null; // Buffer until complete
-            case "tool_call_complete":
-                const completeToolCall = this.toolCallsBuffer.get(event.toolCall.id);
-                if (completeToolCall) {
-                    completeToolCall.argumentsBuffer = event.toolCall.arguments;
-                    completeToolCall.isComplete = true;
-                }
-                // Check if all tool calls are complete
-                const allComplete = Array.from(this.toolCallsBuffer.values()).every((tc) => tc.isComplete);
-                if (allComplete &&
-                    this.hasReceivedToolCalls &&
-                    this.isFirstAssistantMessage) {
-                    // Emit complete assistant message with all tool calls
-                    const toolCalls = Array.from(this.toolCallsBuffer.values()).map((tc) => ({
-                        id: tc.id,
-                        name: tc.name,
-                        arguments: tc.argumentsBuffer,
-                        status: "pending",
-                    }));
-                    this.isFirstAssistantMessage = false;
-                    return {
-                        type: "assistantMessage",
-                        message: {
-                            message: this.messageBuffer,
-                            role: ConversationRoleTypes.Assistant,
-                            toolCalls,
-                        },
-                        isFinal: false,
-                    };
-                }
-                return null;
-            case "complete":
-                // If we haven't sent a message yet (no tool calls), send it now
-                if (this.isFirstAssistantMessage && !this.hasReceivedToolCalls) {
-                    return {
-                        type: "assistantMessage",
-                        message: {
-                            message: this.messageBuffer,
-                            role: ConversationRoleTypes.Assistant,
-                        },
-                        isFinal: true,
-                        conversationId: event.conversationId,
-                    };
-                }
-                return { type: "streamComplete", conversationId: event.conversationId };
-            case "error":
-                return { type: "error", error: event.error };
-            default:
-                return null;
-        }
-    }
-    /**
-     * Reset the aggregator for a new conversation
-     */
-    reset() {
-        this.conversationId = "";
-        this.messageBuffer = "";
-        this.toolCallsBuffer.clear();
-        this.isFirstAssistantMessage = true;
-        this.hasReceivedToolCalls = false;
-        this.tokenBuffer = [];
-    }
-    /**
-     * Get current state (useful for debugging)
-     */
-    getState() {
-        return {
-            conversationId: this.conversationId,
-            messageBuffer: this.messageBuffer,
-            toolCallsCount: this.toolCallsBuffer.size,
-            hasReceivedToolCalls: this.hasReceivedToolCalls,
-            isFirstAssistantMessage: this.isFirstAssistantMessage,
-            tokenCount: this.tokenBuffer.length,
-        };
-    }
-}
-/**
- * Helper to create an SSE response with proper formatting
- */
-export function formatSSEEvent(data, eventName = "message") {
-    if (typeof data === "string") {
-        return `event: ${eventName}\ndata: ${data}\n\n`;
-    }
-    return `event: ${eventName}\ndata: ${JSON.stringify(data)}\n\n`;
-}
-/**
- * Helper to create a TransformStream for SSE with built-in ping support
- */
-export function createSSEStream(options) {
-    const encoder = new TextEncoder();
-    const { readable, writable } = new TransformStream();
-    const writer = writable.getWriter();
-    let pingInterval = null;
-    if (options?.pingInterval) {
-        pingInterval = globalThis.setInterval(() => {
-            writer.write(encoder.encode(":\n\n")).catch(() => {
-                // Ignore errors on ping
-            });
-        }, options.pingInterval);
-    }
-    const sendEvent = (data, eventName = "message") => {
-        const formatted = formatSSEEvent(data, eventName);
-        return writer.write(encoder.encode(formatted));
-    };
-    const close = async () => {
-        if (pingInterval) {
-            globalThis.clearInterval(pingInterval);
-        }
-        await writer.close();
-    };
-    return {
-        readable,
-        sendEvent,
-        close,
-        writer,
-    };
-}
-export function wrapToolHandlers(handlers, emitResult) {
-    const wrapped = {};
-    Object.entries(handlers).forEach(([name, handler]) => {
-        wrapped[name] = async (args) => {
-            const toolCallId = `tool_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-            const startTime = Date.now();
-            try {
-                const result = await handler(args);
-                const duration = Date.now() - startTime;
-                // Emit success result
-                emitResult(toolCallId, { status: "success", result }, "complete", duration);
-                return result;
-            }
-            catch (error) {
-                const duration = Date.now() - startTime;
-                // Emit error result
-                emitResult(toolCallId, {
-                    status: "error",
-                    error: error instanceof Error ? error.message : String(error),
-                }, "error", duration);
-                throw error;
-            }
-        };
-    });
-    return wrapped;
-}
-export function enhanceToolCalls(toolCalls, serverMappings) {
-    const mappingDict = serverMappings.reduce((acc, mapping) => {
-        acc[mapping.toolName] = {
-            serverName: mapping.serverName,
-            serverId: mapping.serverId,
-        };
-        return acc;
-    }, {});
-    return toolCalls.map((toolCall) => ({
-        ...toolCall,
-        serverName: mappingDict[toolCall.name]?.serverName,
-        serverId: mappingDict[toolCall.name]?.serverId,
-    }));
-}
-/**
- * Helper to track conversation metrics
- */
-export class ConversationMetrics {
-    startTime = Date.now();
-    tokenCount = 0;
-    toolCallCount = 0;
-    errorCount = 0;
-    recordToken() {
-        this.tokenCount++;
-    }
-    recordToolCall() {
-        this.toolCallCount++;
-    }
-    recordError() {
-        this.errorCount++;
-    }
-    getMetrics() {
-        const duration = Date.now() - this.startTime;
-        return {
-            duration,
-            tokenCount: this.tokenCount,
-            toolCallCount: this.toolCallCount,
-            errorCount: this.errorCount,
-            tokensPerSecond: this.tokenCount / (duration / 1000),
-        };
-    }
-    reset() {
-        this.startTime = Date.now();
-        this.tokenCount = 0;
-        this.toolCallCount = 0;
-        this.errorCount = 0;
-    }
-}