qlogicagent 2.10.0 → 2.10.2

package/dist/types/provider-core/transports/volcengine-media.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Volcengine Media Transport 鈥?Doubao Seedream (image), Seedance (video), 3D generation.
+ *
+ * API reference:
+ *   Image:  POST /v3/images/generations            (sync)
+ *   Video:  POST /v3/contents/generations/tasks     (async job)
+ *   3D:     POST /v3/contents/generations/tasks     (async job, same endpoint as video)
+ *
+ * Auth: Authorization: Bearer $ARK_API_KEY
+ * Docs: https://www.volcengine.com/docs/82379/1330310
+ *       https://www.volcengine.com/docs/82379/1874993 (3D)
+ */
+import type { AsyncMediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
+export interface VolcengineMediaConfig {
+    /** Base URL, e.g. "https://ark.cn-beijing.volces.com/api" */
+    baseUrl: string;
+    timeoutMs?: number;
+}
+export declare class VolcengineMediaTransport implements AsyncMediaTransport {
+    readonly supportedTypes: readonly MediaType[];
+    private baseUrl;
+    private timeoutMs;
+    constructor(config: VolcengineMediaConfig);
+    generate(request: MediaRequest, apiKey: string, signal?: AbortSignal): Promise<MediaResult>;
+    /**
+     * Check if this transport can handle a given operation.
+     * Video edit/merge/upscale are routed through the same video endpoint.
+     */
+    canHandle(request: MediaRequest): boolean;
+    private generateImage;
+    /**
+     * Parse streaming image SSE 鈥?yields progressive image quality upgrades.
+     * Final event contains the full-quality image URL.
+     */
+    private parseStreamingImage;
+    private generateVideo;
+    private generate3D;
+    /**
+     * Query a single video generation task by ID.
+     * GET /v3/contents/generations/tasks/{taskId}
+     */
+    getTaskStatus(taskId: string, apiKey: string, signal?: AbortSignal): Promise<{
+        status: string;
+        task: Record<string, unknown>;
+    }>;
+    /**
+     * List video generation tasks with optional filters.
+     * GET /v3/contents/generations/tasks
+     */
+    listVideoTasks(apiKey: string, options?: {
+        after?: string;
+        limit?: number;
+        status?: string;
+    }, signal?: AbortSignal): Promise<Record<string, unknown>>;
+    /**
+     * Cancel or delete a video generation task.
+     * DELETE /v3/contents/generations/tasks/{taskId}
+     */
+    deleteVideoTask(taskId: string, apiKey: string, signal?: AbortSignal): Promise<void>;
+    /**
+     * Upload a file to Volcengine Files API for reuse in multimodal requests.
+     * POST /v3/files
+     */
+    uploadFile(file: Blob | Buffer, apiKey: string, options?: {
+        purpose?: string;
+        filename?: string;
+    }, signal?: AbortSignal): Promise<{
+        id: string;
+        status: string;
+    }>;
+    /**
+     * Get file info by ID.
+     * GET /v3/files/{fileId}
+     */
+    getFile(fileId: string, apiKey: string, signal?: AbortSignal): Promise<Record<string, unknown>>;
+    /**
+     * List uploaded files.
+     * GET /v3/files
+     */
+    listFiles(apiKey: string, options?: {
+        after?: string;
+        limit?: number;
+        purpose?: string;
+        order?: "asc" | "desc";
+    }, signal?: AbortSignal): Promise<Record<string, unknown>>;
+    /**
+     * Delete a file.
+     * DELETE /v3/files/{fileId}
+     */
+    deleteFile(fileId: string, apiKey: string, signal?: AbortSignal): Promise<void>;
+    private submitTask;
+    private pollTask;
+}

package/dist/types/provider-core/transports/volcengine-responses.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Volcengine Responses API TransportSSE streaming implementation.
+ *
+ * Implements the fire mountain ark Responses API (`/api/v3/responses`),
+ * which is the officially recommended primary path for Doubao LLM text generation
+ * (250615+ models: doubao-seed-2.0 series).
+ *
+ * Key differences from OpenAI Chat Completions:
+ *   - Endpoint: POST {baseUrl}/v3/responses
+ *   - Request body uses `input` (not `messages`), `instructions`, `thinking`, `reasoning`
+ *   - SSE events: response.output_text.delta, response.reasoning_summary_text.delta,
+ *     response.function_call_arguments.delta, response.completed, etc.
+ *   - Tool calling: function_call / function_call_output with call_id
+ *   - Context persistence: previous_response_id for server-side session continuation
+ *   - Deep thinking: thinking.type (enabled/disabled/auto) + reasoning.effort
+ *
+ * Docs: https://www.volcengine.com/docs/82379/1399008
+ */
+import type { LLMChunk, LLMRequest, LLMTransport } from "../transport.js";
+import type { ProviderQuirks } from "../provider-def.js";
+import type { FileUploadAdapter } from "../file-upload-service.js";
+export interface VolcengineResponsesTransportConfig {
+    baseUrl: string;
+    extraHeaders?: Record<string, string>;
+    timeoutMs?: number;
+    quirks?: ProviderQuirks;
+    /** File upload adapter for resolving local media URLs via upload instead of base64. */
+    fileUploadAdapter?: FileUploadAdapter;
+}
+export declare class VolcengineResponsesTransport implements LLMTransport {
+    private baseUrl;
+    private extraHeaders;
+    private timeoutMs;
+    private quirks;
+    private fileUploadAdapter?;
+    constructor(config: VolcengineResponsesTransportConfig);
+    stream(request: LLMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<LLMChunk>;
+    /**
+     * Resolve known Volcengine Responses API incompatibilities:
+     *   - instructions + caching 閳?drop caching (鎼?0.7)
+     *   - caching + json_schema 閳?downgrade to json_object (鎼?0.10)
+     *   - caching + builtin_web_search/image_process 閳?drop those builtin tools
+     * Returns a shallow copy with fields adjusted; never mutates the original.
+     */
+    private resolveConstraints;
+    private buildRequestBody;
+    private fetchAndStream;
+    private handleNonStreamingResponse;
+    /**
+     * Parse Volcengine Responses API SSE stream.
+     *
+     * Event format: "event: <type>\ndata: <json>\n\n"
+     * Key events:
+     *   - response.output_text.delta           閳?text content delta
+     *   - response.reasoning_summary_text.delta 閳?thinking/reasoning text
+     *   - response.function_call_arguments.delta 閳?tool call arguments streaming
+     *   - response.output_item.added           閳?new output item started
+     *   - response.output_item.done            閳?output item completed
+     *   - response.completed                   閳?full response complete with usage
+     *   - response.failed                      閳?error
+     */
+    private parseSSEStream;
+    private processEvent;
+}

package/dist/types/provider-core/transports/zhipu-media.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Zhipu (GLM) Media Transport 鈥?CogView (image), CogVideoX (video), TTS, STT, Embedding.
+ *
+ * API reference (docs.bigmodel.cn):
+ *   Image sync:  POST /images/generations          (CogView-4, cogview-3-flash)
+ *   Image async: POST /async/images/generations     (glm-image)
+ *   Video async: POST /videos/generations           (CogVideoX)
+ *   TTS sync:    POST /audio/speech                 (glm-tts, returns audio bytes)
+ *   STT sync:    POST /audio/transcriptions         (glm-asr, multipart/form-data)
+ *   Embedding:   POST /embeddings                   (embedding-3/2)
+ *   Async poll:  GET  /async-result/{id}            (unified poll for all async tasks)
+ *
+ * Base URL: https://open.bigmodel.cn/api/paas/v4
+ * Auth: Authorization: Bearer $ZHIPU_API_KEY
+ */
+import type { AsyncMediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
+export interface ZhipuMediaConfig {
+    /** Base URL, e.g. "https://open.bigmodel.cn/api/paas/v4" */
+    baseUrl: string;
+    timeoutMs?: number;
+}
+export declare class ZhipuMediaTransport implements AsyncMediaTransport {
+    readonly supportedTypes: readonly MediaType[];
+    private baseUrl;
+    private timeoutMs;
+    constructor(config: ZhipuMediaConfig);
+    generate(request: MediaRequest, apiKey: string, signal?: AbortSignal): Promise<MediaResult>;
+    private generateImage;
+    /** CogView-4 / cogview-3-flash 鈥?sync, returns URL directly */
+    private generateImageSync;
+    /** glm-image 鈥?async submit + poll */
+    private generateImageAsync;
+    private generateVideo;
+    private generateTTS;
+    private generateSTT;
+    private generateEmbedding;
+    private generateVoiceClone;
+    private generateDocumentParsing;
+    private generateRerank;
+    private postJSON;
+    /**
+     * Unified async result polling 鈥?GET /async-result/{id}
+     * Returns the result object when task_status === "SUCCESS".
+     * Throws on "FAIL" or timeout.
+     */
+    private pollAsyncResult;
+    /**
+     * Query a single task status 鈥?GET /async-result/{id}
+     * Zhipu uses a unified async result endpoint for all task types.
+     */
+    getTaskStatus(taskId: string, apiKey: string, signal?: AbortSignal): Promise<{
+        status: string;
+        task: Record<string, unknown>;
+    }>;
+    /**
+     * List recent tasks 鈥?Zhipu does not have a native list endpoint.
+     * Returns empty since individual task query via getTaskStatus() is the primary API.
+     */
+    listVideoTasks(_apiKey: string, _options?: {
+        after?: string;
+        limit?: number;
+        status?: string;
+    }, _signal?: AbortSignal): Promise<Record<string, unknown>>;
+    /**
+     * Cancel/delete is not supported by Zhipu's async API 鈥?throws informative error.
+     * The /async-result/{id} endpoint is read-only.
+     */
+    deleteVideoTask(_taskId: string, _apiKey: string, _signal?: AbortSignal): Promise<void>;
+    /**
+     * List cloned voices 鈥?GET /voice/
+     * Returns all voice clones for the current user.
+     */
+    listVoices(apiKey: string, signal?: AbortSignal): Promise<Array<{
+        voice_id: string;
+        voice_name: string;
+        status: string;
+    }>>;
+    /**
+     * Delete a cloned voice 鈥?DELETE /voice/{voice_id}
+     */
+    deleteVoice(voiceId: string, apiKey: string, signal?: AbortSignal): Promise<void>;
+}

package/dist/types/provider-core/transports/zhipu-tool-api.d.ts

@@ -0,0 +1,35 @@
+/**
+ * ZhipuToolAPI 鈥?Zhipu-specific utility endpoints.
+ *
+ * Implements ProviderToolAPI for Zhipu GLM platform independent APIs:
+ *   C1: Web Search  鈥?POST /tools/web-search
+ *   C2: Reader      鈥?POST /tools/reader (extract web page content)
+ *   C3: Tokenizer   鈥?POST /tokenizer
+ *   C4: Moderations 鈥?POST /moderations
+ *
+ * Base URL: https://open.bigmodel.cn/api/paas/v4
+ * Auth: Authorization: Bearer $ZHIPU_API_KEY
+ *
+ * C5 (File Parser) is handled by document_parsing media handler.
+ * C6 (Realtime API) requires WebSocket 鈥?out of scope for this interface.
+ */
+import type { ProviderToolAPI, ProviderToolCapability, WebSearchResult, ReaderResult, TokenizerResult, ModerationResult } from "../provider-tool-api.js";
+export interface ZhipuToolAPIConfig {
+    baseUrl: string;
+    apiKey: string;
+    timeoutMs?: number;
+}
+export declare class ZhipuToolAPI implements ProviderToolAPI {
+    readonly capabilities: readonly ProviderToolCapability[];
+    private baseUrl;
+    private apiKey;
+    private timeoutMs;
+    constructor(config: ZhipuToolAPIConfig);
+    webSearch(query: string, options?: {
+        maxResults?: number;
+    }): Promise<WebSearchResult[]>;
+    reader(pageUrl: string): Promise<ReaderResult>;
+    tokenize(text: string, model: string): Promise<TokenizerResult>;
+    moderate(text: string): Promise<ModerationResult>;
+    private postJSON;
+}

package/dist/types/provider-core/wire-types.d.ts

@@ -0,0 +1,51 @@
+export type ChatMessageRole = "system" | "user" | "assistant" | "tool";
+export interface ThinkingBlock {
+    thinking: string;
+    signature: string;
+}
+export interface ToolCallMessage {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface ChatMessage {
+    role: ChatMessageRole;
+    content: string | null;
+    tool_calls?: ToolCallMessage[];
+    tool_call_id?: string;
+    name?: string;
+    thinkingBlocks?: ThinkingBlock[];
+    imageUrls?: string[];
+    imageDetail?: "auto" | "low" | "high" | "xhigh";
+    imagePixelLimit?: {
+        minPixels?: number;
+        maxPixels?: number;
+    };
+    videoUrls?: string[];
+    videoFps?: number;
+    audioFormat?: "mp3" | "wav" | "aac" | "m4a";
+    audioUrls?: string[];
+    fileIds?: Array<{
+        id: string;
+        mimeType?: string;
+        size?: number;
+    }>;
+}
+export interface ToolDefinition {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters?: Record<string, unknown>;
+    };
+    meta?: {
+        serialOnly?: boolean;
+        parallelSafe?: boolean;
+        requiresApproval?: boolean;
+        isReadOnly?: boolean;
+        isDangerous?: boolean;
+    };
+}

package/dist/types/runtime/execution/dream-agent.d.ts

@@ -12,7 +12,7 @@
  */
 import type { DreamTaskState, DreamTurn } from "../../orchestration/subagent/task-types.js";
 import type { ToolDefinition, ToolInvoker, AgentLogger, HookRegistry } from "../../agent/types.js";
-import type { LLMTransport } from "@qlogic/provider-core";
+import type { LLMTransport } from "../../provider-core/index.js";
 export interface DreamTriggerConfig {
     /** Minimum hours since last consolidation. Default: 24. */
     minHours: number;

package/dist/types/runtime/execution/forked-agent.d.ts

@@ -18,7 +18,7 @@
  * Reference: claude-code src/utils/forkedAgent.ts
  */
 import type { AgentLogger, ChatMessage, ToolDefinition, ToolInvoker, TokenUsage, TurnEvent, HookRegistry } from "../../agent/types.js";
-import type { LLMTransport } from "@qlogic/provider-core";
+import type { LLMTransport } from "../../provider-core/index.js";
 import type { AgentProgress } from "./progress-tracker.js";
 /**
  * Tool permission check function — CC canUseTool parity.

package/dist/types/runtime/hooks/context-compression.d.ts

@@ -1,7 +1,7 @@
 import { ContextEngineRegistry, type CompressibleMessage, type CompressionResult, type CompressionStrategy, type AsyncCompressionStrategy, type SummarizeFn } from "../../orchestration/index.js";
 import type { HookRegistry } from "./hook-registry.js";
 import type { RuntimeLogger } from "./hook-registry.js";
-import type { LLMTransport } from "@qlogic/provider-core";
+import type { LLMTransport } from "../../provider-core/index.js";
 /** Rough token estimate: ~4 chars per token for mixed CJK/English. */
 export declare function estimateTokens(msg: CompressibleMessage): number;
 /** Estimate total tokens for a message array. */

package/dist/types/runtime/infra/llmrouter-catalog.d.ts

@@ -0,0 +1,49 @@
+import type { ModelEntry, ModelRegistry } from "./model-registry.js";
+export declare const LLMROUTER_CATALOG_UNAVAILABLE_MESSAGE = "\u65E0\u6CD5\u8FDE\u63A5 llmrouter \u6A21\u578B\u76EE\u5F55";
+export declare class LlmrouterCatalogUnavailableError extends Error {
+    constructor(message?: string);
+}
+export interface LlmrouterCatalogProvider {
+    id: string;
+    name?: string;
+    displayName?: string;
+    baseUrl?: string;
+    base_url?: string;
+    transport?: string;
+    models?: Array<{
+        id?: string;
+    }>;
+}
+export interface LlmrouterCatalogModel {
+    id: string;
+    public_model?: string;
+    publicModel?: string;
+    provider?: string;
+    owned_by?: string;
+    native_model_id?: string;
+    nativeModelId?: string;
+    display_name?: string;
+    displayName?: string;
+    name?: string;
+    category?: string;
+    purposes?: string[];
+    baseUrl?: string;
+    base_url?: string;
+    provider_transport?: string;
+    providerTransport?: string;
+    context_window?: number;
+    contextWindow?: number;
+    max_output?: number;
+    maxOutput?: number;
+    stream_required?: boolean;
+    streamRequired?: boolean;
+    capabilities?: string[];
+    pricing?: Record<string, unknown>;
+}
+export declare function listLlmrouterCatalogProviders(): Promise<LlmrouterCatalogProvider[]>;
+export declare function listLlmrouterCatalogModels(): Promise<LlmrouterCatalogModel[]>;
+export declare function providerDisplayName(provider: LlmrouterCatalogProvider): string;
+export declare function providerBaseUrl(provider: LlmrouterCatalogProvider): string | undefined;
+export declare function getLlmrouterCatalogProvider(providerId: string): Promise<LlmrouterCatalogProvider | null>;
+export declare function refreshRegistryFromLlmrouterCatalog(registry: ModelRegistry): Promise<ModelEntry[]>;
+export declare function toModelEntry(model: LlmrouterCatalogModel): ModelEntry | null;

package/dist/types/runtime/infra/model-registry.d.ts

@@ -1,19 +1,24 @@
-/**
- * Model Registry — centralized model pool + per-purpose binding.
- *
- * Architecture: User adds Provider keys → enables models → binds each purpose to a model.
- * Any code needing a model calls `registry.getActiveModel(purpose)`.
- * Turn handler, media handler, STT, TTS — all go through this single source of truth.
- *
- * Persistence: ~/.qlogicagent/settings.json
- * Runtime state (key health, inFlight): in-memory via KeyPool
- */
-import { type ProviderPoolConfig, type KeyConfig, type LoadBalanceStrategy, type KeyHandle, type PoolStatus } from "./key-pool.js";
-import { type ModelInfo, type ProviderDef } from "@qlogic/provider-core";
+import { type KeyConfig, type KeyHandle, type LoadBalanceStrategy, type PoolStatus, type ProviderPoolConfig } from "./key-pool.js";
 export type RegistryChangeCallback = () => void;
-/** Purpose categories for model routing. */
 export type ModelPurpose = "textGeneration" | "smallModel" | "stt" | "tts" | "imageGeneration" | "imageUnderstanding" | "videoGeneration" | "videoUnderstanding" | "threeDGeneration" | "embedding" | "voiceClone" | "musicGeneration" | "realtimeAudio" | "realtimeVideo";
-/** A model entry in the available model pool. */
+export interface ModelInfo {
+    id: string;
+    name?: string;
+    contextWindow?: number;
+    maxOutput?: number;
+    streamRequired?: boolean;
+    vision?: boolean;
+    mediaType?: string;
+}
+export interface ProviderDef {
+    id: string;
+    name: string;
+    transport: string;
+    baseUrl: string;
+    defaultModel?: string;
+    group?: string;
+    models?: ModelInfo[];
+}
 export interface ModelEntry {
     id: string;
     provider: string;
@@ -22,17 +27,23 @@ export interface ModelEntry {
     purposes: ModelPurpose[];
     baseUrl?: string;
     enabled: boolean;
+    transport?: string;
+    contextWindow?: number;
+    maxOutput?: number;
+    streamRequired?: boolean;
+    capabilities?: string[];
+    pricing?: Record<string, unknown>;
 }
-/** Per-purpose binding: maps purpose → model ID. */
 export type PurposeBindings = Partial<Record<ModelPurpose, string>>;
-/** Persistent settings.json schema (new architecture). */
 export interface ModelRegistryConfig {
     providers: ProviderPoolConfig[];
-    models: ModelEntry[];
+    models: Array<{
+        id: string;
+        enabled?: boolean;
+    }>;
     bindings: PurposeBindings;
     tunables?: Record<string, unknown>;
 }
-/** Resolved model ready for API call. */
 export interface ResolvedModel {
     provider: string;
     model: string;
@@ -40,34 +51,18 @@ export interface ResolvedModel {
     baseUrl?: string;
     keyHandle: KeyHandle;
 }
+export declare const ALL_PURPOSES: ModelPurpose[];
 export declare class ModelRegistry {
     private keyPool;
     private models;
+    private modelEnabledOverrides;
     private bindings;
     private settingsPath;
     private changeListeners;
     constructor(config?: ModelRegistryConfig);
-    /**
-     * Get the currently bound model for a purpose, with a live API key from the pool.
-     * Returns null if purpose is not bound or no key is available.
-     *
-     * IMPORTANT: Caller MUST call result.keyHandle.release({ success, tokens? }) when done.
-     */
     getActiveModel(purpose: ModelPurpose): ResolvedModel | null;
-    /**
-     * Peek at the bound model for a purpose WITHOUT acquiring a key.
-     * Useful for UI display, description generation, etc.
-     */
     peekActiveModel(purpose: ModelPurpose): ModelEntry | null;
-    /**
-     * Check if a purpose has an available model + key (without acquiring).
-     */
     isAvailable(purpose: ModelPurpose): boolean;
-    /**
-     * Resolve a model name for a purpose, falling back to textGeneration if not bound.
-     * Returns the raw model string (e.g. "deepseek-v4-flash") or null if nothing configured.
-     * Does NOT acquire a key — use for cases where the caller already has transport/key.
-     */
     resolveModelForPurpose(purpose: ModelPurpose): string | null;
     addProvider(providerId: string, opts?: {
         baseUrl?: string;
@@ -89,6 +84,8 @@ export declare class ModelRegistry {
     addModel(entry: Omit<ModelEntry, "id"> & {
         id?: string;
     }): string;
+    replaceCatalogModels(entries: ModelEntry[]): void;
+    migrateModelIds(aliasToNative: Map<string, string>): void;
     removeModel(id: string): void;
     enableModel(id: string): void;
     disableModel(id: string): void;
@@ -104,84 +101,22 @@ export declare class ModelRegistry {
     getAllBindings(): Record<string, ModelEntry | null>;
     getProviderStatus(providerId: string): PoolStatus | null;
     getAllProviderStatus(): PoolStatus[];
-    /** Save current config to settings.json. Preserves non-model fields (tunables, theme, etc.). */
     save(): void;
-    /** Load config from settings.json. Returns false if file not found or parse error. */
     load(): boolean;
-    /** Export full config (for serialization/transfer). */
     exportConfig(): ModelRegistryConfig;
-    /**
-     * Read a tunable value from settings.json tunables section.
-     * Returns undefined if not set. Does NOT write — read-only accessor.
-     */
     getTunable<T = unknown>(key: string): T | undefined;
-    private _providerRegistry;
-    private getProviderRegistry;
-    /**
-     * Get model metadata (streamRequired, contextWindow, etc.) from the merged
-     * provider-core registry. Replaces direct `this.registry.getModelInfo(...)`.
-     */
     getModelInfo(providerId: string, modelId: string): ModelInfo | undefined;
-    /**
-     * Get the default model id for a provider (from builtin-providers).
-     * Replaces `this.registry.getProvider(provider)?.defaultModel`.
-     */
     getProviderDefaultModel(providerId: string): string | undefined;
-    /**
-     * List all known provider definitions (builtin + catalog).
-     * Replaces `this.registry.listProviders()`.
-     */
     listProviderDefs(): ProviderDef[];
-    /**
-     * Resolve an API key for a provider via env vars (fallback when KeyPool has no key).
-     * Replaces `this.registry.resolveApiKey(providerId)`.
-     */
     resolveProviderApiKey(providerId: string): string | undefined;
-    /**
-     * Register a callback to be notified when registry state changes
-     * (binding change, model add/remove, key change, save/load).
-     * Returns an unsubscribe function.
-     */
     onChange(callback: RegistryChangeCallback): () => void;
-    private emitChange;
-    /**
-     * Snapshot one available key for a provider WITHOUT holding it (for legacy flat-map consumers).
-     * Returns null if no healthy key exists.
-     */
     getKeyForProvider(providerId: string): string | null;
-    /**
-     * Snapshot one key per provider (for media tools flat apiKeys map).
-     */
     snapshotProviderKeys(): Record<string, string>;
     private getProviderBaseUrl;
+    private loadModelState;
+    private exportModelState;
+    private emitChange;
 }
-export declare const ALL_PURPOSES: ModelPurpose[];
-/**
- * Get the global ModelRegistry singleton.
- * Lazily loads from settings.json on first access.
- */
 export declare function getModelRegistry(): ModelRegistry;
-/**
- * Reset the global singleton (for testing or hot-reload).
- */
 export declare function resetModelRegistry(): void;
-/**
- * Derive which purposes a model supports from its ModelInfo metadata.
- * Layer 1: ModelCatalog (models.dev) modalities → purpose mapping.
- *
- * Priority: mediaType field → vision field → fallback to textGeneration.
- */
 export declare function deriveModelPurposes(model: ModelInfo): ModelPurpose[];
-/**
- * Layer 3: Name-based heuristic for models not in ModelCatalog or builtin-providers.
- */
-export declare function heuristicModelPurposes(modelId: string): ModelPurpose[];
-/**
- * Refresh models from ModelCatalog (remote models.dev + disk cache) for given providers.
- * Merges discovered models into the registry without overwriting user-modified entries.
- */
-export declare function refreshModelsFromCatalog(registry: ModelRegistry, providerIds: string[]): void;
-/**
- * Force refresh the ModelCatalog from remote, then merge into registry.
- */
-export declare function forceRefreshCatalog(registry: ModelRegistry, providerIds: string[]): Promise<boolean>;

package/dist/types/runtime/session/session-persistence.d.ts

@@ -107,7 +107,7 @@ export declare function deleteSession(sessionId: string, projectRoot: string): P
  */
 export declare function pruneOldSessions(projectRoot: string): Promise<number>;
 export interface TaskSummaryDeps {
-    transport: import("@qlogic/provider-core").LLMTransport;
+    transport: import("../../provider-core/index.js").LLMTransport;
     apiKey: string;
     model: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qlogicagent",
-  "version": "2.10.0",
+  "version": "2.10.2",
   "description": "XiaozhiClaw Agent CLI — subprocess architecture (JSON-RPC over stdio)",
   "type": "module",
   "main": "dist/index.js",
@@ -62,7 +62,6 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "@qlogic/provider-core": "workspace:*",
     "better-sqlite3": "^12.10.0",
     "dotenv": "^17.3.1",
     "nanoid": "^5.1.5",
@@ -75,6 +74,7 @@
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.15.0",
+    "@qlogic/provider-core": "workspace:*",
     "esbuild": "^0.28.0",
     "tsx": "^4.19.0",
     "typescript": "^5.9.0",

package/dist/types/runtime/infra/builtin-providers.d.ts

@@ -1,36 +0,0 @@
-/**
- * Supported provider metadata for settings RPC.
- *
- * Bridges provider-core's BUILTIN_PROVIDERS into the ModelPurpose system.
- * This is the authoritative list of providers shown in "Add Key" UI.
- *
- * IMPORTANT: Model lists here are the Layer 2 (offline fallback) data source.
- * Layer 1 is ModelCatalog (models.dev remote). These two are the ONLY sources.
- */
-import type { ModelPurpose } from "./model-registry.js";
-export interface KnownModelMeta {
-    model: string;
-    displayName: string;
-    purposes: ModelPurpose[];
-    baseUrl?: string;
-}
-export interface SupportedProviderMeta {
-    id: string;
-    displayName: string;
-    baseUrl: string;
-    defaultRateLimit?: {
-        rpm?: number;
-        tpm?: number;
-    };
-    knownModels: KnownModelMeta[];
-}
-/**
- * Minimal offline fallback providers.
- * Remote catalog (Layer 1) has text generation models; this Layer 2 keeps ONLY
- * specialized models that remote may not cover: embedding, TTS, STT, image gen,
- * video gen, music gen, 3D gen, realtime voice/video, voice clone.
- *
- * All providers are kept (for Add Key UI dropdown + baseUrl lookup).
- * Text generation / image understanding models are NOT listed here — remote always has them.
- */
-export declare const SUPPORTED_PROVIDERS: SupportedProviderMeta[];