graphlit-client 1.0.20260601002 → 1.0.20260603001

package/dist/client.js

@@ -11,7 +11,7 @@ import { getServiceType, getModelName, getModelEnum, isAnthropicAdaptiveThinking
 import { StuckDetector } from "./helpers/stuck-detector.js";
 import { TurnEvaluator } from "./helpers/turn-evaluator.js";
 import { TokenBudgetTracker, truncateToolResult, windowToolRounds, estimateTokens, DEFAULT_CONTEXT_STRATEGY, } from "./helpers/context-management.js";
-import { ProviderError } from "./types/internal.js";
+import { isRetryableGraphQLTransportError, ProviderError, } from "./types/internal.js";
 import { UIEventAdapter } from "./streaming/ui-event-adapter.js";
 import { formatMessagesForOpenAI, formatMessagesForOpenAIResponsesInitialRound, extractInstructionsForOpenAIResponses, extractSystemInstructionParts, buildResponsesFunctionCallOutputItems, formatToolsForOpenAIResponses, formatMessagesForAnthropic, formatMessagesForGoogle, formatMessagesForMistral, formatMessagesForBedrock, } from "./streaming/llm-formatters.js";
 import { streamWithOpenAIResponses, } from "./streaming/openai-responses.js";
@@ -382,6 +382,19 @@ function mapAnthropicEffort(effort) {
             return undefined;
     }
 }
+function supportsAnthropicThinkingDisplay(specification) {
+    if (specification.serviceType !== Types.ModelServiceTypes.Anthropic) {
+        return false;
+    }
+    const modelName = getModelName(specification);
+    if (!modelName) {
+        return false;
+    }
+    return (modelName.startsWith("claude-opus-4") ||
+        modelName.startsWith("claude-sonnet-4") ||
+        modelName.startsWith("claude-haiku-4") ||
+        modelName === "claude-mythos-preview");
+}
 // Define the Graphlit class
 class Graphlit {
     client;
@@ -515,7 +528,9 @@ class Graphlit {
     }
     refreshClient() {
         this.client = undefined;
-        this.generateToken();
+        if (this.jwtSecret) {
+            this.generateToken();
+        }
         this.setupApolloClient();
     }
     setupApolloClient() {
@@ -535,28 +550,15 @@ class Graphlit {
                     // Check if we should retry this error
                     if (!error)
                         return false;
-                    // Check for network errors
-                    const hasNetworkError = !!error.networkError;
-                    if (!hasNetworkError)
-                        return false;
-                    // Get status code from different possible locations
-                    const statusCode = error.networkError?.statusCode ||
-                        error.networkError?.response?.status ||
-                        error.statusCode;
-                    // Check if status code is retryable
-                    if (statusCode && this.retryConfig.retryableStatusCodes) {
-                        const shouldRetry = this.retryConfig.retryableStatusCodes.includes(statusCode);
-                        // Call onRetry callback if provided
-                        if (shouldRetry &&
-                            this.retryConfig.onRetry &&
-                            _operation.getContext().retryCount !== undefined) {
-                            const attempt = _operation.getContext().retryCount + 1;
-                            this.retryConfig.onRetry(attempt, error, _operation);
-                        }
-                        return shouldRetry;
+                    const shouldRetry = isRetryableGraphQLTransportError(error, this.retryConfig.retryableStatusCodes);
+                    // Call onRetry callback if provided
+                    if (shouldRetry &&
+                        this.retryConfig.onRetry &&
+                        _operation.getContext().retryCount !== undefined) {
+                        const attempt = _operation.getContext().retryCount + 1;
+                        this.retryConfig.onRetry(attempt, error, _operation);
                     }
-                    // Default: retry on network errors without specific status codes
-                    return true;
+                    return shouldRetry;
                 },
             },
         });
@@ -8335,16 +8337,21 @@ class Graphlit {
         if (specification.serviceType === Types.ModelServiceTypes.Anthropic) {
             const anthropic = specification.anthropic;
             if (anthropic?.enableThinking) {
+                const display = supportsAnthropicThinkingDisplay(specification)
+                    ? "summarized"
+                    : undefined;
                 // Claude Opus 4.7/4.8 only support adaptive thinking with output_config.effort
                 if (isAnthropicAdaptiveThinkingOnlyModel(specification)) {
                     return {
                         type: "adaptive",
                         effort: mapAnthropicEffort(anthropic.effort),
+                        display,
                     };
                 }
                 return {
                     type: "enabled",
                     budget_tokens: anthropic.thinkingTokenLimit || 10000,
+                    display,
                 };
             }
         }

package/dist/streaming/providers.d.ts

@@ -19,9 +19,11 @@ export declare function streamWithAnthropic(specification: Specification, messag
 onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any, reasoning?: ReasoningMetadata) => void, abortSignal?: AbortSignal, thinkingConfig?: {
     type: "enabled";
     budget_tokens: number;
+    display?: "summarized";
 } | {
     type: "adaptive";
     effort?: "low" | "medium" | "high" | "xhigh";
+    display?: "summarized";
 }): Promise<void>;
 /**
  * Stream with Google SDK

package/dist/streaming/providers.js

@@ -551,7 +551,9 @@ onEvent, onComplete, abortSignal, thinkingConfig) {
         if (thinkingConfig) {
             if (thinkingConfig.type === "adaptive") {
                 // Claude Opus 4.7/4.8: adaptive thinking, effort controls depth via output_config
-                streamConfig.thinking = { type: "adaptive" };
+                streamConfig.thinking = thinkingConfig.display
+                    ? { type: "adaptive", display: thinkingConfig.display }
+                    : { type: "adaptive" };
                 if (thinkingConfig.effort) {
                     streamConfig.output_config = { effort: thinkingConfig.effort };
                 }

package/dist/types/internal.d.ts

@@ -117,6 +117,19 @@ export declare class ProviderError extends Error {
  * Used as a catch-all after provider-specific error classification.
  */
 export declare function isRetryableServerError(error: any): boolean;
+/**
+ * Extract an HTTP status code from common Apollo/network error shapes.
+ */
+export declare function getErrorStatusCode(error: any): number | undefined;
+/**
+ * Detect retryable GraphQL transport errors from Apollo RetryLink.
+ *
+ * RetryLink can receive either:
+ * - an ApolloError with `networkError`
+ * - a raw HttpLink `ServerError` with `statusCode` / `response.status`
+ * - a nested network/cause error from undici/fetch
+ */
+export declare function isRetryableGraphQLTransportError(error: any, retryableStatusCodes?: number[]): boolean;
 /**
  * Detect rate-limit / overloaded errors across providers.
  */

package/dist/types/internal.js

@@ -37,6 +37,49 @@ export function isRetryableServerError(error) {
         msg.includes("bad gateway") ||
         msg.includes("gateway timeout"));
 }
+/**
+ * Extract an HTTP status code from common Apollo/network error shapes.
+ */
+export function getErrorStatusCode(error) {
+    if (!error || typeof error !== "object")
+        return undefined;
+    const status = typeof error.status === "number"
+        ? error.status
+        : typeof error.statusCode === "number"
+            ? error.statusCode
+            : undefined;
+    if (typeof status === "number")
+        return status;
+    const responseStatus = typeof error.response?.status === "number"
+        ? error.response.status
+        : undefined;
+    if (typeof responseStatus === "number")
+        return responseStatus;
+    return (getErrorStatusCode(error.networkError) ?? getErrorStatusCode(error.cause));
+}
+/**
+ * Detect retryable GraphQL transport errors from Apollo RetryLink.
+ *
+ * RetryLink can receive either:
+ * - an ApolloError with `networkError`
+ * - a raw HttpLink `ServerError` with `statusCode` / `response.status`
+ * - a nested network/cause error from undici/fetch
+ */
+export function isRetryableGraphQLTransportError(error, retryableStatusCodes = [429, 500, 502, 503, 504]) {
+    if (!error)
+        return false;
+    const statusCode = getErrorStatusCode(error);
+    if (typeof statusCode === "number") {
+        return retryableStatusCodes.includes(statusCode);
+    }
+    if (Array.isArray(error.graphQLErrors) && error.graphQLErrors.length > 0) {
+        return false;
+    }
+    return (!!error.networkError ||
+        isNetworkError(error) ||
+        isRetryableServerError(error) ||
+        isRetryableGraphQLTransportError(error.cause, retryableStatusCodes));
+}
 /**
  * Detect rate-limit / overloaded errors across providers.
  */

package/package.json

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