graphlit-client 1.0.20250612008 → 1.0.20250613001

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

@@ -4,7 +4,7 @@ import { ApolloClient, InMemoryCache, createHttpLink, ApolloLink, ApolloError, }
 import * as Types from "./generated/graphql-types.js";
 import * as Documents from "./generated/graphql-documents.js";
 import * as dotenv from "dotenv";
-import { getServiceType } from "./model-mapping.js";
+import { getServiceType, getModelName } from "./model-mapping.js";
 import { UIEventAdapter } from "./streaming/ui-event-adapter.js";
 import { formatMessagesForOpenAI, formatMessagesForAnthropic, formatMessagesForGoogle, } from "./streaming/llm-formatters.js";
 import { streamWithOpenAI, streamWithAnthropic, streamWithGoogle, } from "./streaming/providers.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 });
     }
@@ -1626,11 +1629,15 @@ class Graphlit {
                 });
                 return; // Exit early after successful fallback
             }
-            // Create UI event adapter
+            // Create UI event adapter with model information
+            const modelName = fullSpec ? getModelName(fullSpec) : undefined;
+            const serviceType = fullSpec ? getServiceType(fullSpec) : undefined;
             uiAdapter = new UIEventAdapter(onEvent, actualConversationId, {
                 smoothingEnabled: options?.smoothingEnabled ?? true,
                 chunkingStrategy: options?.chunkingStrategy ?? "word",
                 smoothingDelay: options?.smoothingDelay ?? 30,
+                model: modelName,
+                modelService: serviceType,
             });
             // Start the streaming conversation
             await this.executeStreamingAgent(prompt, actualConversationId, fullSpec, tools, toolHandlers, uiAdapter, maxRounds, abortSignal, mimeType, data, correlationId);

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

@@ -9,8 +9,13 @@ export declare class UIEventAdapter {
     private onEvent;
     private conversationId;
     private model?;
+    private modelService?;
+    private tokenCount;
     private currentMessage;
     private isStreaming;
+    private streamStartTime;
+    private firstTokenTime;
+    private lastTokenTime;
     private activeToolCalls;
     private lastUpdateTime;
     private updateTimer?;
@@ -21,6 +26,8 @@ export declare class UIEventAdapter {
         smoothingEnabled?: boolean;
         chunkingStrategy?: ChunkingStrategy;
         smoothingDelay?: number;
+        model?: string;
+        modelService?: string;
     });
     /**
      * Process a raw streaming event and emit appropriate UI events

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

@@ -8,8 +8,13 @@ export class UIEventAdapter {
     onEvent;
     conversationId;
     model;
+    modelService;
+    tokenCount = 0;
     currentMessage = "";
     isStreaming = false;
+    streamStartTime = 0;
+    firstTokenTime = 0;
+    lastTokenTime = 0;
     activeToolCalls = new Map();
     lastUpdateTime = 0;
     updateTimer;
@@ -20,6 +25,8 @@ export class UIEventAdapter {
         this.onEvent = onEvent;
         this.conversationId = conversationId;
         this.smoothingDelay = options.smoothingDelay ?? 30;
+        this.model = options.model;
+        this.modelService = options.modelService;
         if (options.smoothingEnabled) {
             this.chunkBuffer = new ChunkBuffer(options.chunkingStrategy || "word");
         }
@@ -84,6 +91,9 @@ export class UIEventAdapter {
     handleStart(conversationId) {
         this.conversationId = conversationId;
         this.isStreaming = true;
+        this.streamStartTime = Date.now();
+        this.firstTokenTime = 0;
+        this.lastTokenTime = 0;
         this.emitUIEvent({
             type: "conversation_started",
             conversationId,
@@ -92,6 +102,12 @@ export class UIEventAdapter {
         });
     }
     handleToken(token) {
+        // Track timing for first token
+        const now = Date.now();
+        if (this.firstTokenTime === 0) {
+            this.firstTokenTime = now;
+        }
+        this.lastTokenTime = now;
         if (this.chunkBuffer) {
             const chunks = this.chunkBuffer.addToken(token);
             // Add chunks to queue for all chunking modes (character, word, sentence)
@@ -178,7 +194,7 @@ export class UIEventAdapter {
             }
         }
         this.isStreaming = false;
-        // Create final message
+        // Create final message with metadata
         const finalMessage = {
             __typename: "ConversationMessage",
             role: ConversationRoleTypes.Assistant,
@@ -186,7 +202,26 @@ export class UIEventAdapter {
             timestamp: new Date().toISOString(),
             tokens: undefined, // Will be set by caller if available
             toolCalls: Array.from(this.activeToolCalls.values()).map((t) => t.toolCall),
+            model: this.model,
+            modelService: this.modelService,
         };
+        // Add final timing metadata
+        if (this.streamStartTime > 0) {
+            const totalTime = Date.now() - this.streamStartTime;
+            // Final throughput (chars/second)
+            finalMessage.throughput = totalTime > 0
+                ? Math.round((this.currentMessage.length / totalTime) * 1000)
+                : 0;
+            // Total completion time in seconds
+            finalMessage.completionTime = totalTime / 1000;
+            // Add time to first token if we have it (useful metric)
+            if (this.firstTokenTime > 0) {
+                const ttft = this.firstTokenTime - this.streamStartTime;
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`⏱️ [UIEventAdapter] TTFT: ${ttft}ms | Total: ${totalTime}ms | Throughput: ${finalMessage.throughput} chars/s`);
+                }
+            }
+        }
         this.emitUIEvent({
             type: "conversation_completed",
             message: finalMessage,
@@ -274,6 +309,27 @@ export class UIEventAdapter {
             message: this.currentMessage,
             timestamp: new Date().toISOString(),
         };
+        // Add model metadata if available
+        if (this.model) {
+            message.model = this.model;
+        }
+        if (this.modelService) {
+            message.modelService = this.modelService;
+        }
+        // Add timing metadata if streaming has started
+        if (this.streamStartTime > 0) {
+            const now = Date.now();
+            const elapsedTime = now - this.streamStartTime;
+            // Calculate throughput (chars/second)
+            const throughput = elapsedTime > 0
+                ? Math.round((this.currentMessage.length / elapsedTime) * 1000)
+                : 0;
+            message.throughput = throughput;
+            // Add completion time if we have it (in seconds to match API)
+            if (elapsedTime > 0) {
+                message.completionTime = elapsedTime / 1000;
+            }
+        }
         this.emitUIEvent({
             type: "message_update",
             message,

package/package.json

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