graphlit-client 1.0.20260226003 → 1.0.20260226004

package/dist/client.d.ts

@@ -5,7 +5,7 @@ import { AgentOptions, AgentResult, StreamAgentOptions, ToolHandler } from "./ty
 import { AgentStreamEvent } from "./types/ui-events.js";
 export type { AgentOptions, AgentResult, ArtifactCollector, ContextStrategy, ContextManagementAction, StreamAgentOptions, ToolCallResult, UsageInfo, AgentError, } from "./types/agent.js";
 export { TokenBudgetTracker, truncateToolResult, estimateTokens, isAccurateTokenCounting, } from "./helpers/context-management.js";
-export type { AgentStreamEvent } from "./types/ui-events.js";
+export type { AgentStreamEvent, ReasoningFormat, ReasoningMetadata, } from "./types/ui-events.js";
 export interface RetryConfig {
     /** Maximum number of retry attempts (default: 5) */
     maxAttempts?: number;

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

@@ -66,6 +66,11 @@ export declare class UIEventAdapter {
     private handleReasoningStart;
     private handleReasoningDelta;
     private handleReasoningEnd;
+    /**
+     * Build a ReasoningMetadata object from accumulated reasoning state.
+     * Returns undefined when no reasoning content has been captured.
+     */
+    private buildReasoningMetadata;
     /**
      * Clean up any pending timers
      */

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

@@ -107,6 +107,11 @@ export class UIEventAdapter {
         this.lastTokenTime = 0;
         this.tokenCount = 0;
         this.tokenDelays = [];
+        // Reset reasoning state so stale thinking from a prior round doesn't leak
+        this.reasoningContent = "";
+        this.reasoningFormat = undefined;
+        this.reasoningSignature = undefined;
+        this.isInReasoning = false;
         // Reset tool call tracking flags
         this.hasToolCallsInProgress = false;
         this.hadToolCallsBeforeResume = false;
@@ -436,12 +441,21 @@ export class UIEventAdapter {
             }
             return; // Exit without emitting conversation_completed
         }
+        // Attach reasoning metadata to the final message
+        const reasoning = this.buildReasoningMetadata();
+        if (reasoning) {
+            finalMessage.isThinking = true;
+            finalMessage.thinkingContent = reasoning.content;
+        }
         // Include context window usage if available
         const event = {
             type: "conversation_completed",
             message: finalMessage,
             metrics: finalMetrics,
         };
+        if (reasoning) {
+            event.reasoning = reasoning;
+        }
         if (this.contextWindowUsage) {
             event.contextWindow = this.contextWindowUsage;
         }
@@ -599,12 +613,22 @@ export class UIEventAdapter {
                 metrics.streamingThroughput = Math.round((this.currentMessage.length / streamingTime) * 1000);
             }
         }
-        this.emitUIEvent({
+        // Attach reasoning metadata to the message and event
+        const reasoning = this.buildReasoningMetadata();
+        if (reasoning) {
+            message.isThinking = true;
+            message.thinkingContent = reasoning.content;
+        }
+        const event = {
             type: "message_update",
             message,
             isStreaming,
             metrics,
-        });
+        };
+        if (reasoning) {
+            event.reasoning = reasoning;
+        }
+        this.emitUIEvent(event);
     }
     emitUIEvent(event) {
         this.onEvent(event);
@@ -674,6 +698,23 @@ export class UIEventAdapter {
             });
         }
     }
+    /**
+     * Build a ReasoningMetadata object from accumulated reasoning state.
+     * Returns undefined when no reasoning content has been captured.
+     */
+    buildReasoningMetadata() {
+        if (!this.reasoningContent || !this.reasoningFormat) {
+            return undefined;
+        }
+        const metadata = {
+            content: this.reasoningContent,
+            format: this.reasoningFormat,
+        };
+        if (this.reasoningSignature) {
+            metadata.signature = this.reasoningSignature;
+        }
+        return metadata;
+    }
     /**
      * Clean up any pending timers
      */

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

@@ -21,12 +21,24 @@ export type ContextWindowEvent = {
     };
     timestamp: Date;
 };
+/**
+ * Structured reasoning/thinking metadata.
+ * Provides a canonical representation across all providers so the UI
+ * can decide whether and how to render model reasoning.
+ */
+export type ReasoningMetadata = {
+    content: string;
+    format: ReasoningFormat;
+    signature?: string;
+};
 /**
  * Extended conversation message with additional streaming metadata
  */
 export type StreamingConversationMessage = Partial<ConversationMessage> & {
     message: string;
     modelName?: string;
+    isThinking?: boolean;
+    thinkingContent?: string;
 };
 /**
  * Simplified UI-focused streaming events using GraphQL types
@@ -58,6 +70,7 @@ export type AgentStreamEvent = {
     type: "message_update";
     message: StreamingConversationMessage;
     isStreaming: boolean;
+    reasoning?: ReasoningMetadata;
     metrics?: {
         ttft?: number;
         elapsedTime: number;
@@ -80,6 +93,7 @@ export type AgentStreamEvent = {
 } | {
     type: "conversation_completed";
     message: StreamingConversationMessage;
+    reasoning?: ReasoningMetadata;
     metrics?: {
         ttft?: number;
         totalTime: number;

package/package.json

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