graphlit-client 1.0.20260601001 → 1.0.20260602001

package/dist/client.js

@@ -7,7 +7,7 @@ import gql from "graphql-tag";
 import { attachPartialErrors } from "./partial-errors.js";
 import * as Types from "./generated/graphql-types.js";
 import * as Documents from "./generated/graphql-documents.js";
-import { getServiceType, getModelName, getModelEnum, isOpenAIResponsesEligibleModel, } from "./model-mapping.js";
+import { getServiceType, getModelName, getModelEnum, isAnthropicAdaptiveThinkingOnlyModel, isOpenAIResponsesEligibleModel, } from "./model-mapping.js";
 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";
@@ -362,7 +362,7 @@ function isValidGuid(guid) {
 /**
  * Map Graphlit AnthropicEffortLevels to the string values accepted by the
  * Anthropic Messages API `output_config.effort` parameter (adaptive thinking).
- * Used for Claude 4.7 Opus, which replaces `thinking.budget_tokens` with
+ * Used for Claude Opus 4.7/4.8, which replace `thinking.budget_tokens` with
  * `thinking.type = "adaptive"` + `output_config.effort`.
  */
 function mapAnthropicEffort(effort) {
@@ -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;
@@ -8335,16 +8348,21 @@ class Graphlit {
         if (specification.serviceType === Types.ModelServiceTypes.Anthropic) {
             const anthropic = specification.anthropic;
             if (anthropic?.enableThinking) {
-                // Claude 4.7 Opus only supports adaptive thinking with output_config.effort
-                if (anthropic.model === Types.AnthropicModels.Claude_4_7Opus) {
+                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/model-mapping.d.ts

@@ -22,6 +22,11 @@ export declare function getServiceType(specification: any): string | undefined;
  * @returns The model enum value
  */
 export declare function getModelEnum(specification: any): string | undefined;
+/**
+ * Check whether an Anthropic specification targets an Opus model that only
+ * supports adaptive thinking and rejects non-default sampling parameters.
+ */
+export declare function isAnthropicAdaptiveThinkingOnlyModel(specification: any): boolean;
 /**
  * Check whether an OpenAI specification should use the Responses API path.
  * Eligible models are GPT-5.4 and newer.

package/dist/model-mapping.js

@@ -120,8 +120,9 @@ const ANTHROPIC_MODEL_MAP = {
     [Types.AnthropicModels.Claude_4_6Sonnet_20260217]: "claude-sonnet-4-6-20260217",
     [Types.AnthropicModels.Claude_4_6Sonnet_1M]: "claude-sonnet-4-6",
     [Types.AnthropicModels.Claude_4_6Sonnet_1M_20260217]: "claude-sonnet-4-6-20260217",
-    // Claude 4.7 models (1M context is native to the model, no beta header required)
+    // Claude 4.7+ models (1M context is native to the model, no beta header required)
     [Types.AnthropicModels.Claude_4_7Opus]: "claude-opus-4-7",
+    [Types.AnthropicModels.Claude_4_8Opus]: "claude-opus-4-8",
 };
 // Google model mappings
 const GOOGLE_MODEL_MAP = {
@@ -357,6 +358,22 @@ export function getModelEnum(specification) {
             return undefined;
     }
 }
+/**
+ * Check whether an Anthropic specification targets an Opus model that only
+ * supports adaptive thinking and rejects non-default sampling parameters.
+ */
+export function isAnthropicAdaptiveThinkingOnlyModel(specification) {
+    if (specification?.serviceType !== Types.ModelServiceTypes.Anthropic) {
+        return false;
+    }
+    const modelEnum = getModelEnum(specification);
+    if (modelEnum === Types.AnthropicModels.Claude_4_7Opus ||
+        modelEnum === Types.AnthropicModels.Claude_4_8Opus) {
+        return true;
+    }
+    const modelName = getModelName(specification);
+    return modelName === "claude-opus-4-7" || modelName === "claude-opus-4-8";
+}
 /**
  * Check whether an OpenAI specification should use the Responses API path.
  * Eligible models are GPT-5.4 and newer.

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

@@ -1,5 +1,5 @@
 import * as Types from "../generated/graphql-types.js";
-import { getModelName } from "../model-mapping.js";
+import { getModelName, isAnthropicAdaptiveThinkingOnlyModel, } from "../model-mapping.js";
 import { ProviderError, isRetryableServerError, isRateLimitError, isNetworkError, extractRequestId, } from "../types/internal.js";
 import { createHash } from "node:crypto";
 /**
@@ -509,17 +509,17 @@ onEvent, onComplete, abortSignal, thinkingConfig) {
             stream: true,
             max_tokens: specification.anthropic?.completionTokenLimit || defaultMaxTokens,
         };
-        // Handle temperature based on thinking configuration and model
-        // Claude 4.7 Opus (adaptive thinking) does not accept sampling parameters at all.
+        // Claude Opus 4.7/4.8 do not accept non-default sampling parameters at all.
         const isAdaptiveThinking = thinkingConfig?.type === "adaptive";
-        if (thinkingConfig && !isAdaptiveThinking) {
+        const isAdaptiveThinkingOnlyModel = isAnthropicAdaptiveThinkingOnlyModel(specification);
+        if (thinkingConfig && !isAdaptiveThinking && !isAdaptiveThinkingOnlyModel) {
             // When legacy thinking budget is enabled, temperature must be 1
             streamConfig.temperature = 1;
             if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                 console.log(`🧠 [Anthropic] Setting temperature to 1 (required for extended thinking)`);
             }
         }
-        else if (!isAdaptiveThinking) {
+        else if (!isAdaptiveThinkingOnlyModel && !isAdaptiveThinking) {
             // Only add temperature if it's defined and valid for non-thinking requests
             if (specification.anthropic?.temperature !== undefined &&
                 specification.anthropic?.temperature !== null &&
@@ -550,8 +550,10 @@ onEvent, onComplete, abortSignal, thinkingConfig) {
         // Add thinking config if provided
         if (thinkingConfig) {
             if (thinkingConfig.type === "adaptive") {
-                // Claude 4.7 Opus: adaptive thinking, effort controls depth via output_config
-                streamConfig.thinking = { type: "adaptive" };
+                // Claude Opus 4.7/4.8: adaptive thinking, effort controls depth via output_config
+                streamConfig.thinking = thinkingConfig.display
+                    ? { type: "adaptive", display: thinkingConfig.display }
+                    : { type: "adaptive" };
                 if (thinkingConfig.effort) {
                     streamConfig.output_config = { effort: thinkingConfig.effort };
                 }

package/package.json

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