weave-typescript 0.5.1 → 0.9.0

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

@@ -0,0 +1,491 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export declare const protobufPackage = "weaveapi.llmx.v1";
+/** Core capability types that models can support */
+export declare enum CapabilityType {
+    CAPABILITY_TYPE_UNSPECIFIED = 0,
+    /** 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;
+export declare function capabilityTypeToJSON(object: CapabilityType): string;
+/** Data format types for structured responses, fine-tuning, etc. */
+export declare enum DataFormat {
+    DATA_FORMAT_UNSPECIFIED = 0,
+    DATA_FORMAT_JSON = 1,
+    DATA_FORMAT_YAML = 2,
+    DATA_FORMAT_XML = 3,
+    DATA_FORMAT_JSONL = 4,
+    DATA_FORMAT_CSV = 5,
+    DATA_FORMAT_PARQUET = 6,
+    DATA_FORMAT_PLAIN = 7,
+    DATA_FORMAT_MARKDOWN = 8,
+    DATA_FORMAT_STRUCTURED = 9,
+    UNRECOGNIZED = -1
+}
+export declare function dataFormatFromJSON(object: any): DataFormat;
+export declare function dataFormatToJSON(object: DataFormat): string;
+/** JSON schema types supported in structured responses */
+export declare enum JsonSchemaType {
+    JSON_SCHEMA_TYPE_UNSPECIFIED = 0,
+    JSON_SCHEMA_TYPE_OBJECT = 1,
+    JSON_SCHEMA_TYPE_ARRAY = 2,
+    JSON_SCHEMA_TYPE_STRING = 3,
+    JSON_SCHEMA_TYPE_NUMBER = 4,
+    JSON_SCHEMA_TYPE_BOOLEAN = 5,
+    JSON_SCHEMA_TYPE_NULL = 6,
+    JSON_SCHEMA_TYPE_INTEGER = 7,
+    UNRECOGNIZED = -1
+}
+export declare function jsonSchemaTypeFromJSON(object: any): JsonSchemaType;
+export declare function jsonSchemaTypeToJSON(object: JsonSchemaType): string;
+/** Image formats */
+export declare enum ImageFormat {
+    IMAGE_FORMAT_UNSPECIFIED = 0,
+    IMAGE_FORMAT_JPEG = 1,
+    IMAGE_FORMAT_PNG = 2,
+    IMAGE_FORMAT_GIF = 3,
+    IMAGE_FORMAT_WEBP = 4,
+    IMAGE_FORMAT_BMP = 5,
+    IMAGE_FORMAT_TIFF = 6,
+    IMAGE_FORMAT_SVG = 7,
+    UNRECOGNIZED = -1
+}
+export declare function imageFormatFromJSON(object: any): ImageFormat;
+export declare function imageFormatToJSON(object: ImageFormat): string;
+/** Audio formats */
+export declare enum AudioFormat {
+    AUDIO_FORMAT_UNSPECIFIED = 0,
+    AUDIO_FORMAT_MP3 = 1,
+    AUDIO_FORMAT_WAV = 2,
+    AUDIO_FORMAT_OGG = 3,
+    AUDIO_FORMAT_M4A = 4,
+    AUDIO_FORMAT_FLAC = 5,
+    AUDIO_FORMAT_AAC = 6,
+    AUDIO_FORMAT_WMA = 7,
+    AUDIO_FORMAT_OPUS = 8,
+    UNRECOGNIZED = -1
+}
+export declare function audioFormatFromJSON(object: any): AudioFormat;
+export declare function audioFormatToJSON(object: AudioFormat): string;
+/** Video formats */
+export declare enum VideoFormat {
+    VIDEO_FORMAT_UNSPECIFIED = 0,
+    VIDEO_FORMAT_MP4 = 1,
+    VIDEO_FORMAT_AVI = 2,
+    VIDEO_FORMAT_MOV = 3,
+    VIDEO_FORMAT_MKV = 4,
+    VIDEO_FORMAT_WEBM = 5,
+    VIDEO_FORMAT_FLV = 6,
+    VIDEO_FORMAT_WMV = 7,
+    UNRECOGNIZED = -1
+}
+export declare function videoFormatFromJSON(object: any): VideoFormat;
+export declare function videoFormatToJSON(object: VideoFormat): string;
+/** Tool types supported */
+export declare enum ToolType {
+    TOOL_TYPE_UNSPECIFIED = 0,
+    TOOL_TYPE_FUNCTION = 1,
+    TOOL_TYPE_RETRIEVAL = 2,
+    TOOL_TYPE_CODE_INTERPRETER = 3,
+    TOOL_TYPE_WEB_BROWSER = 4,
+    TOOL_TYPE_DATABASE = 5,
+    TOOL_TYPE_API = 6,
+    TOOL_TYPE_CUSTOM = 7,
+    UNRECOGNIZED = -1
+}
+export declare function toolTypeFromJSON(object: any): ToolType;
+export declare function toolTypeToJSON(object: ToolType): string;
+/** Cache key strategies */
+export declare enum CacheStrategy {
+    CACHE_STRATEGY_UNSPECIFIED = 0,
+    CACHE_STRATEGY_HASH = 1,
+    CACHE_STRATEGY_SEMANTIC = 2,
+    CACHE_STRATEGY_CUSTOM = 3,
+    CACHE_STRATEGY_PREFIX = 4,
+    CACHE_STRATEGY_SUFFIX = 5,
+    UNRECOGNIZED = -1
+}
+export declare function cacheStrategyFromJSON(object: any): CacheStrategy;
+export declare function cacheStrategyToJSON(object: CacheStrategy): string;
+/** Reasoning strategies */
+export declare enum ReasoningStrategy {
+    REASONING_STRATEGY_UNSPECIFIED = 0,
+    REASONING_STRATEGY_CHAIN_OF_THOUGHT = 1,
+    REASONING_STRATEGY_TREE_OF_THOUGHTS = 2,
+    REASONING_STRATEGY_GRAPH_OF_THOUGHTS = 3,
+    REASONING_STRATEGY_STEP_BY_STEP = 4,
+    REASONING_STRATEGY_SELF_CONSISTENCY = 5,
+    REASONING_STRATEGY_LEAST_TO_MOST = 6,
+    UNRECOGNIZED = -1
+}
+export declare function reasoningStrategyFromJSON(object: any): ReasoningStrategy;
+export declare function reasoningStrategyToJSON(object: ReasoningStrategy): string;
+/** Distance metrics for embeddings */
+export declare enum DistanceMetric {
+    DISTANCE_METRIC_UNSPECIFIED = 0,
+    DISTANCE_METRIC_COSINE = 1,
+    DISTANCE_METRIC_EUCLIDEAN = 2,
+    DISTANCE_METRIC_DOT_PRODUCT = 3,
+    DISTANCE_METRIC_MANHATTAN = 4,
+    DISTANCE_METRIC_HAMMING = 5,
+    UNRECOGNIZED = -1
+}
+export declare function distanceMetricFromJSON(object: any): DistanceMetric;
+export declare function distanceMetricToJSON(object: DistanceMetric): string;
+/** Hyperparameter types for fine-tuning */
+export declare enum Hyperparameter {
+    HYPERPARAMETER_UNSPECIFIED = 0,
+    HYPERPARAMETER_LEARNING_RATE = 1,
+    HYPERPARAMETER_BATCH_SIZE = 2,
+    HYPERPARAMETER_EPOCHS = 3,
+    HYPERPARAMETER_WARMUP_STEPS = 4,
+    HYPERPARAMETER_WEIGHT_DECAY = 5,
+    HYPERPARAMETER_GRADIENT_ACCUMULATION = 6,
+    HYPERPARAMETER_LR_SCHEDULER = 7,
+    HYPERPARAMETER_OPTIMIZER = 8,
+    HYPERPARAMETER_DROPOUT = 9,
+    HYPERPARAMETER_MAX_SEQUENCE_LENGTH = 10,
+    UNRECOGNIZED = -1
+}
+export declare function hyperparameterFromJSON(object: any): Hyperparameter;
+export declare function hyperparameterToJSON(object: Hyperparameter): string;
+/** 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;
+    vision?: Vision | undefined;
+    toolUse?: ToolUse | undefined;
+    systemPrompt?: SystemPrompt | undefined;
+    caching?: Caching | undefined;
+    reasoning?: Reasoning | undefined;
+    audio?: Audio | undefined;
+    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 {
+    systemPromptHint: string;
+    supportedFormats: DataFormat[];
+    maxSchemaDepth: number;
+    requiresToolUse: boolean;
+    requiresJsonMode: boolean;
+    maxProperties: number;
+    supportedTypes: JsonSchemaType[];
+    /** Can stream structured responses (not just generate them) */
+    supportsStreaming: boolean;
+}
+/** Streaming capability configuration */
+export interface Streaming {
+    chunkDelimiter: string;
+    bufferSize: number;
+    supportsSse: boolean;
+    supportsUsage: boolean;
+    avgChunkSizeBytes: number;
+    maxChunkDelayMs: number;
+}
+/** Function calling capability configuration */
+export interface FunctionCalling {
+    maxFunctions: number;
+    maxParallelCalls: number;
+    supportsParallel: boolean;
+    requiresToolRole: boolean;
+    supportsStreaming: boolean;
+    supportedParameterTypes: JsonSchemaType[];
+    maxNestingDepth: number;
+}
+/** 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;
+    /**
+     * 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 {
+    maxTools: number;
+    supportsSequential: boolean;
+    supportsParallel: boolean;
+    maxToolRounds: number;
+    supportedToolTypes: ToolType[];
+}
+/** System prompt capability configuration */
+export interface SystemPrompt {
+    maxLength: number;
+    supportsMultiple: boolean;
+    supportsCaching: boolean;
+    format: DataFormat;
+}
+/** Caching capability configuration */
+export interface Caching {
+    cacheKeyStrategy: CacheStrategy;
+    maxCacheSizeBytes: number;
+    cacheTtlSeconds: number;
+    supportsContextCaching: boolean;
+    supportsPromptCaching: boolean;
+    minCacheableTokens: number;
+}
+/** Reasoning capability configuration */
+export interface Reasoning {
+    supportsChainOfThought: boolean;
+    supportsStepTracking: boolean;
+    maxReasoningSteps: number;
+    supportsSelfCorrection: boolean;
+    reasoningStrategies: ReasoningStrategy[];
+}
+/** 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;
+    /**
+     * 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 {
+    embeddingDimensions: number;
+    maxInputTokens: number;
+    supportsBatch: boolean;
+    maxBatchSize: number;
+    distanceMetrics: DistanceMetric[];
+}
+/** Fine-tuning capability configuration */
+export interface FineTuning {
+    minExamples: number;
+    maxExamples: number;
+    supportedFormats: DataFormat[];
+    maxFileSizeMb: number;
+    supportsValidationSet: boolean;
+    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>;
+export declare const Vision: MessageFns<Vision>;
+export declare const ToolUse: MessageFns<ToolUse>;
+export declare const SystemPrompt: MessageFns<SystemPrompt>;
+export declare const Caching: MessageFns<Caching>;
+export declare const Reasoning: MessageFns<Reasoning>;
+export declare const Audio: MessageFns<Audio>;
+export declare const Video: MessageFns<Video>;
+export declare const Embeddings: MessageFns<Embeddings>;
+export declare const FineTuning: MessageFns<FineTuning>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};