weave-typescript 0.9.0 → 0.10.1

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

@@ -7,16 +7,27 @@ export declare enum CapabilityType {
     CAPABILITY_TYPE_TEXT = 1,
     /** CAPABILITY_TYPE_STRUCTURED_RESPONSE - Structured output (JSON, XML, etc.) */
     CAPABILITY_TYPE_STRUCTURED_RESPONSE = 2,
+    /** CAPABILITY_TYPE_STREAMING - Server-sent or websocket streaming of partial outputs */
     CAPABILITY_TYPE_STREAMING = 3,
+    /** CAPABILITY_TYPE_FUNCTION_CALLING - Tool/function calling with schemaed arguments */
     CAPABILITY_TYPE_FUNCTION_CALLING = 4,
+    /** CAPABILITY_TYPE_VISION - Image understanding and/or generation */
     CAPABILITY_TYPE_VISION = 5,
+    /** CAPABILITY_TYPE_TOOL_USE - General tool use beyond plain function calls */
     CAPABILITY_TYPE_TOOL_USE = 6,
+    /** CAPABILITY_TYPE_SYSTEM_PROMPT - System messages/prompt steering support */
     CAPABILITY_TYPE_SYSTEM_PROMPT = 7,
+    /** CAPABILITY_TYPE_CACHING - Prompt/context caching capabilities */
     CAPABILITY_TYPE_CACHING = 8,
+    /** CAPABILITY_TYPE_REASONING - Advanced reasoning controls/strategies */
     CAPABILITY_TYPE_REASONING = 9,
+    /** CAPABILITY_TYPE_AUDIO - Audio STT/TTS support */
     CAPABILITY_TYPE_AUDIO = 10,
+    /** CAPABILITY_TYPE_VIDEO - Video analysis/generation support */
     CAPABILITY_TYPE_VIDEO = 11,
+    /** CAPABILITY_TYPE_EMBEDDINGS - Vector embedding generation */
     CAPABILITY_TYPE_EMBEDDINGS = 12,
+    /** CAPABILITY_TYPE_FINE_TUNING - Custom model training/fine-tuning */
     CAPABILITY_TYPE_FINE_TUNING = 13,
     UNRECOGNIZED = -1
 }
@@ -248,33 +259,116 @@ export interface Text {
 }
 /** Structured response capability configuration */
 export interface StructuredResponse {
+    /**
+     * Optional guidance to include in the system prompt to elicit structured output
+     * Example: "Always return valid JSON matching the provided schema"
+     */
     systemPromptHint: string;
+    /**
+     * Supported output formats for structured responses
+     * Examples: [DATA_FORMAT_JSON, DATA_FORMAT_YAML]
+     */
     supportedFormats: DataFormat[];
+    /**
+     * Maximum allowed nesting depth for JSON schema objects/arrays
+     * Example: 5 for moderately complex schemas
+     */
     maxSchemaDepth: number;
+    /**
+     * Whether structured output requires tool/function use (vs. direct generation)
+     * Example: true for providers that only return JSON via tool calls
+     */
     requiresToolUse: boolean;
+    /**
+     * Whether the model must be in a special "JSON mode" to honor schemas
+     * Example: true for models that enforce strict JSON output when enabled
+     */
     requiresJsonMode: boolean;
+    /**
+     * Maximum number of top-level properties in object schemas
+     * Example: 50
+     */
     maxProperties: number;
+    /**
+     * JSON Schema primitive/types supported by the model
+     * Examples: [JSON_SCHEMA_TYPE_OBJECT, JSON_SCHEMA_TYPE_ARRAY, JSON_SCHEMA_TYPE_STRING]
+     */
     supportedTypes: JsonSchemaType[];
-    /** Can stream structured responses (not just generate them) */
+    /**
+     * Can stream structured responses (not just generate them)
+     * Example: true if partial JSON chunks are streamed
+     */
     supportsStreaming: boolean;
 }
 /** Streaming capability configuration */
 export interface Streaming {
+    /**
+     * Delimiter used between streamed chunks, if any
+     * Example: "\n\n" for event-stream boundaries
+     */
     chunkDelimiter: string;
+    /**
+     * Preferred buffer size used by the provider when batching output
+     * Example: 1024 (bytes)
+     */
     bufferSize: number;
+    /**
+     * Whether Server-Sent Events (SSE) is supported
+     * Example: true if provider uses text/event-stream
+     */
     supportsSse: boolean;
+    /**
+     * Whether token usage info can be emitted incrementally during streaming
+     * Example: true if usage deltas are included in stream
+     */
     supportsUsage: boolean;
+    /**
+     * Typical size of individual streamed chunks in bytes
+     * Example: 256
+     */
     avgChunkSizeBytes: number;
+    /**
+     * Maximum delay between streamed chunks in milliseconds
+     * Example: 200
+     */
     maxChunkDelayMs: number;
 }
 /** Function calling capability configuration */
 export interface FunctionCalling {
+    /**
+     * Maximum number of functions that can be registered per request
+     * Example: 128
+     */
     maxFunctions: number;
+    /**
+     * Maximum number of tool/function calls that may be executed in parallel
+     * Example: 5
+     */
     maxParallelCalls: number;
+    /**
+     * Whether the model can plan and invoke multiple tools concurrently
+     * Example: true for models with parallel tool-use orchestration
+     */
     supportsParallel: boolean;
+    /**
+     * Whether requests must use a special "tool" role or channel for calls
+     * Example: true if provider requires tool role messages
+     */
     requiresToolRole: boolean;
+    /**
+     * Whether intermediate tool call tokens/results are streamable
+     * Example: true if tool call arguments/results are streamed as they are produced
+     */
     supportsStreaming: boolean;
+    /**
+     * JSON schema types supported for function parameters
+     * Examples: [JSON_SCHEMA_TYPE_OBJECT, JSON_SCHEMA_TYPE_ARRAY, JSON_SCHEMA_TYPE_STRING]
+     */
     supportedParameterTypes: JsonSchemaType[];
+    /**
+     * Maximum nesting depth allowed for function/tool call plans
+     * Example: 3 for limited recursion
+     */
     maxNestingDepth: number;
 }
 /** Vision capability configuration */
@@ -329,34 +423,114 @@ export interface Vision {
 }
 /** Tool use capability configuration */
 export interface ToolUse {
+    /**
+     * Maximum number of tools that can be registered or considered
+     * Example: 64
+     */
     maxTools: number;
+    /**
+     * Whether the model can chain tool invocations one after another
+     * Example: true for stepwise tool planning
+     */
     supportsSequential: boolean;
+    /**
+     * Whether the model can invoke multiple tools concurrently
+     * Example: true for parallelized tool execution
+     */
     supportsParallel: boolean;
+    /**
+     * Maximum number of tool-use rounds allowed in a single request
+     * Example: 10
+     */
     maxToolRounds: number;
+    /**
+     * Types of tools supported by the provider/model
+     * Examples: [TOOL_TYPE_FUNCTION, TOOL_TYPE_RETRIEVAL]
+     */
     supportedToolTypes: ToolType[];
 }
 /** System prompt capability configuration */
 export interface SystemPrompt {
+    /**
+     * Maximum allowed length of system prompt content (characters or tokens)
+     * Example: 8000 (characters)
+     */
     maxLength: number;
+    /**
+     * Whether multiple system prompts (or segments) can be supplied
+     * Example: true if the provider supports multiple system messages
+     */
     supportsMultiple: boolean;
+    /**
+     * Whether system prompts can be cached for re-use
+     * Example: true if provider supports prompt caching hints
+     */
     supportsCaching: boolean;
+    /**
+     * Preferred/required format for system prompts (plain, markdown, etc.)
+     * Example: DATA_FORMAT_MARKDOWN
+     */
     format: DataFormat;
 }
 /** Caching capability configuration */
 export interface Caching {
+    /**
+     * Strategy used to compute cache keys for requests/responses
+     * Examples: CACHE_STRATEGY_HASH, CACHE_STRATEGY_SEMANTIC
+     */
     cacheKeyStrategy: CacheStrategy;
+    /**
+     * Maximum total cache capacity (bytes)
+     * Example: 1073741824 for 1GB
+     */
     maxCacheSizeBytes: number;
+    /**
+     * Default time-to-live for cache entries (seconds)
+     * Example: 3600 for 1 hour
+     */
     cacheTtlSeconds: number;
+    /**
+     * Whether the model/provider supports caching of conversation context
+     * Example: true for context window reuse
+     */
     supportsContextCaching: boolean;
+    /**
+     * Whether the model/provider supports caching of prompts/prefixes
+     * Example: true for prefix caching/token reuse
+     */
     supportsPromptCaching: boolean;
+    /**
+     * Minimum number of tokens required for an entry to be cacheable
+     * Example: 128
+     */
     minCacheableTokens: number;
 }
 /** Reasoning capability configuration */
 export interface Reasoning {
+    /**
+     * Whether the model can produce hidden chain-of-thought/assistant reasoning
+     * Example: true for models supporting private CoT traces
+     */
     supportsChainOfThought: boolean;
+    /**
+     * Whether the model can expose discrete step indices or markers
+     * Example: true for models that number reasoning steps
+     */
     supportsStepTracking: boolean;
+    /**
+     * Maximum number of internal reasoning steps supported
+     * Example: 64
+     */
     maxReasoningSteps: number;
+    /**
+     * Whether the model can revise earlier steps based on later insights
+     * Example: true for self-correction/self-reflection
+     */
     supportsSelfCorrection: boolean;
+    /**
+     * Supported high-level reasoning strategies
+     * Examples: [REASONING_STRATEGY_STEP_BY_STEP, REASONING_STRATEGY_SELF_CONSISTENCY]
+     */
     reasoningStrategies: ReasoningStrategy[];
 }
 /** Audio capability configuration */
@@ -441,19 +615,63 @@ export interface Video {
 }
 /** Embeddings capability configuration */
 export interface Embeddings {
+    /**
+     * Dimensionality of the vector space produced by the model
+     * Example: 1536
+     */
     embeddingDimensions: number;
+    /**
+     * Maximum number of tokens accepted per input item
+     * Example: 8192
+     */
     maxInputTokens: number;
+    /**
+     * Whether the API supports batching multiple inputs in one call
+     * Example: true
+     */
     supportsBatch: boolean;
+    /**
+     * Maximum number of items allowed per batch
+     * Example: 128
+     */
     maxBatchSize: number;
+    /**
+     * Supported similarity/distance metrics for index/search
+     * Examples: [DISTANCE_METRIC_COSINE, DISTANCE_METRIC_DOT_PRODUCT]
+     */
     distanceMetrics: DistanceMetric[];
 }
 /** Fine-tuning capability configuration */
 export interface FineTuning {
+    /**
+     * Minimum number of training examples required to start fine-tuning
+     * Example: 50
+     */
     minExamples: number;
+    /**
+     * Maximum number of training examples supported in a single job
+     * Example: 500000
+     */
     maxExamples: number;
+    /**
+     * Supported dataset/file formats for fine-tuning
+     * Examples: [DATA_FORMAT_JSONL, DATA_FORMAT_CSV]
+     */
     supportedFormats: DataFormat[];
+    /**
+     * Maximum size of individual training files (MB)
+     * Example: 512
+     */
     maxFileSizeMb: number;
+    /**
+     * Whether a separate validation set can be provided
+     * Example: true
+     */
     supportsValidationSet: boolean;
+    /**
+     * Hyperparameters that can be configured for training
+     * Examples: [HYPERPARAMETER_LEARNING_RATE, HYPERPARAMETER_EPOCHS]
+     */
     hyperparameters: Hyperparameter[];
 }
 export declare const Capability: MessageFns<Capability>;

package/dist/weaveapi/llmx/v1/capabilities.pb.js

@@ -41,16 +41,27 @@ var CapabilityType;
     CapabilityType[CapabilityType["CAPABILITY_TYPE_TEXT"] = 1] = "CAPABILITY_TYPE_TEXT";
     /** CAPABILITY_TYPE_STRUCTURED_RESPONSE - Structured output (JSON, XML, etc.) */
     CapabilityType[CapabilityType["CAPABILITY_TYPE_STRUCTURED_RESPONSE"] = 2] = "CAPABILITY_TYPE_STRUCTURED_RESPONSE";
+    /** CAPABILITY_TYPE_STREAMING - Server-sent or websocket streaming of partial outputs */
     CapabilityType[CapabilityType["CAPABILITY_TYPE_STREAMING"] = 3] = "CAPABILITY_TYPE_STREAMING";
+    /** CAPABILITY_TYPE_FUNCTION_CALLING - Tool/function calling with schemaed arguments */
     CapabilityType[CapabilityType["CAPABILITY_TYPE_FUNCTION_CALLING"] = 4] = "CAPABILITY_TYPE_FUNCTION_CALLING";
+    /** CAPABILITY_TYPE_VISION - Image understanding and/or generation */
     CapabilityType[CapabilityType["CAPABILITY_TYPE_VISION"] = 5] = "CAPABILITY_TYPE_VISION";
+    /** CAPABILITY_TYPE_TOOL_USE - General tool use beyond plain function calls */
     CapabilityType[CapabilityType["CAPABILITY_TYPE_TOOL_USE"] = 6] = "CAPABILITY_TYPE_TOOL_USE";
+    /** CAPABILITY_TYPE_SYSTEM_PROMPT - System messages/prompt steering support */
     CapabilityType[CapabilityType["CAPABILITY_TYPE_SYSTEM_PROMPT"] = 7] = "CAPABILITY_TYPE_SYSTEM_PROMPT";
+    /** CAPABILITY_TYPE_CACHING - Prompt/context caching capabilities */
     CapabilityType[CapabilityType["CAPABILITY_TYPE_CACHING"] = 8] = "CAPABILITY_TYPE_CACHING";
+    /** CAPABILITY_TYPE_REASONING - Advanced reasoning controls/strategies */
     CapabilityType[CapabilityType["CAPABILITY_TYPE_REASONING"] = 9] = "CAPABILITY_TYPE_REASONING";
+    /** CAPABILITY_TYPE_AUDIO - Audio STT/TTS support */
     CapabilityType[CapabilityType["CAPABILITY_TYPE_AUDIO"] = 10] = "CAPABILITY_TYPE_AUDIO";
+    /** CAPABILITY_TYPE_VIDEO - Video analysis/generation support */
     CapabilityType[CapabilityType["CAPABILITY_TYPE_VIDEO"] = 11] = "CAPABILITY_TYPE_VIDEO";
+    /** CAPABILITY_TYPE_EMBEDDINGS - Vector embedding generation */
     CapabilityType[CapabilityType["CAPABILITY_TYPE_EMBEDDINGS"] = 12] = "CAPABILITY_TYPE_EMBEDDINGS";
+    /** CAPABILITY_TYPE_FINE_TUNING - Custom model training/fine-tuning */
     CapabilityType[CapabilityType["CAPABILITY_TYPE_FINE_TUNING"] = 13] = "CAPABILITY_TYPE_FINE_TUNING";
     CapabilityType[CapabilityType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(CapabilityType || (exports.CapabilityType = CapabilityType = {}));