qlogicagent 1.0.0 → 1.1.0

package/dist/types/llm/provider-def.d.ts

@@ -9,9 +9,116 @@
  *   Layer 2: model-catalog.ts remote (models.dev)
  *   Layer 3: user config (from agent.turn.config)
  */
-export type TransportType = "openai-chat" | "anthropic-messages";
+export type TransportType = "openai-chat" | "anthropic-messages" | "volcengine-responses";
 export type AuthType = "bearer" | "x-api-key" | "none";
-export type MediaCapability = "image" | "video" | "music" | "tts" | "3d";
+export type MediaCapability = "image" | "video" | "music" | "tts" | "3d" | "stt" | "embedding" | "video_understanding" | "image_understanding" | "voice_clone" | "rerank" | "document_parsing";
+export type VideoOperation = "text2video" | "img2video" | "video2video" | "edit" | "merge" | "upscale";
+export type ImageOperation = "text2image" | "img2img" | "inpainting" | "outpainting";
+export type MusicOperation = "text2music" | "cover";
+export type TtsOperation = "text2speech" | "voice_clone";
+export type ThreeDOperation = "text2_3d" | "img2_3d";
+export interface VideoCapabilities {
+    type: "video";
+    operations: VideoOperation[];
+    maxDurationSeconds?: number;
+    resolutions?: string[];
+    aspectRatios?: string[];
+    fps?: number[];
+}
+export interface ImageCapabilities {
+    type: "image";
+    operations: ImageOperation[];
+    sizes?: string[];
+    transparentBackground?: boolean;
+}
+export interface MusicCapabilities {
+    type: "music";
+    operations: MusicOperation[];
+    maxDurationSeconds?: number;
+    formats?: string[];
+}
+export interface TtsCapabilities {
+    type: "tts";
+    operations?: TtsOperation[];
+    voices?: string[];
+    maxCharacters?: number;
+    formats?: string[];
+}
+export interface ThreeDCapabilities {
+    type: "3d";
+    operations: ThreeDOperation[];
+    outputFormats?: string[];
+}
+export interface SttCapabilities {
+    type: "stt";
+    languages?: string[];
+    maxDurationSeconds?: number;
+    formats?: string[];
+}
+export interface EmbeddingCapabilities {
+    type: "embedding";
+    dimensions?: number;
+    maxTokens?: number;
+}
+export interface VideoUnderstandingCapabilities {
+    type: "video_understanding";
+    maxDurationSeconds?: number;
+    formats?: string[];
+}
+export interface ImageUnderstandingCapabilities {
+    type: "image_understanding";
+    formats?: string[];
+}
+export interface VoiceCloneCapabilities {
+    type: "voice_clone";
+    maxSampleDurationSeconds?: number;
+    maxSampleSizeMB?: number;
+    formats?: string[];
+}
+export interface RerankCapabilities {
+    type: "rerank";
+    maxDocuments?: number;
+    maxQueryLength?: number;
+    maxDocumentLength?: number;
+}
+export interface DocumentParsingCapabilities {
+    type: "document_parsing";
+    supportedFormats?: string[];
+    maxPageCount?: number;
+    maxFileSizeMB?: number;
+}
+export type MediaCapabilities = VideoCapabilities | ImageCapabilities | MusicCapabilities | TtsCapabilities | ThreeDCapabilities | SttCapabilities | EmbeddingCapabilities | VideoUnderstandingCapabilities | ImageUnderstandingCapabilities | VoiceCloneCapabilities | RerankCapabilities | DocumentParsingCapabilities;
+/**
+ * Provider-specific quirks — drives conditional logic in transports.
+ * CC parity: provider detection via quirks flags instead of hardcoded if/else.
+ * altcode parity: provider auto-detect + per-provider parameter translation.
+ */
+export interface ProviderQuirks {
+    /** Provider doesn't support thinking content blocks (Qwen) */
+    filterThinkingBlocks?: boolean;
+    /** Provider doesn't support image content blocks — strip imageUrls before sending (DeepSeek, MiniMax) */
+    filterImageBlocks?: boolean;
+    /** DeepSeek: budget_tokens ignored, use output_config.effort instead */
+    useEffortInsteadOfBudget?: boolean;
+    /** Provider supports reasoning_effort param (Kimi K2, OpenAI o-series) */
+    supportsReasoningEffort?: boolean;
+    /** Provider has built-in web search (Kimi: builtin_function.$web_search, GLM: web_search) */
+    builtinWebSearch?: boolean;
+    /** Provider has built-in code interpreter */
+    builtinCodeInterpreter?: boolean;
+    /** Supports thinking.type="enabled"/"disabled" body param (Kimi K2, GLM).
+     *  Disambiguation: GLM also sets supportsToolStream; Kimi does not. */
+    supportsThinkingParam?: boolean;
+    /** GLM-only: supports tool_stream=true for incremental tool call streaming */
+    supportsToolStream?: boolean;
+    /** DeepSeek only maps to "high"|"max"; low/medium→high */
+    maxReasoningEffort?: "high" | "max";
+    /** Supports prefix completion via /beta endpoint (DeepSeek Beta) */
+    supportsPrefixCompletion?: boolean;
+    /** MiniMax OpenAI route: inject reasoning_split=true to split thinking into reasoning_details.
+     *  Streaming uses cumulative string updates (not incremental deltas). */
+    supportsReasoningSplit?: boolean;
+}
 export interface ProviderDef {
     /** Unique provider id, e.g. "deepseek", "openai", "anthropic" */
     id: string;
@@ -21,6 +128,12 @@ export interface ProviderDef {
     transport: TransportType;
     /** API base URL, e.g. "https://api.deepseek.com" */
     baseUrl: string;
+    /**
+     * Logical provider group — links protocol variants of the same vendor.
+     * e.g. both "zhipu" (anthropic) and "zhipu-openai" share group "zhipu".
+     * Defaults to provider id if unset.
+     */
+    group?: string;
     /** Env var names for API key (priority order) */
     apiKeyEnvVars: string[];
     /** Auth header style */
@@ -37,9 +150,11 @@ export interface ProviderDef {
     supportsStreamOptions?: boolean;
     /** Whether to omit temperature when it equals 0 (some providers reject 0) */
     omitZeroTemperature?: boolean;
+    /** Provider-specific quirks for transport-level conditional logic */
+    quirks?: ProviderQuirks;
 }
 export interface ModelInfo {
-    /** Model id, e.g. "deepseek-chat" */
+    /** Model id, e.g. "deepseek-v4-flash" */
     id: string;
     /** Display name, e.g. "DeepSeek Chat V3" */
     name: string;
@@ -51,6 +166,10 @@ export interface ModelInfo {
     toolCall: boolean;
     /** Has reasoning/thinking mode */
     reasoning: boolean;
+    /** Thinking is forced on — cannot be toggled off (e.g. QwQ, DeepSeek-R1) */
+    reasoningRequired?: boolean;
+    /** Model only supports streaming (non-stream requests will fail) */
+    streamRequired?: boolean;
     /** Supports vision (image input) */
     vision: boolean;
     /** Cost per 1M input tokens (USD) */
@@ -63,4 +182,6 @@ export interface ModelInfo {
     costCacheWrite?: number;
     /** Media generation capability — undefined means chat/reasoning model */
     mediaType?: MediaCapability;
+    /** Fine-grained media capabilities — operations, formats, limits */
+    mediaCapabilities?: MediaCapabilities;
 }

package/dist/types/llm/provider-registry.d.ts

@@ -41,6 +41,11 @@ export declare class ProviderRegistry {
      * Merges: Layer 3 override > Layer 1 builtin > Layer 2 catalog enrichment.
      */
     listModels(providerId: string): ModelInfo[];
+    /**
+     * Look up a single model's info by provider + model id.
+     * Returns undefined if the model is not found.
+     */
+    getModelInfo(providerId: string, modelId: string): ModelInfo | undefined;
     /**
      * Trigger background refresh of the remote model catalog.
      */

package/dist/types/llm/provider-tool-api.d.ts

@@ -0,0 +1,44 @@
+/**
+ * ProviderToolAPI — interface for provider-specific utility endpoints
+ * that are neither LLM chat nor media generation.
+ *
+ * Examples: web search, content reader, tokenizer, moderation, realtime voice.
+ * Each provider can expose its own set of tool APIs; the agent's tool cascade
+ * mechanism (Q1) routes to these when the provider has a native capability.
+ */
+export interface WebSearchResult {
+    title: string;
+    url: string;
+    snippet: string;
+    /** Full page content if available */
+    content?: string;
+}
+export interface ReaderResult {
+    title: string;
+    content: string;
+    url: string;
+}
+export interface TokenizerResult {
+    tokenCount: number;
+    model: string;
+}
+export interface ModerationResult {
+    flagged: boolean;
+    categories: Record<string, boolean>;
+    scores?: Record<string, number>;
+}
+export interface ProviderToolAPI {
+    /** Which tool APIs this provider supports */
+    readonly capabilities: readonly ProviderToolCapability[];
+    /** Web search — returns search result list */
+    webSearch?(query: string, options?: {
+        maxResults?: number;
+    }): Promise<WebSearchResult[]>;
+    /** URL reader — extracts content from a web page */
+    reader?(url: string): Promise<ReaderResult>;
+    /** Tokenizer — count tokens for given text/model */
+    tokenize?(text: string, model: string): Promise<TokenizerResult>;
+    /** Content moderation — check text for policy violations */
+    moderate?(text: string): Promise<ModerationResult>;
+}
+export type ProviderToolCapability = "web_search" | "reader" | "tokenizer" | "moderations";

package/dist/types/llm/retry.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared retry/backoff utilities for LLM transport implementations.
+ *
+ * Provides common constants and helper functions used by all transports
+ * (anthropic-messages, openai-chat, volcengine-responses) to handle
+ * transient errors with exponential backoff.
+ */
+/** Default maximum number of retry attempts */
+export declare const DEFAULT_MAX_RETRIES = 3;
+/** Base delay for exponential backoff (doubles each attempt, capped at 30s) */
+export declare const RETRY_BASE_DELAY_MS = 1000;
+/** Maximum backoff delay */
+export declare const RETRY_MAX_DELAY_MS = 30000;
+/** HTTP status codes considered transient (worth retrying) */
+export declare const TRANSIENT_STATUS_CODES: Set<number>;
+/** Default timeout for idle stream detection (no data received) */
+export declare const STREAM_IDLE_TIMEOUT_MS = 90000;
+/**
+ * Calculate the delay for a given retry attempt using exponential backoff with jitter.
+ * @param attempt 1-based attempt number (1 = first retry)
+ * @returns delay in milliseconds
+ */
+export declare function retryDelay(attempt: number): number;
+/**
+ * Check if an HTTP status code indicates a transient error worth retrying.
+ */
+export declare function isTransientStatus(status: number | null | undefined): boolean;
+/**
+ * Sleep with abort signal support. Resolves after `ms` milliseconds
+ * or rejects if the signal is aborted.
+ */
+export declare function retrySleep(ms: number, signal?: AbortSignal): Promise<void>;
+/**
+ * Extract HTTP status from various error shapes.
+ * Works with fetch Response errors, Axios errors, and generic errors with status property.
+ */
+export declare function extractHttpStatus(error: unknown): number | null;

package/dist/types/llm/transport.d.ts

@@ -9,17 +9,146 @@
  *   - Anthropic Messages API
  */
 import type { ChatMessage, ToolDefinition } from "../agent/types.js";
+export type StructuredOutputConfig = {
+    mode: "json_object";
+} | {
+    mode: "json_schema";
+    name: string;
+    schema: Record<string, unknown>;
+    strict?: boolean;
+};
+export interface CachingConfig {
+    type: "enabled" | "disabled";
+    /** Enable prefix caching mode (§20.3). Requires store=true and stream=false. */
+    prefix?: boolean;
+}
+export type ContextEdit = {
+    type: "clear_thinking";
+    keep?: "all" | {
+        type: "thinking_turns";
+        value: number;
+    };
+} | {
+    type: "clear_tool_uses";
+    trigger?: {
+        type: "tool_uses";
+        value: number;
+    };
+    keep?: {
+        type: "tool_uses";
+        value: number;
+    };
+    excludeTools?: string[];
+    clearToolInput?: boolean;
+};
+export interface ContextManagementConfig {
+    edits: ContextEdit[];
+}
 export interface LLMRequest {
     model: string;
     messages: ChatMessage[];
     tools?: ToolDefinition[];
-    toolChoice?: "auto" | "none" | "required";
+    toolChoice?: "auto" | "none" | "required" | {
+        type: "function";
+        name: string;
+    };
     temperature?: number;
+    /** Nucleus sampling: controls diversity via cumulative probability cutoff. */
+    topP?: number;
     maxTokens?: number;
     reasoning?: {
-        effort: "low" | "medium" | "high";
+        effort: "minimal" | "low" | "medium" | "high";
+        /** Request encrypted original reasoning content (Volcengine §17.7). */
+        includeEncryptedReasoning?: boolean;
     };
+    /** Volcengine: max builtin tool calls per turn (§19.15). */
+    maxToolCalls?: number;
+    /**
+     * DeepSeek prefix completion: force model to continue from this prefix.
+     * Requires `/beta` endpoint; adds a trailing assistant message with `prefix: true`.
+     */
+    prefixMessage?: string;
+    /**
+     * Model requires streaming — disable non-streaming fallback in transports.
+     * When true, transports must NOT fall back to non-streaming requests on failure.
+     * Set for models like QwQ/Omni where the provider rejects non-streaming calls.
+     */
+    streamRequired?: boolean;
+    /**
+     * Disable injection of provider-native builtin tools (web_search, code_interpreter)
+     * for this specific request. Allows session-level control over GLM/Kimi builtin tools.
+     */
+    disableBuiltinTools?: boolean;
+    /**
+     * Volcengine builtin tools to inject (web_search, image_process, knowledge_search).
+     * Each entry specifies a tool type and optional config.
+     * These are platform-executed tools requiring beta headers.
+     */
+    builtinTools?: Array<{
+        type: "builtin_web_search" | "builtin_image_process" | "builtin_knowledge_search" | "builtin_doubao_app";
+        config?: Record<string, unknown>;
+    }>;
+    /**
+     * Server-side context continuation via response chain (§5).
+     * When set, the server automatically includes previous context,
+     * so messages[] only needs to contain the NEW user message.
+     */
+    previousResponseId?: string;
+    /**
+     * Control server-side storage of this request's input/output (§5.1).
+     * Default: true (server stores for 3 days).
+     */
+    store?: boolean;
+    /** Expiration time for stored response (Unix seconds, max 7 days from now) */
+    storeExpireAt?: number;
+    /**
+     * Per-turn system instruction augmentation (§8).
+     * Temporarily overlays persona or adds constraints for this turn only.
+     * NOTE: Incompatible with caching — do not use both together.
+     */
+    instructions?: string;
+    /**
+     * Structured output format (§16).
+     * Forces model to produce JSON conforming to the specified schema.
+     */
+    structuredOutput?: StructuredOutputConfig;
+    /**
+     * Caching configuration (§20).
+     * Controls prefix/session caching behavior.
+     * NOTE: Incompatible with instructions, json_schema, and builtin tools.
+     */
+    caching?: CachingConfig;
+    /**
+     * Context management edits (§21, beta).
+     * Server-side trimming of historical thinking chains and tool call traces.
+     */
+    contextManagement?: ContextManagementConfig;
 }
+/**
+ * FIM completion request — DeepSeek Beta Completions API.
+ * POST /beta/v1/completions with prompt + suffix.
+ * Only works with non-thinking mode.
+ */
+export interface FIMRequest {
+    model: string;
+    /** Text before the cursor (prefix context) */
+    prompt: string;
+    /** Text after the cursor (suffix context) */
+    suffix?: string;
+    /** Max tokens to generate for the infill */
+    maxTokens?: number;
+    /** Sampling temperature */
+    temperature?: number;
+    /** Stop sequences */
+    stop?: string[];
+}
+export type FIMChunk = {
+    type: "delta";
+    text: string;
+} | {
+    type: "done";
+    finishReason: string;
+};
 export type LLMChunk = {
     type: "delta";
     text: string;
@@ -32,6 +161,10 @@ export type LLMChunk = {
 } | {
     type: "reasoning_delta";
     text: string;
+} | {
+    type: "reasoning_block_complete";
+    thinking: string;
+    signature: string;
 } | {
     type: "usage";
     promptTokens: number;
@@ -39,6 +172,27 @@ export type LLMChunk = {
     reasoningTokens?: number;
     cacheReadTokens?: number;
     cacheCreationTokens?: number;
+} | {
+    type: "response_id";
+    id: string;
+} | {
+    /** Informational status from platform-executed builtin tools (web_search, image_process). */
+    type: "builtin_tool_status";
+    toolType: string;
+    event: string;
+    data?: Record<string, unknown>;
+} | {
+    /** Web search citation annotations from Volcengine web_search results. */
+    type: "annotations";
+    annotations: Array<{
+        type: string;
+        url?: string;
+        title?: string;
+        [key: string]: unknown;
+    }>;
+} | {
+    type: "error";
+    message: string;
 } | {
     type: "done";
     finishReason: string;
@@ -54,6 +208,11 @@ export interface LLMTransport {
      * apiKey is passed explicitly (from agent.turn.config, not env).
      */
     stream(request: LLMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<LLMChunk>;
+    /**
+     * FIM (Fill-In-Middle) completion — optional capability.
+     * Only implemented by providers that support it (DeepSeek /beta endpoint).
+     */
+    complete?(request: FIMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<FIMChunk>;
 }
 /**
  * Accumulate tool_call_delta chunks into complete ToolCall objects.

package/dist/types/llm/transports/anthropic-messages.d.ts

@@ -12,6 +12,7 @@
  *   - signature_delta handling for thinking blocks
  */
 import type { LLMChunk, LLMRequest, LLMTransport } from "../transport.js";
+import type { ProviderQuirks } from "../provider-def.js";
 export interface AnthropicTransportConfig {
     baseUrl: string;
     /** anthropic-version header (default "2023-06-01") */
@@ -24,6 +25,10 @@ export interface AnthropicTransportConfig {
     enablePromptCaching?: boolean;
     /** Max retry attempts on transient errors (default 3) */
     maxRetries?: number;
+    /** Omit temperature when it equals 0 — MiniMax rejects temperature=0 */
+    omitZeroTemperature?: boolean;
+    /** Provider-specific quirks for conditional logic (CC/altcode parity) */
+    quirks?: ProviderQuirks;
 }
 export declare class AnthropicMessagesTransport implements LLMTransport {
     private baseUrl;
@@ -32,6 +37,8 @@ export declare class AnthropicMessagesTransport implements LLMTransport {
     private streamIdleTimeoutMs;
     private enablePromptCaching;
     private maxRetries;
+    private omitZeroTemperature;
+    private quirks;
     constructor(config: AnthropicTransportConfig);
     stream(request: LLMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<LLMChunk>;
     /**

package/dist/types/llm/transports/minimax-media.d.ts

@@ -18,4 +18,9 @@ export declare class MiniMaxMediaTransport implements MediaTransport {
     constructor(config: MiniMaxMediaConfig);
     generate(request: MediaRequest, apiKey: string, signal?: AbortSignal): Promise<MediaResult>;
     private pollTask;
+    /**
+     * Generate lyrics from a text prompt via MiniMax Lyrics Generation API.
+     * POST /v1/lyrics_generation — returns structured lyrics with tags.
+     */
+    generateLyrics(prompt: string, apiKey: string, signal?: AbortSignal): Promise<string>;
 }

package/dist/types/llm/transports/openai-chat.d.ts

@@ -11,7 +11,8 @@
  *
  * Adapted from admin-infer-proxy-client.ts SSE logic + Hermes openai_chat.py transport.
  */
-import type { LLMChunk, LLMRequest, LLMTransport } from "../transport.js";
+import type { LLMChunk, LLMRequest, LLMTransport, FIMRequest, FIMChunk } from "../transport.js";
+import type { ProviderQuirks } from "../provider-def.js";
 export interface OpenAIChatTransportConfig {
     baseUrl: string;
     /** Additional headers (e.g. for specific providers) */
@@ -22,6 +23,8 @@ export interface OpenAIChatTransportConfig {
     supportsStreamOptions?: boolean;
     /** Whether to omit temperature when it equals 0 (e.g. Moonshot rejects 0) */
     omitZeroTemperature?: boolean;
+    /** Provider-specific quirks (CC/altcode parity) */
+    quirks?: ProviderQuirks;
 }
 export declare class OpenAIChatTransport implements LLMTransport {
     private baseUrl;
@@ -29,8 +32,46 @@ export declare class OpenAIChatTransport implements LLMTransport {
     private timeoutMs;
     private supportsStreamOptions;
     private omitZeroTemperature;
+    private quirks;
+    private cumulativeReasoningLen;
+    private cumulativeContentLen;
     constructor(config: OpenAIChatTransportConfig);
     stream(request: LLMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<LLMChunk>;
-    private parseSSEStream;
-    private mapChunk;
+    private fetchAndStream;
+    /**
+     * Handle non-streaming JSON response from providers that ignore stream:true.
+     * Synthesize the same LLMChunk events a streaming response would produce.
+     */
+    private handleNonStreamingResponse;
+    /**
+     * Parse SSE stream with 90s idle watchdog (CC parity).
+     * If no data arrives within STREAM_IDLE_TIMEOUT_MS, throw to trigger retry.
+     */
+    private parseSSEStreamWithWatchdog;
+    private processChunk;
+    /**
+     * FIM completion via /beta/v1/completions.
+     * Only works with DeepSeek (requires supportsPrefixCompletion quirk).
+     * Non-thinking mode only; max completion 4K tokens.
+     */
+    complete(request: FIMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<FIMChunk>;
+    /**
+     * Upload a file for use in conversations (Kimi File API).
+     * Returns a file_id that can be referenced in user messages.
+     * POST /v1/files with multipart/form-data.
+     */
+    uploadFile(fileBlob: Blob, filename: string, purpose: string, apiKey: string, signal?: AbortSignal): Promise<{
+        fileId: string;
+        filename: string;
+        bytes: number;
+    }>;
+    /**
+     * Get file content/status — GET /v1/files/{file_id}
+     */
+    getFileInfo(fileId: string, apiKey: string, signal?: AbortSignal): Promise<{
+        id: string;
+        filename: string;
+        bytes: number;
+        status: string;
+    }>;
 }