@cline/shared 0.0.66 → 0.0.67

package/dist/llms/gateway.d.ts

@@ -2,6 +2,7 @@ import type { AgentMessage, AgentModelEvent, AgentToolDefinition } from "../agen
 import type { BasicLogger } from "../logging/logger";
 import type { ProviderCapability, ProviderConfigField } from "../rpc/runtime";
 import type { ITelemetryService } from "../services/telemetry";
+import type { ModelReasoningOption, ReasoningEffort } from "./reasoning-options";
 export type JsonValue = string | number | boolean | null | JsonValue[] | {
     [key: string]: JsonValue | undefined;
 };
@@ -60,6 +61,7 @@ export interface GatewayModelDefinition {
     maxInputTokens?: number;
     maxOutputTokens?: number;
     capabilities?: readonly GatewayModelCapability[];
+    reasoningOptions?: readonly ModelReasoningOption[];
     metadata?: Record<string, JsonValue | undefined>;
 }
 export interface GatewayProviderManifest {
@@ -130,7 +132,7 @@ export interface GatewayStreamRequest {
     metadata?: Record<string, unknown>;
     reasoning?: {
         enabled?: boolean;
-        effort?: "low" | "medium" | "high";
+        effort?: ReasoningEffort;
         budgetTokens?: number;
     };
     signal?: AbortSignal;
@@ -152,7 +154,7 @@ export interface GatewayModelHandleOptions {
     metadata?: Record<string, unknown>;
     reasoning?: {
         enabled?: boolean;
-        effort?: "low" | "medium" | "high";
+        effort?: ReasoningEffort;
         budgetTokens?: number;
     };
     signal?: AbortSignal;

package/dist/llms/model-info.d.ts

@@ -78,6 +78,25 @@ export declare const ModelInfoSchema: z.ZodObject<{
         temperature: "temperature";
         files: "files";
     }>>>;
+    reasoningOptions: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"toggle">;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"effort">;
+        values: z.ZodArray<z.ZodNullable<z.ZodEnum<{
+            none: "none";
+            minimal: "minimal";
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+            max: "max";
+            default: "default";
+        }>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"budget_tokens">;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>], "type">>>;
     apiFormat: z.ZodOptional<z.ZodEnum<{
         default: "default";
         "openai-responses": "openai-responses";

package/dist/llms/reasoning-effort.d.ts

@@ -1,4 +1,6 @@
+import type { ReasoningLevel } from "./reasoning-options";
 export declare const REASONING_EFFORT_RATIOS: {
+    readonly max: 1;
     readonly xhigh: 0.95;
     readonly high: 0.8;
     readonly medium: 0.5;
@@ -6,7 +8,7 @@ export declare const REASONING_EFFORT_RATIOS: {
     readonly minimal: 0.1;
     readonly none: 0;
 };
-export type ReasoningEffortValue = keyof typeof REASONING_EFFORT_RATIOS;
+export type ReasoningEffortValue = ReasoningLevel;
 export declare const DEFAULT_REASONING_EFFORT: ReasoningEffortValue | undefined;
 export declare function resolveEffectiveReasoningEffort(reasoningEffort?: string, thinking?: boolean): ReasoningEffortValue | undefined;
 export declare function resolveReasoningEffortRatio(effort?: string, options?: {

package/dist/llms/reasoning-options.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+export declare const REASONING_LEVELS: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+export declare const ReasoningLevelSchema: z.ZodEnum<{
+    none: "none";
+    minimal: "minimal";
+    low: "low";
+    medium: "medium";
+    high: "high";
+    xhigh: "xhigh";
+    max: "max";
+}>;
+export type ReasoningLevel = z.infer<typeof ReasoningLevelSchema>;
+export declare const ReasoningEffortSchema: z.ZodEnum<{
+    minimal: "minimal";
+    low: "low";
+    medium: "medium";
+    high: "high";
+    xhigh: "xhigh";
+    max: "max";
+}>;
+export type ReasoningEffort = z.infer<typeof ReasoningEffortSchema>;
+export declare const ModelReasoningOptionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"toggle">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"effort">;
+    values: z.ZodArray<z.ZodNullable<z.ZodEnum<{
+        none: "none";
+        minimal: "minimal";
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        max: "max";
+        default: "default";
+    }>>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"budget_tokens">;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>], "type">;
+export type ModelReasoningOption = z.infer<typeof ModelReasoningOptionSchema>;

package/dist/mcp.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Per-server MCP request timeout contract, in seconds.
+ *
+ * The `timeout` field in cline_mcp_settings.json is in SECONDS. Every client
+ * (VSCode extension, CLI, JetBrains) resolves it through this module so all
+ * apply the same default and bounds. Values above MAX are almost always a
+ * milliseconds/seconds mix-up (e.g. `timeout: 60000` meaning 60s), so they
+ * clamp instead of silently becoming hours.
+ */
+export declare const DEFAULT_MCP_TIMEOUT_SECONDS = 60;
+export declare const MIN_MCP_TIMEOUT_SECONDS = 1;
+export declare const MAX_MCP_TIMEOUT_SECONDS = 3600;
+export declare function isMcpTimeoutConfigured(value: unknown): value is number;
+/**
+ * Clamp a timeout in seconds into [MIN_MCP_TIMEOUT_SECONDS, MAX_MCP_TIMEOUT_SECONDS].
+ */
+export declare function clampMcpTimeoutSeconds(value: number): number;
+/**
+ * Resolve a raw `timeout` value from MCP settings to seconds. Never throws:
+ * missing or non-numeric values fall back to the default, so one malformed
+ * field cannot take down a whole settings file.
+ */
+export declare function resolveMcpTimeoutSeconds(value: unknown): number;
+export declare function formatMcpTimeoutErrorMessage(serverName: string, timeoutMs: number, method?: string): string;