weave-typescript 0.8.0 → 0.9.0

package/dist/weaveapi/llmx/v1/capabilities.pb.d.ts

@@ -3,18 +3,21 @@ export declare const protobufPackage = "weaveapi.llmx.v1";
 /** Core capability types that models can support */
 export declare enum CapabilityType {
     CAPABILITY_TYPE_UNSPECIFIED = 0,
-    CAPABILITY_TYPE_STRUCTURED_RESPONSE = 1,
-    CAPABILITY_TYPE_STREAMING = 2,
-    CAPABILITY_TYPE_FUNCTION_CALLING = 3,
-    CAPABILITY_TYPE_VISION = 4,
-    CAPABILITY_TYPE_TOOL_USE = 5,
-    CAPABILITY_TYPE_SYSTEM_PROMPT = 6,
-    CAPABILITY_TYPE_CACHING = 7,
-    CAPABILITY_TYPE_REASONING = 8,
-    CAPABILITY_TYPE_AUDIO = 9,
-    CAPABILITY_TYPE_VIDEO = 10,
-    CAPABILITY_TYPE_EMBEDDINGS = 11,
-    CAPABILITY_TYPE_FINE_TUNING = 12,
+    /** CAPABILITY_TYPE_TEXT - Basic text input/output capability */
+    CAPABILITY_TYPE_TEXT = 1,
+    /** CAPABILITY_TYPE_STRUCTURED_RESPONSE - Structured output (JSON, XML, etc.) */
+    CAPABILITY_TYPE_STRUCTURED_RESPONSE = 2,
+    CAPABILITY_TYPE_STREAMING = 3,
+    CAPABILITY_TYPE_FUNCTION_CALLING = 4,
+    CAPABILITY_TYPE_VISION = 5,
+    CAPABILITY_TYPE_TOOL_USE = 6,
+    CAPABILITY_TYPE_SYSTEM_PROMPT = 7,
+    CAPABILITY_TYPE_CACHING = 8,
+    CAPABILITY_TYPE_REASONING = 9,
+    CAPABILITY_TYPE_AUDIO = 10,
+    CAPABILITY_TYPE_VIDEO = 11,
+    CAPABILITY_TYPE_EMBEDDINGS = 12,
+    CAPABILITY_TYPE_FINE_TUNING = 13,
     UNRECOGNIZED = -1
 }
 export declare function capabilityTypeFromJSON(object: any): CapabilityType;
@@ -160,10 +163,35 @@ export declare enum Hyperparameter {
 }
 export declare function hyperparameterFromJSON(object: any): Hyperparameter;
 export declare function hyperparameterToJSON(object: Hyperparameter): string;
-/** Base capability configuration */
+/** Modality direction - whether a modality supports input, output, or both */
+export declare enum ModalityDirection {
+    MODALITY_DIRECTION_UNSPECIFIED = 0,
+    /** MODALITY_DIRECTION_INPUT_ONLY - Can only process/analyze (e.g., image analysis) */
+    MODALITY_DIRECTION_INPUT_ONLY = 1,
+    /** MODALITY_DIRECTION_OUTPUT_ONLY - Can only generate (e.g., TTS without STT) */
+    MODALITY_DIRECTION_OUTPUT_ONLY = 2,
+    /** MODALITY_DIRECTION_INPUT_OUTPUT - Can both process and generate */
+    MODALITY_DIRECTION_INPUT_OUTPUT = 3,
+    UNRECOGNIZED = -1
+}
+export declare function modalityDirectionFromJSON(object: any): ModalityDirection;
+export declare function modalityDirectionToJSON(object: ModalityDirection): string;
+/**
+ * Capability represents a specific feature/ability of a model with its configuration.
+ * Each capability has a type and optional detailed configuration.
+ */
 export interface Capability {
+    /**
+     * The type of capability this represents.
+     * Example: CAPABILITY_TYPE_FUNCTION_CALLING for function/tool calling
+     */
     type: CapabilityType;
+    /**
+     * Whether this capability is currently enabled/available.
+     * Example: true if the model supports and has this feature active
+     */
     enabled: boolean;
+    text?: Text | undefined;
     structuredResponse?: StructuredResponse | undefined;
     streaming?: Streaming | undefined;
     functionCalling?: FunctionCalling | undefined;
@@ -176,6 +204,47 @@ export interface Capability {
     video?: Video | undefined;
     embeddings?: Embeddings | undefined;
     fineTuning?: FineTuning | undefined;
+    /**
+     * Unstructured additional information about this capability.
+     * Used for provider-specific details that don't fit the structured fields.
+     * Example: "Supports up to 10 parallel function calls with automatic retry"
+     * Example: "Beta feature - may have unexpected behavior"
+     * Example: "Optimized for conversational use cases"
+     */
+    additionalInfo: string;
+}
+/** Text capability configuration for basic text input/output */
+export interface Text {
+    /**
+     * Direction of text support (input, output, or both)
+     * Example: MODALITY_DIRECTION_INPUT_OUTPUT for chat models
+     */
+    direction: ModalityDirection;
+    /**
+     * Maximum input text length in characters (if limited)
+     * Example: 32000 for models with character limits
+     */
+    maxInputLength: number;
+    /**
+     * Maximum output text length in characters (if limited)
+     * Example: 4096 for models with output limits
+     */
+    maxOutputLength: number;
+    /**
+     * Supported languages for text processing
+     * Examples: ["en", "es", "fr", "de", "zh", "ja"]
+     */
+    supportedLanguages: string[];
+    /**
+     * Whether the model supports multi-turn conversations
+     * Example: true for chat models, false for completion-only models
+     */
+    supportsConversation: boolean;
+    /**
+     * Whether the model can maintain context across messages
+     * Example: true for stateful models
+     */
+    supportsContext: boolean;
 }
 /** Structured response capability configuration */
 export interface StructuredResponse {
@@ -210,15 +279,53 @@ export interface FunctionCalling {
 }
 /** Vision capability configuration */
 export interface Vision {
+    /**
+     * Direction of vision support
+     * Example: MODALITY_DIRECTION_INPUT_ONLY for analysis-only models
+     * Example: MODALITY_DIRECTION_OUTPUT_ONLY for image generation models (DALL-E)
+     * Example: MODALITY_DIRECTION_INPUT_OUTPUT for models that can both analyze and generate
+     */
+    direction: ModalityDirection;
+    /**
+     * Supported image file formats
+     * Examples: [IMAGE_FORMAT_JPEG, IMAGE_FORMAT_PNG, IMAGE_FORMAT_WEBP]
+     */
     supportedFormats: ImageFormat[];
+    /**
+     * Maximum size per image in bytes
+     * Example: 20971520 (20MB) for GPT-4-vision
+     */
     maxImageSizeBytes: number;
+    /**
+     * Maximum images per API request (for input)
+     * Example: 10 for GPT-4-vision, 1 for some models
+     */
     maxImagesPerRequest: number;
-    supportsImageGeneration: boolean;
-    supportsVideoFrames: boolean;
+    /**
+     * Maximum image width in pixels
+     * Example: 4096 for high-resolution support
+     */
     maxResolutionWidth: number;
+    /**
+     * Maximum image height in pixels
+     * Example: 4096 for high-resolution support
+     */
     maxResolutionHeight: number;
+    /**
+     * Supports optical character recognition
+     * Example: true if model can extract text from images
+     */
     supportsOcr: boolean;
+    /**
+     * Supports object detection/localization
+     * Example: true if model can identify and locate objects
+     */
     supportsObjectDetection: boolean;
+    /**
+     * Can process video frames as images
+     * Example: true if model accepts video frame extraction
+     */
+    supportsVideoFrames: boolean;
 }
 /** Tool use capability configuration */
 export interface ToolUse {
@@ -254,20 +361,83 @@ export interface Reasoning {
 }
 /** Audio capability configuration */
 export interface Audio {
+    /**
+     * Direction of audio support
+     * Example: MODALITY_DIRECTION_INPUT_ONLY for speech-to-text only
+     * Example: MODALITY_DIRECTION_OUTPUT_ONLY for text-to-speech only
+     * Example: MODALITY_DIRECTION_INPUT_OUTPUT for models supporting both STT and TTS
+     */
+    direction: ModalityDirection;
+    /**
+     * Supported audio file formats
+     * Examples: [AUDIO_FORMAT_MP3, AUDIO_FORMAT_WAV, AUDIO_FORMAT_M4A]
+     */
     supportedFormats: AudioFormat[];
+    /**
+     * Maximum audio duration in seconds
+     * Example: 600 for 10-minute limit
+     */
     maxDurationSeconds: number;
+    /**
+     * Maximum audio file size in bytes
+     * Example: 26214400 (25MB) limit
+     */
     maxFileSizeBytes: number;
-    supportsTranscription: boolean;
-    supportsGeneration: boolean;
+    /**
+     * Supported languages for audio processing
+     * Examples: ["en", "es", "fr", "de", "zh", "ja"]
+     */
     supportedLanguages: string[];
+    /**
+     * Supports real-time streaming (for live audio)
+     * Example: true for real-time voice models
+     */
+    supportsStreaming: boolean;
+    /**
+     * Supports voice cloning or voice selection
+     * Example: true if TTS can use different voices
+     */
+    supportsVoiceSelection: boolean;
 }
 /** Video capability configuration */
 export interface Video {
+    /**
+     * Direction of video support
+     * Example: MODALITY_DIRECTION_INPUT_ONLY for video analysis/understanding
+     * Example: MODALITY_DIRECTION_OUTPUT_ONLY for video generation
+     * Example: MODALITY_DIRECTION_INPUT_OUTPUT for models that can both analyze and generate
+     */
+    direction: ModalityDirection;
+    /**
+     * Supported video file formats
+     * Examples: [VIDEO_FORMAT_MP4, VIDEO_FORMAT_MOV, VIDEO_FORMAT_AVI]
+     */
     supportedFormats: VideoFormat[];
+    /**
+     * Maximum video duration in seconds
+     * Example: 120 for 2-minute limit
+     */
     maxDurationSeconds: number;
+    /**
+     * Maximum video file size in bytes
+     * Example: 1073741824 (1GB) limit
+     */
     maxFileSizeBytes: number;
+    /**
+     * Maximum frames per second supported
+     * Example: 30 for standard frame rate
+     */
     maxFps: number;
+    /**
+     * Supports extracting and analyzing individual frames
+     * Example: true if model can process video as a sequence of images
+     */
     supportsFrameExtraction: boolean;
+    /**
+     * Maximum number of frames that can be analyzed
+     * Example: 100 for frame-by-frame analysis limit
+     */
+    maxFrames: number;
 }
 /** Embeddings capability configuration */
 export interface Embeddings {
@@ -287,6 +457,7 @@ export interface FineTuning {
     hyperparameters: Hyperparameter[];
 }
 export declare const Capability: MessageFns<Capability>;
+export declare const Text: MessageFns<Text>;
 export declare const StructuredResponse: MessageFns<StructuredResponse>;
 export declare const Streaming: MessageFns<Streaming>;
 export declare const FunctionCalling: MessageFns<FunctionCalling>;