@cline/shared 0.0.75 → 0.0.76

package/dist/llms/ai-sdk-format.d.ts

@@ -1,4 +1,4 @@
-import { type MediaBudgetState } from "./media";
+import { type GeneratedMedia, type MediaBudgetState } from "./media";
 /**
  * Sanitizes unpaired/lone Unicode surrogates in text content.
  *
@@ -24,6 +24,9 @@ export type AiSdkFormatterPart = {
     type: "image";
     image: string | Uint8Array | ArrayBuffer | URL;
     mediaType?: string;
+} | {
+    type: "media";
+    media: GeneratedMedia;
 } | {
     type: "file";
     path: string;
@@ -64,5 +67,5 @@ export declare function formatMessagesForAiSdk(systemContent: string | AiSdkMess
      * Defaults to true. The substitution happens here at request-build
      * time only — stored conversation history is never mutated.
      */
-    supportsImages?: boolean;
+    supportedInputModalities?: readonly string[];
 }): AiSdkMessage[];

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 { ModelModalities, ModelModality, ModelOperation, ModelOperationMode } from "./model-info";
 import type { ModelTool, ModelToolName } from "./model-tools";
 import type { ModelReasoningOption, ReasoningEffort } from "./reasoning-options";
 export type JsonValue = string | number | boolean | null | JsonValue[] | {
@@ -15,6 +16,12 @@ export type GatewayPromptCacheFormat = "anthropic-cache-control" | "bedrock-cach
 export type GatewayReasoningFormat = "anthropic-thinking" | "glm-thinking" | "minimax-thinking";
 export type GatewayModelRoute = {
     matcher: "anthropic-compatible";
+} | {
+    matcher: "model-operation";
+    operation: ModelOperation;
+} | {
+    matcher: "model-output-modality";
+    modality: ModelModality;
 } | {
     matcher: "model-family";
     family: string;
@@ -36,6 +43,15 @@ export interface GatewayModelToolCapability {
     routes?: readonly GatewayModelRoute[];
     excludeRoutes?: readonly GatewayModelRoute[];
 }
+/** A provider transport capable of executing a matching model operation. */
+export interface GatewayModelOperationCapability {
+    operation: ModelOperation;
+    modes?: readonly ModelOperationMode[];
+    inputModalities?: readonly ModelModality[];
+    outputModalities?: readonly ModelModality[];
+    routes?: readonly GatewayModelRoute[];
+    excludeRoutes?: readonly GatewayModelRoute[];
+}
 export interface GatewayProviderRouting {
     promptCache?: {
         format: GatewayPromptCacheFormat;
@@ -62,6 +78,19 @@ export interface GatewayProviderMetadata {
     usageCostDisplay?: GatewayUsageCostDisplay;
     routing?: GatewayProviderRouting;
     stickySession?: GatewayStickySessionMetadata;
+    /**
+     * Provider-specific transport used for models whose output includes images.
+     * OpenRouter-compatible image responses require a richer schema than the
+     * generic OpenAI-compatible adapter exposes.
+     */
+    imageTransport?: "openrouter";
+    /** Provider-owned implementation used for the transcription operation. */
+    transcriptionTransport?: "openai-compatible" | "vercel-ai-gateway" | "elevenlabs";
+    /**
+     * Successful JSON responses are wrapped by the provider before reaching
+     * the protocol adapter. `success-data` represents `{ success, data }`.
+     */
+    responseEnvelope?: "success-data";
     configFields?: readonly ProviderConfigField[];
     [key: string]: JsonValue | GatewayProviderRouting | GatewayStickySessionMetadata | readonly ProviderConfigField[] | undefined;
 }
@@ -73,6 +102,9 @@ export interface GatewayModelDefinition {
     contextWindow?: number;
     maxInputTokens?: number;
     maxOutputTokens?: number;
+    operation?: ModelOperation;
+    operationModes?: readonly ModelOperationMode[];
+    modalities?: ModelModalities;
     capabilities?: readonly GatewayModelCapability[];
     reasoningOptions?: readonly ModelReasoningOption[];
     metadata?: Record<string, JsonValue | undefined>;
@@ -83,6 +115,7 @@ export interface GatewayProviderManifest {
     description?: string;
     defaultModelId: string;
     models: readonly GatewayModelDefinition[];
+    modelOperationCapabilities?: readonly GatewayModelOperationCapability[];
     modelToolCapabilities?: readonly GatewayModelToolCapability[];
     capabilities?: readonly ProviderCapability[];
     env?: readonly ("browser" | "node")[];

package/dist/llms/media.d.ts

@@ -1,3 +1,4 @@
+import { z } from "zod";
 export declare const IMAGE_OMITTED_PLACEHOLDER = "[media omitted: invalid or exceeds size limit]";
 /**
  * Substituted for image content at request-build time when the target model
@@ -5,6 +6,50 @@ export declare const IMAGE_OMITTED_PLACEHOLDER = "[media omitted: invalid or exc
  * real image, so switching to an image-capable model restores it.
  */
 export declare const IMAGE_UNSUPPORTED_PLACEHOLDER = "[Image attached \u2014 this model cannot view images]";
+export declare const GeneratedMediaModalitySchema: z.ZodEnum<{
+    image: "image";
+    audio: "audio";
+    video: "video";
+    file: "file";
+}>;
+export type GeneratedMediaModality = z.infer<typeof GeneratedMediaModalitySchema>;
+export declare const GeneratedMediaSourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"base64">;
+    data: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"url">;
+    url: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"artifact">;
+    artifactId: z.ZodString;
+}, z.core.$strip>], "type">;
+export type GeneratedMediaSource = z.infer<typeof GeneratedMediaSourceSchema>;
+/** Canonical model-generated media, shared by streaming and persistence. */
+export declare const GeneratedMediaSchema: z.ZodObject<{
+    id: z.ZodString;
+    modality: z.ZodEnum<{
+        image: "image";
+        audio: "audio";
+        video: "video";
+        file: "file";
+    }>;
+    mediaType: z.ZodString;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"base64">;
+        data: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"url">;
+        url: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"artifact">;
+        artifactId: z.ZodString;
+    }, z.core.$strip>], "type">;
+    name: z.ZodOptional<z.ZodString>;
+    sizeBytes: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type GeneratedMedia = z.infer<typeof GeneratedMediaSchema>;
+export declare function isGeneratedMedia(value: unknown): value is GeneratedMedia;
+export declare function generatedMediaModalityFromMediaType(mediaType: string): GeneratedMediaModality;
 export declare const SUPPORTED_IMAGE_MEDIA_TYPES: readonly ["image/png", "image/jpeg", "image/gif", "image/webp"];
 export declare const DEFAULT_MAX_IMAGE_BASE64_BYTES: number;
 export declare const DEFAULT_MAX_IMAGE_ENCODED_BYTES: number;
@@ -44,6 +89,18 @@ export interface MediaBudgetState {
     omittedImages: number;
     omittedReasons: Partial<Record<ImageMediaValidationFailure["reason"], number>>;
 }
+export interface Base64MediaValidationSuccess {
+    ok: true;
+    base64: string;
+    encodedBytes: number;
+    decodedBytes: number;
+}
+export interface Base64MediaValidationFailure {
+    ok: false;
+    reason: "invalid_base64" | "total_limit";
+    message: string;
+}
+export type Base64MediaValidationResult = Base64MediaValidationSuccess | Base64MediaValidationFailure;
 export declare function imageBase64EncodedByteLength(base64: string): number;
 export declare function imageBase64DecodedByteLength(base64: string): number;
 export declare function imageFileMaxDecodedBytesForBase64Limit(maxBase64Bytes?: number): number;
@@ -53,5 +110,7 @@ export declare function createMediaBudgetState(): MediaBudgetState;
 export declare function reserveImageMediaBytes(encodedBytes: number, decodedBytes: number, budget: MediaBudgetOptions, state: MediaBudgetState): ImageMediaValidationFailure | null;
 export declare function isBase64Char(charCode: number): boolean;
 export declare function isCanonicalBase64(base64: string): boolean;
+/** Validate and reserve an arbitrary inline media payload against the turn budget. */
+export declare function validateAndReserveBase64Media(data: string, budget: MediaBudgetOptions, state: MediaBudgetState): Base64MediaValidationResult;
 export declare function validateImageMedia(mediaType: string | undefined, data: string, limits?: ImageMediaLimits): ImageMediaValidationResult;
 export declare function validateAndReserveImageMedia(mediaType: string | undefined, data: string, budget: MediaBudgetOptions, state: MediaBudgetState): ImageMediaValidationResult;

package/dist/llms/messages.d.ts

@@ -5,6 +5,7 @@
  * This is a simplified, provider-agnostic format that can be
  * converted to any provider's native format.
  */
+import type { GeneratedMedia } from "./media";
 /**
  * Message roles
  */
@@ -38,6 +39,11 @@ export interface ImageContent {
     /** MIME type (e.g., "image/png", "image/jpeg") */
     mediaType: string;
 }
+/** Model-generated binary media preserved independently of textual files. */
+export interface MediaContent {
+    type: "media";
+    media: GeneratedMedia;
+}
 /**
  * Tool use content block (assistant's tool call)
  */
@@ -97,7 +103,7 @@ export interface RedactedThinkingContent {
 /**
  * Union of all content block types
  */
-export type ContentBlock = TextContent | ImageContent | ToolUseContent | ToolResultContent | ThinkingContent | FileContent | RedactedThinkingContent;
+export type ContentBlock = TextContent | ImageContent | MediaContent | ToolUseContent | ToolResultContent | ThinkingContent | FileContent | RedactedThinkingContent;
 /**
  * A single message in the conversation
  */

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

@@ -18,8 +18,8 @@ export declare const ApiFormat: {
     readonly R1: "r1";
 };
 export declare const ModelCapabilitySchema: z.ZodEnum<{
-    images: "images";
     video: "video";
+    images: "images";
     tools: "tools";
     streaming: "streaming";
     "prompt-cache": "prompt-cache";
@@ -59,6 +59,120 @@ export declare const ModelMetadataSchema: z.ZodObject<{
     reasoningDefaultOn: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$catchall<z.ZodUnknown>>;
 export type ModelMetadata = z.infer<typeof ModelMetadataSchema>;
+export declare const ModelModalitySchema: z.ZodEnum<{
+    image: "image";
+    audio: "audio";
+    video: "video";
+    text: "text";
+    pdf: "pdf";
+}>;
+export type ModelModality = z.infer<typeof ModelModalitySchema>;
+export declare const ModelModalitiesSchema: z.ZodObject<{
+    input: z.ZodArray<z.ZodEnum<{
+        image: "image";
+        audio: "audio";
+        video: "video";
+        text: "text";
+        pdf: "pdf";
+    }>>;
+    output: z.ZodArray<z.ZodEnum<{
+        image: "image";
+        audio: "audio";
+        video: "video";
+        text: "text";
+        pdf: "pdf";
+    }>>;
+}, z.core.$strip>;
+export type ModelModalities = z.infer<typeof ModelModalitiesSchema>;
+export type ChatModelModalities = {
+    readonly input?: readonly ModelModality[];
+    readonly output?: readonly ModelModality[];
+};
+/**
+ * Returns whether a model can participate in a text chat turn.
+ *
+ * Missing modality metadata is treated as chat-compatible for backwards
+ * compatibility. When a catalog does provide modalities, the model must both
+ * accept text and produce text; dedicated transcription and media-generation
+ * endpoints therefore stay available in the shared catalog without leaking
+ * into chat model pickers.
+ */
+export declare function supportsChatModalities(modalities: ChatModelModalities | undefined): boolean;
+/**
+ * Provider operation used to execute a model request.
+ *
+ * Modalities describe the values a model accepts and produces; they do not
+ * identify the provider endpoint. Keeping the operation explicit prevents an
+ * image-output model from being routed to a generic chat or compatible-image
+ * endpoint merely because its catalog advertises an image modality.
+ */
+export declare const ModelOperationSchema: z.ZodEnum<{
+    language: "language";
+    "image-generation": "image-generation";
+    "speech-generation": "speech-generation";
+    "video-generation": "video-generation";
+    transcription: "transcription";
+}>;
+export type ModelOperation = z.infer<typeof ModelOperationSchema>;
+export type ChatCompatibleModelDescriptor = {
+    readonly operation?: ModelOperation;
+    readonly modalities?: ChatModelModalities;
+};
+/**
+ * Returns whether a model uses the language operation and supports a text chat
+ * turn. Missing operation and modality metadata remain chat-compatible for
+ * backwards compatibility, while any explicitly non-language operation is
+ * excluded even when its modalities are absent.
+ */
+export declare function isChatCompatibleModel(model: ChatCompatibleModelDescriptor): boolean;
+/**
+ * Execution modes supported by a non-language model operation.
+ *
+ * The operation selects the provider transport; the mode describes how that
+ * transport is consumed. Keeping this separate from generic model
+ * capabilities prevents transcription-specific flags from spreading through
+ * otherwise modality-agnostic clients.
+ */
+export declare const ModelOperationModeSchema: z.ZodEnum<{
+    streaming: "streaming";
+    batch: "batch";
+}>;
+export type ModelOperationMode = z.infer<typeof ModelOperationModeSchema>;
+interface ImageOutputModelDescriptor {
+    operation?: ModelOperation;
+    modalities?: ModelModalities;
+}
+export declare function modelProducesImages(model: ImageOutputModelDescriptor): boolean;
+export declare function usesImageGenerationOperation(model: ImageOutputModelDescriptor): boolean;
+/**
+ * Whether a model's capability metadata declares `capability`.
+ *
+ * Capability lists reach this check from sources of very different fidelity:
+ * the generated catalog is complete, but host boundaries (VS Code's legacy
+ * ModelInfo, user-authored overrides, dynamic provider listings) may carry
+ * partial lists reconstructed from a handful of boolean flags. A missing or
+ * empty list therefore carries no signal, and each check declares its own
+ * default via `assumeWhenUnspecified` instead of treating absence as denial.
+ *
+ * Capability gates added by future model modes (audio, video, transcription,
+ * …) should route through this helper rather than reading
+ * `model.capabilities` directly, so the unspecified-list semantics stay
+ * consistent across the codebase.
+ */
+export declare function modelHasCapability(model: {
+    capabilities?: readonly string[];
+}, capability: string, options?: {
+    assumeWhenUnspecified?: boolean;
+}): boolean;
+/**
+ * Whether a model can receive function/tool definitions. Fails open when the
+ * capability list is missing or empty (user-entered and dynamically
+ * discovered models); a populated capability list without `tools` is
+ * authoritative.
+ */
+export declare function modelSupportsToolCalling(model: {
+    capabilities?: readonly string[];
+}): boolean;
 export declare const ModelInfoSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodOptional<z.ZodString>;
@@ -67,8 +181,8 @@ export declare const ModelInfoSchema: z.ZodObject<{
     contextWindow: z.ZodOptional<z.ZodNumber>;
     maxInputTokens: z.ZodOptional<z.ZodNumber>;
     capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        images: "images";
         video: "video";
+        images: "images";
         tools: "tools";
         streaming: "streaming";
         "prompt-cache": "prompt-cache";
@@ -80,11 +194,39 @@ export declare const ModelInfoSchema: z.ZodObject<{
         temperature: "temperature";
         files: "files";
     }>>>;
+    operation: z.ZodOptional<z.ZodEnum<{
+        language: "language";
+        "image-generation": "image-generation";
+        "speech-generation": "speech-generation";
+        "video-generation": "video-generation";
+        transcription: "transcription";
+    }>>;
+    operationModes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        streaming: "streaming";
+        batch: "batch";
+    }>>>;
+    modalities: z.ZodOptional<z.ZodObject<{
+        input: z.ZodArray<z.ZodEnum<{
+            image: "image";
+            audio: "audio";
+            video: "video";
+            text: "text";
+            pdf: "pdf";
+        }>>;
+        output: z.ZodArray<z.ZodEnum<{
+            image: "image";
+            audio: "audio";
+            video: "video";
+            text: "text";
+            pdf: "pdf";
+        }>>;
+    }, z.core.$strip>>;
     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<{
+            default: "default";
             none: "none";
             minimal: "minimal";
             low: "low";
@@ -92,7 +234,6 @@ export declare const ModelInfoSchema: z.ZodObject<{
             high: "high";
             xhigh: "xhigh";
             max: "max";
-            default: "default";
         }>>>;
     }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"budget_tokens">;
@@ -139,3 +280,4 @@ export declare const ModelInfoSchema: z.ZodObject<{
     }, z.core.$catchall<z.ZodUnknown>>>;
 }, z.core.$strip>;
 export type ModelInfo = z.infer<typeof ModelInfoSchema>;
+export {};

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

@@ -1,6 +1,8 @@
 /** Provider-executed tools requested from the selected language model. */
-export declare const MODEL_TOOL_NAMES: readonly ["web_search"];
+export declare const MODEL_TOOL_NAMES: readonly ["web_search", "image_generation"];
+export declare const CONFIGURABLE_MODEL_TOOL_NAMES: readonly ["web_search"];
 export type ModelToolName = (typeof MODEL_TOOL_NAMES)[number];
+export type ConfigurableModelToolName = (typeof CONFIGURABLE_MODEL_TOOL_NAMES)[number];
 export interface WebSearchModelTool {
     name: "web_search";
     maxUses?: number;
@@ -13,12 +15,16 @@ export interface WebSearchModelTool {
         timezone?: string;
     };
 }
+export interface ImageGenerationModelTool {
+    name: "image_generation";
+    outputFormat?: "png" | "jpeg" | "webp";
+}
 /**
  * A tool executed by the model provider as part of inference. Unlike an
  * AgentTool, it has no local executor or approval lifecycle.
  */
-export type ModelTool = WebSearchModelTool;
+export type ModelTool = WebSearchModelTool | ImageGenerationModelTool;
 export interface ModelToolSetting {
     enabled: boolean;
 }
-export type ModelToolSettings = Partial<Record<ModelToolName, ModelToolSetting>>;
+export type ModelToolSettings = Partial<Record<ConfigurableModelToolName, ModelToolSetting>>;

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

@@ -24,6 +24,7 @@ export declare const ModelReasoningOptionSchema: z.ZodDiscriminatedUnion<[z.ZodO
 }, z.core.$strict>, z.ZodObject<{
     type: z.ZodLiteral<"effort">;
     values: z.ZodArray<z.ZodNullable<z.ZodEnum<{
+        default: "default";
         none: "none";
         minimal: "minimal";
         low: "low";
@@ -31,7 +32,6 @@ export declare const ModelReasoningOptionSchema: z.ZodDiscriminatedUnion<[z.ZodO
         high: "high";
         xhigh: "xhigh";
         max: "max";
-        default: "default";
     }>>>;
 }, z.core.$strict>, z.ZodObject<{
     type: z.ZodLiteral<"budget_tokens">;