qlogicagent 0.6.0 → 1.0.0

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

@@ -1,31 +1,54 @@
 /**
  * Anthropic Messages Transport — SSE streaming for Claude API.
  *
- * POST {baseUrl}/v1/messages with stream: true
- * Auth: x-api-key: {apiKey} + anthropic-version header
- *
- * SSE event types:
- *   message_start, content_block_start, content_block_delta,
- *   content_block_stop, message_delta, message_stop
- *
- * Tool use is via content blocks with type "tool_use" + "input_json_delta".
- *
- * Aligned with Hermes anthropic_messages.py transport.
+ * Aligned with CC (claude-code-haha) src/services/api/claude.ts:
+ *   - cache_control ephemeral injection on system prompt blocks
+ *   - ensureToolResultPairing() conversation repair before every request
+ *   - Retry with exponential backoff on transient errors (429/529/overloaded)
+ *   - Non-streaming fallback when stream errors out
+ *   - 90s idle watchdog timeout for silently dropped connections
+ *   - Adaptive/budget thinking with temperature omit
+ *   - Cache token extraction with >0 guard (CC updateUsage parity)
+ *   - signature_delta handling for thinking blocks
  */
 import type { LLMChunk, LLMRequest, LLMTransport } from "../transport.js";
 export interface AnthropicTransportConfig {
     baseUrl: string;
     /** anthropic-version header (default "2023-06-01") */
     apiVersion?: string;
-    /** Timeout in ms (default 180_000) */
+    /** Per-request timeout in ms (default 180_000) */
     timeoutMs?: number;
+    /** Stream idle watchdog timeout in ms (default 90_000, CC parity) */
+    streamIdleTimeoutMs?: number;
+    /** Enable prompt caching via cache_control ephemeral (default true) */
+    enablePromptCaching?: boolean;
+    /** Max retry attempts on transient errors (default 3) */
+    maxRetries?: number;
 }
 export declare class AnthropicMessagesTransport implements LLMTransport {
     private baseUrl;
     private apiVersion;
     private timeoutMs;
+    private streamIdleTimeoutMs;
+    private enablePromptCaching;
+    private maxRetries;
     constructor(config: AnthropicTransportConfig);
     stream(request: LLMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<LLMChunk>;
+    /**
+     * Stream with idle watchdog timer (CC parity: 90s default).
+     * Throws if no chunks received for streamIdleTimeoutMs.
+     */
+    private streamWithWatchdog;
+    /**
+     * Non-streaming fallback (CC executeNonStreamingRequest parity).
+     * Used when streaming fails after all retries.
+     * Caps max_tokens at 64K and adjusts thinking budget accordingly.
+     */
+    private nonStreamingFallback;
+    /**
+     * Convert a non-streaming API response to LLMChunk sequence.
+     */
+    private mapNonStreamingResponse;
     private parseSSEStream;
     private mapEvent;
 }

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

@@ -0,0 +1,21 @@
+/**
+ * Gemini Media Transport — Image generation via Gemini generateContent.
+ *
+ * Uses responseModalities: ["TEXT", "IMAGE"] with the Gemini REST API.
+ * POST /v1beta/models/{model}:generateContent
+ * Auth: key= query param or x-goog-api-key header
+ * Docs: https://ai.google.dev/gemini-api/docs/image-generation
+ */
+import type { MediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
+export interface GeminiMediaConfig {
+    /** Base URL, e.g. "https://generativelanguage.googleapis.com/v1beta/openai" */
+    baseUrl: string;
+    timeoutMs?: number;
+}
+export declare class GeminiMediaTransport implements MediaTransport {
+    readonly supportedTypes: readonly MediaType[];
+    private apiBase;
+    private timeoutMs;
+    constructor(config: GeminiMediaConfig);
+    generate(request: MediaRequest, apiKey: string, signal?: AbortSignal): Promise<MediaResult>;
+}

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

@@ -0,0 +1,21 @@
+/**
+ * MiniMax Media Transport — Music Generation API (music-2.6, music-cover).
+ *
+ * POST /v1/music_generation (async job: submit → poll → result)
+ * Auth: Authorization: Bearer $MINIMAX_API_KEY
+ * Docs: https://platform.minimaxi.com/document/Music
+ */
+import type { MediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
+export interface MiniMaxMediaConfig {
+    /** Base URL, e.g. "https://api.minimaxi.com" */
+    baseUrl: string;
+    timeoutMs?: number;
+}
+export declare class MiniMaxMediaTransport implements MediaTransport {
+    readonly supportedTypes: readonly MediaType[];
+    private baseUrl;
+    private timeoutMs;
+    constructor(config: MiniMaxMediaConfig);
+    generate(request: MediaRequest, apiKey: string, signal?: AbortSignal): Promise<MediaResult>;
+    private pollTask;
+}

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

@@ -2,7 +2,7 @@
  * OpenAI Chat Completions Transport — SSE streaming implementation.
  *
  * Covers all OpenAI-compatible providers:
- *   DeepSeek, Qwen, 硅基, Minimax, Moonshot, Groq, Together, OpenRouter, etc.
+ *   DeepSeek, Qwen, Minimax, Moonshot, OpenRouter, etc.
  *
  * POST {baseUrl}/v1/chat/completions with stream: true
  * Auth: Authorization: Bearer {apiKey}

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

@@ -0,0 +1,24 @@
+/**
+ * OpenAI Media Transport — Images API (gpt-image-2) + Audio Speech API (tts-1).
+ *
+ * Image:  POST /v1/images/generations (sync response, returns URLs)
+ * TTS:    POST /v1/audio/speech      (sync response, returns raw audio bytes)
+ * Auth: Authorization: Bearer $OPENAI_API_KEY
+ * Docs: https://platform.openai.com/docs/api-reference/images/create
+ *       https://platform.openai.com/docs/api-reference/audio/createSpeech
+ */
+import type { MediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
+export interface OpenAIMediaConfig {
+    /** Base URL, e.g. "https://api.openai.com" */
+    baseUrl: string;
+    timeoutMs?: number;
+}
+export declare class OpenAIMediaTransport implements MediaTransport {
+    readonly supportedTypes: readonly MediaType[];
+    private baseUrl;
+    private timeoutMs;
+    constructor(config: OpenAIMediaConfig);
+    generate(request: MediaRequest, apiKey: string, signal?: AbortSignal): Promise<MediaResult>;
+    private generateImage;
+    private generateTTS;
+}

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

@@ -0,0 +1,25 @@
+/**
+ * Qwen (DashScope) Media Transport — TTS via CosyVoice.
+ *
+ * DashScope TTS uses the async task API:
+ *   Submit: POST /api/v1/services/aigc/text2audio/generation
+ *   Poll:   GET  /api/v1/tasks/{taskId}
+ *
+ * Auth: Authorization: Bearer $DASHSCOPE_API_KEY
+ * Docs: https://help.aliyun.com/zh/model-studio/developer-reference/cosyvoice-large-speech-synthesis
+ */
+import type { MediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
+export interface QwenMediaConfig {
+    /** Base URL, e.g. "https://dashscope.aliyuncs.com" */
+    baseUrl: string;
+    timeoutMs?: number;
+}
+export declare class QwenMediaTransport implements MediaTransport {
+    readonly supportedTypes: readonly MediaType[];
+    private baseUrl;
+    private timeoutMs;
+    constructor(config: QwenMediaConfig);
+    generate(request: MediaRequest, apiKey: string, signal?: AbortSignal): Promise<MediaResult>;
+    private pollTask;
+    private extractAudioUrl;
+}

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

@@ -0,0 +1,34 @@
+/**
+ * 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/3d-contents/generations/tasks  (async job)
+ *
+ * Auth: Authorization: Bearer $ARK_API_KEY
+ * Docs: https://www.volcengine.com/docs/82379/1330310
+ */
+import type { MediaTransport, 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 MediaTransport {
+    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;
+    private generateVideo;
+    private generate3D;
+    private submitTask;
+    private pollTask;
+}

package/dist/types/orchestration/tool-loop/tool-schema.d.ts

@@ -21,7 +21,6 @@ export interface CapabilityToolManifestLike {
     description?: string;
     requiredParameters?: string[];
 }
-export declare function isXaiProvider(modelProvider?: string, modelId?: string): boolean;
 export declare function normalizeFunctionToolParameters(parameters: Record<string, unknown> | undefined, options?: ToolSchemaProvider): Record<string, unknown>;
 export declare function convertFunctionTools(tools: readonly FunctionToolSource[], options?: ToolSchemaProvider): FunctionToolDefinition[];
 export declare function convertCapabilityToolManifestsToFunctionTools(tools: readonly CapabilityToolManifestLike[]): FunctionToolDefinition[];
@@ -30,7 +29,7 @@ export declare function parseOpenAiToolCallsFromChatResponse(responseBody: strin
     toolCalls: OpenAiToolCall[];
     responseText: string;
 };
-export declare function buildAssistantToolCallMessage(toolCalls: OpenAiToolCall[]): Record<string, unknown>;
+export declare function buildAssistantToolCallMessage(toolCalls: OpenAiToolCall[], text?: string): Record<string, unknown>;
 export declare function buildToolResultMessage(callId: string, result: {
     ok: boolean;
     payload?: unknown;

package/dist/types/protocol/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Protocol barrel — centralized re-export of all agent RPC contracts.
+ *
+ * Import from here: `import type { NotificationMethod, RpcMethod } from "../protocol/index.js";`
+ */
+export * from "./notifications.js";
+export * from "./methods.js";

package/dist/types/protocol/methods.d.ts

@@ -0,0 +1,380 @@
+/**
+ * Centralized RPC Method Protocol — all JSON-RPC request methods
+ * that qlogicagent exposes to external apps.
+ *
+ * This is the SINGLE SOURCE OF TRUTH for the agent's inbound API contract.
+ *
+ * Reference: Codex app-server RPC, Claude Code JSON-RPC, GitHub Copilot Agent API.
+ */
+import type { ChatMessage, ToolDefinition } from "../agent/types.js";
+import type { TodoItem } from "../contracts/todo.js";
+export interface InitializeParams {
+    protocolVersion: string;
+    host?: {
+        name: string;
+        version: string;
+    };
+    /** Legacy flat form. */
+    hostName?: string;
+    hostVersion?: string;
+    capabilities?: {
+        streaming?: boolean;
+        toolApproval?: boolean;
+        threads?: boolean;
+    };
+    config?: Record<string, unknown>;
+}
+export interface InitializeResult {
+    protocolVersion: string;
+    agent: {
+        name: string;
+        version: string;
+    };
+    capabilities: {
+        tools: string[];
+        streaming: boolean;
+        threads: boolean;
+        /** New: list of notification methods the agent can emit. */
+        notifications: string[];
+        /** New: list of RPC methods the agent supports. */
+        methods: string[];
+    };
+}
+export interface ThreadCreateParams {
+    id?: string;
+    title?: string;
+    cwd?: string;
+    config?: Record<string, unknown>;
+}
+export interface ThreadCreateResult {
+    id: string;
+    title?: string;
+    status: "active";
+    createdAt: string;
+}
+export interface ThreadListParams {
+    limit?: number;
+}
+export interface ThreadListResult {
+    threads: Array<{
+        id: string;
+        title?: string;
+        status: "active" | "archived";
+        turnCount?: number;
+        createdAt: string;
+        lastActiveAt: string;
+    }>;
+}
+export interface ThreadTurnParams {
+    turnId?: string;
+    sessionId: string;
+    messages?: ChatMessage[];
+    tools?: ToolDefinition[];
+    config?: Record<string, unknown>;
+}
+export interface ThreadTurnResult {
+    accepted: boolean;
+    turnId: string;
+}
+export interface SessionResumeParams {
+    sessionId: string;
+}
+export interface SessionResumeResult {
+    metadata: {
+        sessionId: string;
+        createdAt: number;
+        lastActiveAt: number;
+        model?: string;
+        cwd?: string;
+        turnCount: number;
+        messageCount: number;
+        title?: string;
+    };
+    messages: ChatMessage[];
+    costSnapshot?: Record<string, unknown>;
+}
+export interface SessionGetInfoParams {
+    sessionId?: string;
+}
+export interface SessionGetInfoResult {
+    sessionId: string;
+    /** Persistent storage paths for this session. */
+    paths: {
+        /** Session directory (~/.qlogicagent/sessions/<id>/). */
+        sessionDir: string;
+        /** Transcript file path. */
+        transcript: string;
+        /** Session state file path. */
+        state: string;
+        /** Agent home root (~/.qlogicagent/). */
+        agentHome: string;
+        /** User settings path. */
+        settings: string;
+        /** Current working directory. */
+        cwd: string;
+    };
+    model?: string;
+    provider?: string;
+    turnCount: number;
+    title?: string;
+    /** Cumulative token usage for the session. */
+    usage?: {
+        totalPromptTokens: number;
+        totalCompletionTokens: number;
+        totalCost?: number;
+    };
+}
+export interface MemoryListParams {
+    /** Filter by source: "local" (md files), "store" (in-memory), "qmemory" (remote). */
+    source?: "local" | "store" | "qmemory" | "all";
+}
+export interface MemoryListResult {
+    entries: Array<{
+        source: "local" | "store" | "qmemory";
+        target?: string;
+        path?: string;
+        entryCount: number;
+        charCount: number;
+        lastModified?: string;
+    }>;
+}
+export interface MemoryReadParams {
+    /** Source to read from. */
+    source: "local" | "store" | "qmemory";
+    /** Target within source (e.g. "memory", "user"). */
+    target?: string;
+    /** For local source, file path relative to agent home. */
+    path?: string;
+}
+export interface MemoryReadResult {
+    content: string;
+    source: string;
+    target?: string;
+    entryCount: number;
+}
+export interface MemoryWriteParams {
+    source: "local" | "store";
+    target?: string;
+    content: string;
+    /** Write mode: "append" adds to existing, "replace" overwrites. */
+    mode?: "append" | "replace";
+}
+export interface MemoryWriteResult {
+    ok: boolean;
+    entryCount: number;
+    message: string;
+}
+export interface MemoryDreamParams {
+    turnId?: string;
+    sessionId: string;
+    config?: Record<string, unknown>;
+}
+export interface MemoryDreamResult {
+    accepted: boolean;
+    turnId: string;
+}
+export interface ToolsListParams {
+    /** Filter by category. */
+    category?: "builtin" | "mcp" | "plugin" | "all";
+    /** Include full parameter schemas (default false — names only). */
+    includeSchema?: boolean;
+}
+export interface ToolsListResult {
+    tools: Array<{
+        name: string;
+        description: string;
+        category: "builtin" | "mcp" | "plugin";
+        /** Whether this tool requires approval. */
+        requiresApproval?: boolean;
+        /** Parameter schema (if includeSchema=true). */
+        parameters?: Record<string, unknown>;
+    }>;
+}
+export interface ConfigGetParams {
+    keys?: string[];
+}
+export interface ConfigGetResult {
+    config: Record<string, unknown>;
+}
+export interface ConfigUpdateParams {
+    settings: Record<string, unknown>;
+}
+export interface ConfigUpdateResult {
+    ok: boolean;
+    applied: string[];
+    rejected?: Array<{
+        key: string;
+        reason: string;
+    }>;
+}
+export interface TodosListParams {
+    /** Filter by status. */
+    status?: "not-started" | "in-progress" | "completed" | "all";
+}
+export interface TodosListResult {
+    items: TodoItem[];
+    summary: {
+        total: number;
+        completed: number;
+        inProgress: number;
+        notStarted: number;
+    };
+}
+export interface AgentPingResult {
+    status: "ok";
+}
+export interface AgentAbortParams {
+    turnId?: string;
+}
+export interface AgentAbortResult {
+    aborted: boolean;
+}
+export interface ToolApprovalResponseParams {
+    approvalId: string;
+    decision: "allow-once" | "allow-session" | "allow-always" | "deny";
+    updatedInput?: Record<string, unknown>;
+    permissionUpdate?: {
+        pattern: string;
+        behavior: string;
+    };
+}
+export interface MemorySearchParams {
+    query: string;
+    /** Max results (default 10). */
+    limit?: number;
+    /** Filter by userId (defaults to current session user). */
+    userId?: string;
+}
+export interface MemorySearchResult {
+    results: Array<{
+        id: string;
+        text: string;
+        score: number;
+        source: string;
+        metadata?: Record<string, unknown>;
+    }>;
+}
+export interface MemoryDeleteParams {
+    /** Source: "local" only (QMemory delete via adapter). */
+    source: "local" | "qmemory";
+    /** For local: target ("memory" | "user"). */
+    target?: string;
+    /** For local: substring to match and remove. For qmemory: memory block ID. */
+    match: string;
+}
+export interface MemoryDeleteResult {
+    ok: boolean;
+    removedCount: number;
+    message: string;
+}
+export interface TasksListParams {
+    /** Filter by lifecycle state. */
+    lifecycle?: "running" | "completed" | "failed" | "cancelled" | "all";
+}
+export interface TasksListResult {
+    tasks: Array<{
+        taskId: string;
+        type: string;
+        lifecycle: string;
+        label?: string;
+    }>;
+}
+export interface TasksCancelParams {
+    taskId: string;
+}
+export interface TasksCancelResult {
+    ok: boolean;
+    message: string;
+}
+export interface RpcMethodMap {
+    "initialize": {
+        params: InitializeParams;
+        result: InitializeResult;
+    };
+    "thread.create": {
+        params: ThreadCreateParams;
+        result: ThreadCreateResult;
+    };
+    "thread.list": {
+        params: ThreadListParams;
+        result: ThreadListResult;
+    };
+    "thread.turn": {
+        params: ThreadTurnParams;
+        result: ThreadTurnResult;
+    };
+    "session.resume": {
+        params: SessionResumeParams;
+        result: SessionResumeResult;
+    };
+    "session.getInfo": {
+        params: SessionGetInfoParams;
+        result: SessionGetInfoResult;
+    };
+    "memory.list": {
+        params: MemoryListParams;
+        result: MemoryListResult;
+    };
+    "memory.read": {
+        params: MemoryReadParams;
+        result: MemoryReadResult;
+    };
+    "memory.write": {
+        params: MemoryWriteParams;
+        result: MemoryWriteResult;
+    };
+    "memory.search": {
+        params: MemorySearchParams;
+        result: MemorySearchResult;
+    };
+    "memory.delete": {
+        params: MemoryDeleteParams;
+        result: MemoryDeleteResult;
+    };
+    "memory.dream": {
+        params: MemoryDreamParams;
+        result: MemoryDreamResult;
+    };
+    "tools.list": {
+        params: ToolsListParams;
+        result: ToolsListResult;
+    };
+    "config.get": {
+        params: ConfigGetParams;
+        result: ConfigGetResult;
+    };
+    "config.update": {
+        params: ConfigUpdateParams;
+        result: ConfigUpdateResult;
+    };
+    "todos.list": {
+        params: TodosListParams;
+        result: TodosListResult;
+    };
+    "tasks.list": {
+        params: TasksListParams;
+        result: TasksListResult;
+    };
+    "tasks.cancel": {
+        params: TasksCancelParams;
+        result: TasksCancelResult;
+    };
+    "agent.ping": {
+        params: undefined;
+        result: AgentPingResult;
+    };
+    "agent.abort": {
+        params: AgentAbortParams;
+        result: AgentAbortResult;
+    };
+    "tool.approval.response": {
+        params: ToolApprovalResponseParams;
+        result: {
+            received: boolean;
+        };
+    };
+}
+/** All known RPC method names. */
+export type RpcMethod = keyof RpcMethodMap;
+/** All RPC method names as a runtime array (for capabilities declaration). */
+export declare const ALL_RPC_METHODS: RpcMethod[];