qlogicagent 0.5.3 → 1.0.0

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

@@ -1,113 +1,15 @@
-export { buildAssistantToolCallMessage, buildToolResultMessage, type FunctionToolDefinition, } from "./tool-schema.js";
-export { classifyError, getRetryStrategy, type ErrorCategory, type RetryStrategy, } from "./error-classification.js";
-export { composeStrategies, composeAsyncStrategies, SlidingWindowStrategy, SummarizeOldStrategy, ToolResultTrimStrategy, HeadTailProtectedStrategy, IncrementalCompactStrategy, CacheAwareCompressionStrategy, CompressionMetricsCollector, ContextEngineRegistry, MicroCompactStrategy, postCompactFileRecovery, type PostCompactRecoveryConfig, buildStructuredSummaryPrompt, computeAdaptiveBudget, isAsyncCompressionStrategy, selectCompressionTier, DEFAULT_ADAPTIVE_BUDGET_CONFIG, type AdaptiveBudgetConfig, type AsyncCompressionStrategy, type CacheAwareCompressionConfig, type CompressibleMessage, type CompressionEvent, type CompressionMetrics, type CompressionMetricsSnapshot, type CompressionResult, type CompressionStrategy, type CompressionTier, type ContextEngine, type HeadTailProtectionConfig, type IncrementalCompactConfig, type SummarizeFn, } from "./context-compression.js";
-export { snipCompactIfNeeded, type SnipResult, } from "./context-compression.js";
-export { applyCollapsesIfNeeded as applyContextCollapsesIfNeeded, recoverFromOverflow as recoverContextCollapseFromOverflow, createCollapseStore, type CollapseStore, type CollapseStage, } from "./context-collapse.js";
+export { buildAssistantToolCallMessage, buildToolResultMessage, type FunctionToolDefinition, } from "./tool-loop/tool-schema.js";
+export { classifyError, getRetryStrategy, type ErrorCategory, type RetryStrategy, } from "./error-handling/error-classification.js";
+export { composeStrategies, composeAsyncStrategies, SlidingWindowStrategy, SummarizeOldStrategy, ToolResultTrimStrategy, HeadTailProtectedStrategy, IncrementalCompactStrategy, CacheAwareCompressionStrategy, CompressionMetricsCollector, ContextEngineRegistry, MicroCompactStrategy, postCompactFileRecovery, type PostCompactRecoveryConfig, buildStructuredSummaryPrompt, computeAdaptiveBudget, isAsyncCompressionStrategy, selectCompressionTier, DEFAULT_ADAPTIVE_BUDGET_CONFIG, type AdaptiveBudgetConfig, type AsyncCompressionStrategy, type CacheAwareCompressionConfig, type CompressibleMessage, type CompressionEvent, type CompressionMetrics, type CompressionMetricsSnapshot, type CompressionResult, type CompressionStrategy, type CompressionTier, type ContextEngine, type HeadTailProtectionConfig, type IncrementalCompactConfig, type SummarizeFn, } from "./context/context-compression.js";
+export { snipCompactIfNeeded, type SnipResult, } from "./context/context-compression.js";
+export { applyCollapsesIfNeeded as applyContextCollapsesIfNeeded, recoverFromOverflow as recoverContextCollapseFromOverflow, createCollapseStore, type CollapseStore, type CollapseStage, } from "./context/context-collapse.js";
 export { buildSkillInstruction, type SkillCreateInstruction, type SkillImproveInstruction, type SkillInstruction, type SkillTurnResult, } from "./skill-improvement.js";
-export { buildSkillCandidateEffectivenessSummary, buildSkillCandidateEvidencePayload, buildSkillCandidateImprovementEvidenceBundle, buildSkillCandidateLatestReview, createDefaultSkillImprovementPolicy, normalizeSkillImprovementPolicy, type SkillCandidateImprovementEvidenceBundleContract, type SkillImprovementPolicyContract, } from "./skill-candidate.js";
-export declare const SIDECHAIN_TYPE_VALUES: readonly ["research", "planner", "plan-repair", "code-repair", "media-prep"];
-export type SidechainType = typeof SIDECHAIN_TYPE_VALUES[number];
-export type SidechainBudgetTier = "low" | "medium" | "high";
-export type SidechainMergePolicy = "summary-only" | "append-messages" | "replace-context" | "manual";
-export type SidechainToolAccessMode = "full" | "read-only" | "none";
-export interface SidechainTypePolicy {
-    type: SidechainType;
-    label: string;
-    description: string;
-    mergePolicy: SidechainMergePolicy;
-    budgetTier: SidechainBudgetTier;
-    budgetWeight: number;
-    preferFullContext: boolean;
-    preserveConversationHistory: boolean;
-    toolAccessMode: SidechainToolAccessMode;
-}
-export type SidechainToolAccessDecision = "allowed" | "denied";
-export type SidechainToolAccessInheritance = "inherit" | "shrink";
-export type SidechainToolAccessReason = "default-allow" | "always-deny" | "leaf-deny";
-export interface SidechainToolAccessRule {
-    toolName: string;
-    decision: SidechainToolAccessDecision;
-    inheritance: SidechainToolAccessInheritance;
-    reason: SidechainToolAccessReason;
-}
-export interface SidechainToolAccessPolicy {
-    deniedTools: string[];
-    canSpawnChildren: boolean;
-    defaultDecision: "allowed";
-    defaultInheritance: "inherit";
-    tools: SidechainToolAccessRule[];
-}
-export declare const SIDECHAIN_TOOL_DENY_ALWAYS: readonly ["gateway", "agents_list", "whatsapp_login", "session_status", "cron", "memory_query", "sessions_send"];
-export declare const SIDECHAIN_TOOL_DENY_LEAF: readonly ["sessions_list", "sessions_history", "sessions_spawn"];
-/** Tools that perform write/mutation operations — denied in read-only sidechain types. */
-export declare const SIDECHAIN_TOOL_DENY_WRITE: readonly ["file_edit", "create_file", "replace_string_in_file", "multi_replace_string_in_file", "create_directory", "run_in_terminal", "run_command", "delete_file", "rename_file", "move_file", "git_commit", "git_push", "manage_todo_list"];
-export declare function resolveSidechainToolAccessPolicy(params?: {
-    depth?: number;
-    maxDepth?: number;
-    role?: "leaf" | "orchestrator";
-    toolNames?: Iterable<string>;
-}): SidechainToolAccessPolicy;
-/**
- * Resolve tool access policy for a specific sidechain type.
- * Combines depth-based deny lists with type-specific access mode:
- * - "full": only depth-based denials apply
- * - "read-only": depth-based + all write/mutation tools denied
- * - "none": all tools denied
- */
-export declare function resolveSidechainToolAccessByType(params: {
-    type: SidechainType;
-    depth?: number;
-    maxDepth?: number;
-    role?: "leaf" | "orchestrator";
-    toolNames?: Iterable<string>;
-}): SidechainToolAccessPolicy;
-export interface ToolCallAccessFilterResult<T> {
-    allowed: T[];
-    denied: Array<{
-        toolCall: T;
-        reason: string;
-    }>;
-}
-/**
- * Filter tool_calls against a resolved access policy.
- * Returns allowed calls and denied calls with reasons.
- * T must have at least { id: string; function: { name: string } }.
- */
-export declare function filterToolCallsByAccessPolicy<T extends {
-    id: string;
-    function: {
-        name: string;
-    };
-}>(toolCalls: T[], policy: SidechainToolAccessPolicy): ToolCallAccessFilterResult<T>;
-export declare function listSidechainTypePolicies(): SidechainTypePolicy[];
-export declare function resolveSidechainTypePolicy(type: SidechainType): SidechainTypePolicy;
-export declare function resolveRepairSidechainType(params?: {
-    toolNames?: Iterable<string>;
-    preferCodeRepair?: boolean;
-    trigger?: string;
-}): Extract<SidechainType, "plan-repair" | "code-repair">;
-export declare function resolveSidechainMergePolicyByType(type: SidechainType, overrides?: {
-    forceManualReview?: boolean;
-    preferFullContext?: boolean;
-    preserveConversationHistory?: boolean;
-}): SidechainMergePolicy;
-export declare function resolveSidechainMergePolicy(params?: {
-    preferFullContext?: boolean;
-    forceManualReview?: boolean;
-    preserveConversationHistory?: boolean;
-}): SidechainMergePolicy;
-export { applyToolChoicePolicy, type ApplyToolChoicePolicyInput, type ApplyToolChoicePolicyResult, } from "./tool-choice-policy.js";
-export { repairOpenAiChatConversation, type ConversationRepairOptions, type OpenAiChatMessageLike, type OpenAiToolCall, } from "./conversation-repair.js";
-export { advanceToolLoopState, recoverToolLoopStateFromChatConversation, recoverToolLoopStateFromResponsesItems, settleToolLoopState, type RepairToolLoopStateResult, type ToolLoopRepairAction, type ToolLoopState, } from "./tool-loop-state.js";
-export { MEMORY_OBSERVATION_HOOK_VALUES, MEMORY_OBSERVATION_SOURCE_VALUES, MEMORY_WRITE_ACCESS_VALUES, type MemoryObservationHook, type MemoryObservationSource, type MemoryWriteAccess, type MemoryProviderLifecycleInvocation, } from "./memory-provider.js";
-export { isForegroundSource, isTransientCapacityError, computeRetryBackoff, isPersistentRetryEnabled, FallbackTriggeredError, type PersistentRetryConfig, } from "./retry-loop.js";
-export { computeLifecycleTransitions, DEFAULT_CURATOR_SCHEDULE_POLICY, INITIAL_CURATOR_STATE, selectReviewCandidates, shouldRunCurator, type CuratorAutoTransitionResult, type CuratorGateInput, type CuratorGateResult, type CuratorLifecycleTransition, type CuratorSchedulePolicy, type CuratorSkillLifecycleState, type CuratorSkillRecord, type CuratorState, } from "./curator-scheduler.js";
-export { buildConsolidationPrompt, buildCuratorRunSummary, detectPrefixClusters, parseConsolidationOutput, reconcileConsolidationPlan, type ConsolidationAction, type ConsolidationPlan, type ConsolidationSkillSummary, type CuratorRunReport, type PruningAction, type ReconciledConsolidationPlan, type SkillPrefixCluster, } from "./skill-consolidation.js";
-export { bigramSimilarity, computeSimilarity, decideSimilarityAction, DEFAULT_SKILL_SIMILARITY_POLICY, findSimilarSkills, stepCountProximity, toolSetJaccard, type SimilarityDecision, type SimilarityScore, type SimilarSkillMatch, type SkillSimilarityPolicy, type SkillSimilarityProfile, } from "./skill-similarity.js";
-export { aggregateTeamResults, allocateTokenBudgets, buildAgentTaskPrompt, inferAggregationPolicy, inferExecutionMode, mapRoleToSidechainType, resolveAgentToolAccess, resolveExecutionOrder, resolveTeamPlan, shouldCancelTeam, TEAM_MAX_AGENTS, TEAM_MAX_DEPTH, validateTeamPlan, type AgentRole, type TeamAgentResult, type TeamAgentSpec, type TeamAggregationPolicy, type TeamExecutionMode, type TeamLifecycleState, type TeamPlan, type TeamResult, } from "./team-orchestration.js";
-export { canForkAtDepth, buildForkedMessages, buildForkPlaceholderResults, FORK_PLACEHOLDER_RESULT, FORK_SENTINEL_TAG, generateForkChildAgentId, isInForkChild, MAX_FORK_DEPTH, MAX_SIDECHAIN_DB_DEPTH, resolveForkChildTools, type ForkChildConfig, type ForkChildMessage, type ForkContext, type ForkResult, } from "./fork-subagent.js";
-export { getBuiltInAgent, getBuiltInAgents, isBuiltInAgent, resolveAgentToolSet, type AgentDefinition, } from "./agent-registry.js";
-export { createTaskState, filterToolsByRole, type IsolationMode, type PermissionRole, type TaskType, type TaskLifecycle, type TaskState, type TaskStateBase, type LocalBashTaskState, type LocalAgentTaskState, type RemoteAgentTaskState, type InProcessTeammateTaskState, type DreamTaskState, type DreamTurn, type DreamPhase, } from "./task-types.js";
-export { calculateTokenWarningState, createTurnLoopGuardState, resolveApiErrorRecovery, resolveOutputTokenEscalation, shouldAbortTurn, type ApiErrorRecovery, type TokenWarningState, type TurnLoopGuardConfig, type TurnLoopGuardState, } from "./turn-loop-guard.js";
-export { buildPostCompactRestorationMessage, createReactiveCompactState, shouldAttemptReactiveCompact, type ReactiveCompactConfig, type ReactiveCompactState, } from "./reactive-compact.js";
-export { aggregateTeamToolResults, mapTeamRequestToForkConfigs, resolveTeamExecutionPlan, type TeamAgentRequest, type TeamAggregatedResult, type TeamExecutionBatch, type TeamExecutionPlan, type TeamToolRequest, } from "./team-tool-loop-wiring.js";
+export { applyToolChoicePolicy, type ApplyToolChoicePolicyInput, type ApplyToolChoicePolicyResult, } from "./tool-loop/tool-choice-policy.js";
+export { repairOpenAiChatConversation, type ConversationRepairOptions, type OpenAiChatMessageLike, type OpenAiToolCall, } from "./tool-loop/conversation-repair.js";
+export { advanceToolLoopState, recoverToolLoopStateFromChatConversation, recoverToolLoopStateFromResponsesItems, settleToolLoopState, type RepairToolLoopStateResult, type ToolLoopRepairAction, type ToolLoopState, } from "./tool-loop/tool-loop-state.js";
+export { isForegroundSource, isTransientCapacityError, computeRetryBackoff, isPersistentRetryEnabled, FallbackTriggeredError, type PersistentRetryConfig, } from "./error-handling/retry-loop.js";
+export { canForkAtDepth, buildForkedMessages, buildForkPlaceholderResults, FORK_PLACEHOLDER_RESULT, FORK_SENTINEL_TAG, generateForkChildAgentId, isInForkChild, MAX_FORK_DEPTH, resolveForkChildTools, type ForkChildConfig, type ForkChildMessage, type ForkContext, type ForkResult, } from "./subagent/fork-subagent.js";
+export { getBuiltInAgent, getBuiltInAgents, isBuiltInAgent, resolveAgentToolSet, type AgentDefinition, } from "./subagent/agent-registry.js";
+export { createTaskState, filterToolsByRole, type IsolationMode, type PermissionRole, type TaskType, type TaskLifecycle, type TaskState, type TaskStateBase, type LocalBashTaskState, type LocalAgentTaskState, type RemoteAgentTaskState, type InProcessTeammateTaskState, type DreamTaskState, type DreamTurn, type DreamPhase, } from "./subagent/task-types.js";
+export { calculateTokenWarningState, createTurnLoopGuardState, resolveApiErrorRecovery, resolveOutputTokenEscalation, shouldAbortTurn, type ApiErrorRecovery, type TokenWarningState, type TurnLoopGuardConfig, type TurnLoopGuardState, } from "./context/turn-loop-guard.js";
+export { buildPostCompactRestorationMessage, createReactiveCompactState, shouldAttemptReactiveCompact, type ReactiveCompactConfig, type ReactiveCompactState, } from "./context/reactive-compact.js";

package/dist/types/orchestration/skill-improvement.d.ts

@@ -10,8 +10,8 @@ export interface SkillTurnResult {
     distinctToolCount: number;
     /** Was a multi-step orchestration (≥2 rounds) used? */
     multiStep: boolean;
-    /** Did the turn involve a sidechain? */
-    hasSidechain: boolean;
+    /** Did the turn involve a sub-agent fork? */
+    hasSubAgent: boolean;
     /** Optional user feedback signal (positive/negative/none) */
     feedback?: "positive" | "negative" | null;
     /** Skill name if an existing skill was used */

package/dist/types/orchestration/{fork-subagent.d.ts → subagent/fork-subagent.d.ts}

@@ -13,10 +13,8 @@ import type { AgentDefinition } from "./agent-registry.js";
 export declare const FORK_SENTINEL_TAG = "<fork-child-context>";
 /** Placeholder text used for all tool_results in shared prefix (ensures byte-identical prefix). */
 export declare const FORK_PLACEHOLDER_RESULT = "Fork started \u2014 processing in background";
-/** Maximum fork depth for in-memory agents (more permissive than DB sidechain). */
+/** Maximum fork depth for in-memory agents (CC: MAX_FORK_DEPTH). */
 export declare const MAX_FORK_DEPTH = 4;
-/** Maximum fork depth for DB-backed sidechains (more conservative). */
-export declare const MAX_SIDECHAIN_DB_DEPTH = 2;
 export interface ForkContext {
     /** Parent's full message history (becomes shared prefix for cache). */
     parentMessages: unknown[];
@@ -67,7 +65,7 @@ export declare function isInForkChild(messages: unknown[]): boolean;
 /**
  * Check if fork depth allows spawning another child.
  */
-export declare function canForkAtDepth(currentDepth: number, mode?: "in-memory" | "db-sidechain"): boolean;
+export declare function canForkAtDepth(currentDepth: number): boolean;
 /**
  * Build forked messages that ensure byte-identical prefix across all fork children.
  *

package/dist/types/orchestration/{tool-schema.d.ts → 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[];