graphlit-client 1.0.20250612009 → 1.0.20250613002

package/dist/client.d.ts

@@ -86,6 +86,7 @@ declare class Graphlit {
     publishContents(publishPrompt: string, connector: Types.ContentPublishingConnectorInput, summaryPrompt?: string, summarySpecification?: Types.EntityReferenceInput, publishSpecification?: Types.EntityReferenceInput, name?: string, filter?: Types.ContentFilter, workflow?: Types.EntityReferenceInput, isSynchronous?: boolean, includeDetails?: boolean, correlationId?: string): Promise<Types.PublishContentsMutation>;
     publishText(text: string, textType: Types.TextTypes, connector: Types.ContentPublishingConnectorInput, name?: string, workflow?: Types.EntityReferenceInput, isSynchronous?: boolean, correlationId?: string): Promise<Types.PublishTextMutation>;
     getContent(id: string): Promise<Types.GetContentQuery>;
+    lookupContents(ids: string[]): Promise<Types.LookupContentsResults>;
     queryContents(filter?: Types.ContentFilter): Promise<Types.QueryContentsQuery>;
     queryContentsFacets(filter?: Types.ContentFilter): Promise<Types.QueryContentsFacetsQuery>;
     queryContentsGraph(filter?: Types.ContentFilter): Promise<Types.QueryContentsGraphQuery>;

package/dist/client.js

@@ -489,6 +489,9 @@ class Graphlit {
     async getContent(id) {
         return this.queryAndCheckError(Documents.GetContent, { id: id });
     }
+    async lookupContents(ids) {
+        return this.queryAndCheckError(Documents.LookupContents, { ids: ids });
+    }
     async queryContents(filter) {
         return this.queryAndCheckError(Documents.QueryContents, { filter: filter });
     }
@@ -1980,14 +1983,21 @@ class Graphlit {
             }
             currentRound++;
         }
-        // Complete the conversation
+        // Complete the conversation and get token count
+        let finalTokens;
         if (fullMessage) {
-            await this.completeConversation(fullMessage.trim(), conversationId, correlationId);
+            const completeResponse = await this.completeConversation(fullMessage.trim(), conversationId, correlationId);
+            // Extract token count from the response
+            finalTokens = completeResponse.completeConversation?.message?.tokens ?? undefined;
+            if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                console.log(`📊 [completeConversation] Tokens used: ${finalTokens || 'unknown'}`);
+            }
         }
-        // Emit completion event
+        // Emit completion event with token count
         uiAdapter.handleEvent({
             type: "complete",
             conversationId,
+            tokens: finalTokens,
         });
     }
     /**

package/dist/generated/graphql-documents.d.ts

@@ -44,6 +44,7 @@ export declare const IngestText: import("graphql").DocumentNode;
 export declare const IngestTextBatch: import("graphql").DocumentNode;
 export declare const IngestUri: import("graphql").DocumentNode;
 export declare const IsContentDone: import("graphql").DocumentNode;
+export declare const LookupContents: import("graphql").DocumentNode;
 export declare const PublishContents: import("graphql").DocumentNode;
 export declare const PublishText: import("graphql").DocumentNode;
 export declare const QueryContents: import("graphql").DocumentNode;

package/dist/generated/graphql-documents.js

@@ -1583,6 +1583,293 @@ export const IsContentDone = gql `
   }
 }
     `;
+export const LookupContents = gql `
+    query LookupContents($ids: [ID!]!, $correlationId: String) {
+  lookupContents(ids: $ids, correlationId: $correlationId) {
+    results {
+      id
+      name
+      creationDate
+      owner {
+        id
+      }
+      state
+      originalDate
+      finishedDate
+      fileCreationDate
+      fileModifiedDate
+      workflowDuration
+      uri
+      description
+      identifier
+      markdown
+      address {
+        streetAddress
+        city
+        region
+        country
+        postalCode
+      }
+      location {
+        latitude
+        longitude
+      }
+      h3 {
+        h3r0
+        h3r1
+        h3r2
+        h3r3
+        h3r4
+        h3r5
+        h3r6
+        h3r7
+        h3r8
+        h3r9
+        h3r10
+        h3r11
+        h3r12
+        h3r13
+        h3r14
+        h3r15
+      }
+      boundary
+      epsgCode
+      path
+      features
+      c4id
+      type
+      fileType
+      mimeType
+      format
+      formatName
+      fileName
+      fileSize
+      masterUri
+      imageUri
+      textUri
+      audioUri
+      transcriptUri
+      summary
+      customSummary
+      keywords
+      bullets
+      headlines
+      posts
+      chapters
+      questions
+      video {
+        width
+        height
+        duration
+        make
+        model
+        software
+        title
+        description
+        keywords
+        author
+      }
+      audio {
+        keywords
+        author
+        series
+        episode
+        episodeType
+        season
+        publisher
+        copyright
+        genre
+        title
+        description
+        bitrate
+        channels
+        sampleRate
+        bitsPerSample
+        duration
+      }
+      image {
+        width
+        height
+        resolutionX
+        resolutionY
+        bitsPerComponent
+        components
+        projectionType
+        orientation
+        description
+        make
+        model
+        software
+        lens
+        focalLength
+        exposureTime
+        fNumber
+        iso
+        heading
+        pitch
+      }
+      document {
+        title
+        subject
+        summary
+        author
+        publisher
+        description
+        keywords
+        pageCount
+        worksheetCount
+        slideCount
+        wordCount
+        lineCount
+        paragraphCount
+        isEncrypted
+        hasDigitalSignature
+      }
+      email {
+        identifier
+        threadIdentifier
+        subject
+        labels
+        sensitivity
+        priority
+        importance
+        from {
+          name
+          email
+          givenName
+          familyName
+        }
+        to {
+          name
+          email
+          givenName
+          familyName
+        }
+        cc {
+          name
+          email
+          givenName
+          familyName
+        }
+        bcc {
+          name
+          email
+          givenName
+          familyName
+        }
+      }
+      issue {
+        identifier
+        title
+        project
+        team
+        status
+        priority
+        type
+        labels
+      }
+      package {
+        fileCount
+        folderCount
+        isEncrypted
+      }
+      language {
+        languages
+      }
+      parent {
+        id
+        name
+      }
+      children {
+        id
+        name
+      }
+      feed {
+        id
+        name
+      }
+      collections {
+        id
+        name
+      }
+      links {
+        uri
+        linkType
+      }
+      observations {
+        id
+        type
+        observable {
+          id
+          name
+        }
+        related {
+          id
+          name
+        }
+        relatedType
+        relation
+        occurrences {
+          type
+          confidence
+          startTime
+          endTime
+          pageIndex
+          boundingBox {
+            left
+            top
+            width
+            height
+          }
+        }
+        state
+      }
+      workflow {
+        id
+        name
+      }
+      pages {
+        index
+        text
+        relevance
+        images {
+          id
+          mimeType
+          data
+          left
+          right
+          top
+          bottom
+        }
+        chunks {
+          index
+          pageIndex
+          rowIndex
+          columnIndex
+          confidence
+          text
+          role
+          language
+          relevance
+        }
+      }
+      segments {
+        startTime
+        endTime
+        text
+        relevance
+      }
+      frames {
+        index
+        description
+        text
+        relevance
+      }
+      error
+    }
+  }
+}
+    `;
 export const PublishContents = gql `
     mutation PublishContents($summaryPrompt: String, $publishPrompt: String!, $connector: ContentPublishingConnectorInput!, $filter: ContentFilter, $includeDetails: Boolean, $isSynchronous: Boolean, $correlationId: String, $name: String, $summarySpecification: EntityReferenceInput, $publishSpecification: EntityReferenceInput, $workflow: EntityReferenceInput) {
   publishContents(

package/dist/generated/graphql-types.d.ts

@@ -15784,6 +15784,330 @@ export type IsContentDoneQuery = {
         result?: boolean | null;
     } | null;
 };
+export type LookupContentsQueryVariables = Exact<{
+    ids: Array<Scalars['ID']['input']> | Scalars['ID']['input'];
+    correlationId?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type LookupContentsQuery = {
+    __typename?: 'Query';
+    lookupContents?: {
+        __typename?: 'LookupContentsResults';
+        results?: Array<{
+            __typename?: 'Content';
+            id: string;
+            name: string;
+            creationDate: any;
+            state: EntityState;
+            originalDate?: any | null;
+            finishedDate?: any | null;
+            fileCreationDate?: any | null;
+            fileModifiedDate?: any | null;
+            workflowDuration?: any | null;
+            uri?: any | null;
+            description?: string | null;
+            identifier?: string | null;
+            markdown?: string | null;
+            boundary?: string | null;
+            epsgCode?: number | null;
+            path?: string | null;
+            features?: string | null;
+            c4id?: string | null;
+            type?: ContentTypes | null;
+            fileType?: FileTypes | null;
+            mimeType?: string | null;
+            format?: string | null;
+            formatName?: string | null;
+            fileName?: string | null;
+            fileSize?: any | null;
+            masterUri?: any | null;
+            imageUri?: any | null;
+            textUri?: any | null;
+            audioUri?: any | null;
+            transcriptUri?: any | null;
+            summary?: string | null;
+            customSummary?: string | null;
+            keywords?: Array<string> | null;
+            bullets?: Array<string> | null;
+            headlines?: Array<string> | null;
+            posts?: Array<string> | null;
+            chapters?: Array<string> | null;
+            questions?: Array<string> | null;
+            error?: string | null;
+            owner: {
+                __typename?: 'Owner';
+                id: string;
+            };
+            address?: {
+                __typename?: 'Address';
+                streetAddress?: string | null;
+                city?: string | null;
+                region?: string | null;
+                country?: string | null;
+                postalCode?: string | null;
+            } | null;
+            location?: {
+                __typename?: 'Point';
+                latitude?: number | null;
+                longitude?: number | null;
+            } | null;
+            h3?: {
+                __typename?: 'H3';
+                h3r0?: string | null;
+                h3r1?: string | null;
+                h3r2?: string | null;
+                h3r3?: string | null;
+                h3r4?: string | null;
+                h3r5?: string | null;
+                h3r6?: string | null;
+                h3r7?: string | null;
+                h3r8?: string | null;
+                h3r9?: string | null;
+                h3r10?: string | null;
+                h3r11?: string | null;
+                h3r12?: string | null;
+                h3r13?: string | null;
+                h3r14?: string | null;
+                h3r15?: string | null;
+            } | null;
+            video?: {
+                __typename?: 'VideoMetadata';
+                width?: number | null;
+                height?: number | null;
+                duration?: any | null;
+                make?: string | null;
+                model?: string | null;
+                software?: string | null;
+                title?: string | null;
+                description?: string | null;
+                keywords?: Array<string | null> | null;
+                author?: string | null;
+            } | null;
+            audio?: {
+                __typename?: 'AudioMetadata';
+                keywords?: Array<string | null> | null;
+                author?: string | null;
+                series?: string | null;
+                episode?: string | null;
+                episodeType?: string | null;
+                season?: string | null;
+                publisher?: string | null;
+                copyright?: string | null;
+                genre?: string | null;
+                title?: string | null;
+                description?: string | null;
+                bitrate?: number | null;
+                channels?: number | null;
+                sampleRate?: number | null;
+                bitsPerSample?: number | null;
+                duration?: any | null;
+            } | null;
+            image?: {
+                __typename?: 'ImageMetadata';
+                width?: number | null;
+                height?: number | null;
+                resolutionX?: number | null;
+                resolutionY?: number | null;
+                bitsPerComponent?: number | null;
+                components?: number | null;
+                projectionType?: ImageProjectionTypes | null;
+                orientation?: OrientationTypes | null;
+                description?: string | null;
+                make?: string | null;
+                model?: string | null;
+                software?: string | null;
+                lens?: string | null;
+                focalLength?: number | null;
+                exposureTime?: string | null;
+                fNumber?: string | null;
+                iso?: string | null;
+                heading?: number | null;
+                pitch?: number | null;
+            } | null;
+            document?: {
+                __typename?: 'DocumentMetadata';
+                title?: string | null;
+                subject?: string | null;
+                summary?: string | null;
+                author?: string | null;
+                publisher?: string | null;
+                description?: string | null;
+                keywords?: Array<string | null> | null;
+                pageCount?: number | null;
+                worksheetCount?: number | null;
+                slideCount?: number | null;
+                wordCount?: number | null;
+                lineCount?: number | null;
+                paragraphCount?: number | null;
+                isEncrypted?: boolean | null;
+                hasDigitalSignature?: boolean | null;
+            } | null;
+            email?: {
+                __typename?: 'EmailMetadata';
+                identifier?: string | null;
+                threadIdentifier?: string | null;
+                subject?: string | null;
+                labels?: Array<string | null> | null;
+                sensitivity?: MailSensitivity | null;
+                priority?: MailPriority | null;
+                importance?: MailImportance | null;
+                from?: Array<{
+                    __typename?: 'PersonReference';
+                    name?: string | null;
+                    email?: string | null;
+                    givenName?: string | null;
+                    familyName?: string | null;
+                } | null> | null;
+                to?: Array<{
+                    __typename?: 'PersonReference';
+                    name?: string | null;
+                    email?: string | null;
+                    givenName?: string | null;
+                    familyName?: string | null;
+                } | null> | null;
+                cc?: Array<{
+                    __typename?: 'PersonReference';
+                    name?: string | null;
+                    email?: string | null;
+                    givenName?: string | null;
+                    familyName?: string | null;
+                } | null> | null;
+                bcc?: Array<{
+                    __typename?: 'PersonReference';
+                    name?: string | null;
+                    email?: string | null;
+                    givenName?: string | null;
+                    familyName?: string | null;
+                } | null> | null;
+            } | null;
+            issue?: {
+                __typename?: 'IssueMetadata';
+                identifier?: string | null;
+                title?: string | null;
+                project?: string | null;
+                team?: string | null;
+                status?: string | null;
+                priority?: string | null;
+                type?: string | null;
+                labels?: Array<string | null> | null;
+            } | null;
+            package?: {
+                __typename?: 'PackageMetadata';
+                fileCount?: number | null;
+                folderCount?: number | null;
+                isEncrypted?: boolean | null;
+            } | null;
+            language?: {
+                __typename?: 'LanguageMetadata';
+                languages?: Array<string | null> | null;
+            } | null;
+            parent?: {
+                __typename?: 'Content';
+                id: string;
+                name: string;
+            } | null;
+            children?: Array<{
+                __typename?: 'Content';
+                id: string;
+                name: string;
+            } | null> | null;
+            feed?: {
+                __typename?: 'Feed';
+                id: string;
+                name: string;
+            } | null;
+            collections?: Array<{
+                __typename?: 'Collection';
+                id: string;
+                name: string;
+            } | null> | null;
+            links?: Array<{
+                __typename?: 'LinkReference';
+                uri?: any | null;
+                linkType?: LinkTypes | null;
+            }> | null;
+            observations?: Array<{
+                __typename?: 'Observation';
+                id: string;
+                type: ObservableTypes;
+                relatedType?: ObservableTypes | null;
+                relation?: string | null;
+                state: EntityState;
+                observable: {
+                    __typename?: 'NamedEntityReference';
+                    id: string;
+                    name?: string | null;
+                };
+                related?: {
+                    __typename?: 'NamedEntityReference';
+                    id: string;
+                    name?: string | null;
+                } | null;
+                occurrences?: Array<{
+                    __typename?: 'ObservationOccurrence';
+                    type?: OccurrenceTypes | null;
+                    confidence?: number | null;
+                    startTime?: any | null;
+                    endTime?: any | null;
+                    pageIndex?: number | null;
+                    boundingBox?: {
+                        __typename?: 'BoundingBox';
+                        left?: number | null;
+                        top?: number | null;
+                        width?: number | null;
+                        height?: number | null;
+                    } | null;
+                } | null> | null;
+            } | null> | null;
+            workflow?: {
+                __typename?: 'Workflow';
+                id: string;
+                name: string;
+            } | null;
+            pages?: Array<{
+                __typename?: 'TextPage';
+                index?: number | null;
+                text?: string | null;
+                relevance?: number | null;
+                images?: Array<{
+                    __typename?: 'ImageChunk';
+                    id?: string | null;
+                    mimeType?: string | null;
+                    data?: string | null;
+                    left?: number | null;
+                    right?: number | null;
+                    top?: number | null;
+                    bottom?: number | null;
+                } | null> | null;
+                chunks?: Array<{
+                    __typename?: 'TextChunk';
+                    index?: number | null;
+                    pageIndex?: number | null;
+                    rowIndex?: number | null;
+                    columnIndex?: number | null;
+                    confidence?: number | null;
+                    text?: string | null;
+                    role?: TextRoles | null;
+                    language?: string | null;
+                    relevance?: number | null;
+                } | null> | null;
+            }> | null;
+            segments?: Array<{
+                __typename?: 'TextSegment';
+                startTime?: any | null;
+                endTime?: any | null;
+                text?: string | null;
+                relevance?: number | null;
+            }> | null;
+            frames?: Array<{
+                __typename?: 'TextFrame';
+                index?: number | null;
+                description?: string | null;
+                text?: string | null;
+                relevance?: number | null;
+            }> | null;
+        } | null> | null;
+    } | null;
+};
 export type PublishContentsMutationVariables = Exact<{
     summaryPrompt?: InputMaybe<Scalars['String']['input']>;
     publishPrompt: Scalars['String']['input'];

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

@@ -13,9 +13,11 @@ export declare class UIEventAdapter {
     private tokenCount;
     private currentMessage;
     private isStreaming;
+    private conversationStartTime;
     private streamStartTime;
     private firstTokenTime;
     private lastTokenTime;
+    private tokenDelays;
     private activeToolCalls;
     private lastUpdateTime;
     private updateTimer?;

package/dist/streaming/ui-event-adapter.js

@@ -12,9 +12,11 @@ export class UIEventAdapter {
     tokenCount = 0;
     currentMessage = "";
     isStreaming = false;
-    streamStartTime = 0;
+    conversationStartTime = 0; // When user sent the message
+    streamStartTime = 0; // When streaming actually began
     firstTokenTime = 0;
     lastTokenTime = 0;
+    tokenDelays = [];
     activeToolCalls = new Map();
     lastUpdateTime = 0;
     updateTimer;
@@ -27,6 +29,7 @@ export class UIEventAdapter {
         this.smoothingDelay = options.smoothingDelay ?? 30;
         this.model = options.model;
         this.modelService = options.modelService;
+        this.conversationStartTime = Date.now(); // Capture when conversation began
         if (options.smoothingEnabled) {
             this.chunkBuffer = new ChunkBuffer(options.chunkingStrategy || "word");
         }
@@ -55,7 +58,7 @@ export class UIEventAdapter {
                 this.handleToolCallComplete(event.toolCall);
                 break;
             case "complete":
-                this.handleComplete();
+                this.handleComplete(event.tokens);
                 break;
             case "error":
                 this.handleError(event.error);
@@ -94,6 +97,8 @@ export class UIEventAdapter {
         this.streamStartTime = Date.now();
         this.firstTokenTime = 0;
         this.lastTokenTime = 0;
+        this.tokenCount = 0;
+        this.tokenDelays = [];
         this.emitUIEvent({
             type: "conversation_started",
             conversationId,
@@ -107,7 +112,12 @@ export class UIEventAdapter {
         if (this.firstTokenTime === 0) {
             this.firstTokenTime = now;
         }
+        // Track inter-token delays
+        if (this.lastTokenTime > 0) {
+            this.tokenDelays.push(now - this.lastTokenTime);
+        }
         this.lastTokenTime = now;
+        this.tokenCount++;
         if (this.chunkBuffer) {
             const chunks = this.chunkBuffer.addToken(token);
             // Add chunks to queue for all chunking modes (character, word, sentence)
@@ -165,7 +175,7 @@ export class UIEventAdapter {
             });
         }
     }
-    handleComplete() {
+    handleComplete(tokens) {
         // Clear any pending updates
         if (this.updateTimer) {
             globalThis.clearTimeout(this.updateTimer);
@@ -200,7 +210,7 @@ export class UIEventAdapter {
             role: ConversationRoleTypes.Assistant,
             message: this.currentMessage,
             timestamp: new Date().toISOString(),
-            tokens: undefined, // Will be set by caller if available
+            tokens: tokens, // Now we have the actual LLM token count!
             toolCalls: Array.from(this.activeToolCalls.values()).map((t) => t.toolCall),
             model: this.model,
             modelService: this.modelService,
@@ -222,9 +232,32 @@ export class UIEventAdapter {
                 }
             }
         }
+        // Build final metrics
+        const completionTime = Date.now();
+        const finalMetrics = {
+            totalTime: this.streamStartTime > 0 ? completionTime - this.streamStartTime : 0,
+            conversationDuration: this.conversationStartTime > 0 ? completionTime - this.conversationStartTime : 0,
+        };
+        // Add TTFT if we have it
+        if (this.firstTokenTime > 0 && this.streamStartTime > 0) {
+            finalMetrics.ttft = this.firstTokenTime - this.streamStartTime;
+        }
+        // Add token counts
+        if (this.tokenCount > 0) {
+            finalMetrics.tokenCount = this.tokenCount; // Streaming chunks
+        }
+        if (tokens) {
+            finalMetrics.llmTokens = tokens; // Actual LLM tokens used
+        }
+        // Calculate average token delay
+        if (this.tokenDelays.length > 0) {
+            const avgDelay = this.tokenDelays.reduce((a, b) => a + b, 0) / this.tokenDelays.length;
+            finalMetrics.avgTokenDelay = Math.round(avgDelay);
+        }
         this.emitUIEvent({
             type: "conversation_completed",
             message: finalMessage,
+            metrics: finalMetrics,
         });
     }
     handleError(error) {
@@ -330,10 +363,30 @@ export class UIEventAdapter {
                 message.completionTime = elapsedTime / 1000;
             }
         }
+        // Build metrics object
+        const now = Date.now();
+        const metrics = {
+            elapsedTime: this.streamStartTime > 0 ? now - this.streamStartTime : 0,
+            conversationDuration: this.conversationStartTime > 0 ? now - this.conversationStartTime : 0,
+        };
+        // Add TTFT if we have it
+        if (this.firstTokenTime > 0 && this.streamStartTime > 0) {
+            metrics.ttft = this.firstTokenTime - this.streamStartTime;
+        }
+        // Add token count if available
+        if (this.tokenCount > 0) {
+            metrics.tokenCount = this.tokenCount;
+        }
+        // Calculate average token delay
+        if (this.tokenDelays.length > 0) {
+            const avgDelay = this.tokenDelays.reduce((a, b) => a + b, 0) / this.tokenDelays.length;
+            metrics.avgTokenDelay = Math.round(avgDelay);
+        }
         this.emitUIEvent({
             type: "message_update",
             message,
             isStreaming,
+            metrics,
         });
     }
     emitUIEvent(event) {

package/dist/types/internal.d.ts

@@ -36,6 +36,7 @@ export type StreamEvent = {
     type: "complete";
     messageId?: string;
     conversationId?: string;
+    tokens?: number;
 } | {
     type: "error";
     error: string;

package/dist/types/ui-events.d.ts

@@ -17,6 +17,13 @@ export type AgentStreamEvent = {
         message: string;
     };
     isStreaming: boolean;
+    metrics?: {
+        ttft?: number;
+        elapsedTime: number;
+        conversationDuration: number;
+        tokenCount?: number;
+        avgTokenDelay?: number;
+    };
 } | {
     type: "tool_update";
     toolCall: ConversationToolCall;
@@ -26,6 +33,14 @@ export type AgentStreamEvent = {
 } | {
     type: "conversation_completed";
     message: ConversationMessage;
+    metrics?: {
+        ttft?: number;
+        totalTime: number;
+        conversationDuration: number;
+        tokenCount?: number;
+        llmTokens?: number;
+        avgTokenDelay?: number;
+    };
 } | {
     type: "error";
     error: {

package/package.json

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