@yushaw/sanqian-ai-sdk 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,1393 @@
+import { z } from 'zod';
+
+/**
+ * Runtime Profile - separates provider, auth, billing, and history concerns.
+ */
+type RuntimeProviderKind = 'sanqian-sdk' | 'vercel-ai-sdk' | 'fake' | 'replay';
+type ExecutionTarget = 'local-sanqian' | 'local-byok';
+type AuthMode = 'none' | 'local-provider-key';
+type BillingMode = 'host-managed' | 'user-provider-billing';
+type HistoryLocation = 'local';
+interface RuntimeProfile {
+    providerKind: RuntimeProviderKind;
+    executionTarget: ExecutionTarget;
+    authMode: AuthMode;
+    billingMode: BillingMode;
+    historyLocation: HistoryLocation;
+}
+
+/**
+ * Runtime Stream Events - normalized event protocol for all providers.
+ */
+interface RuntimeToolCall {
+    id: string;
+    name: string;
+    arguments: string;
+}
+interface RuntimeInterrupt {
+    type: string;
+    payload: unknown;
+}
+interface RuntimeToolExecutionMetadata {
+    status?: 'pending' | 'running' | 'completed' | 'error' | 'cancelled' | string;
+    actionRequired?: string;
+    settingsTab?: string;
+    settingsSubTab?: string;
+    commandExitCode?: number;
+    durationMs?: number;
+    sandboxed?: boolean;
+    timedOut?: boolean;
+    truncated?: boolean;
+    stdoutPath?: string;
+    stderrPath?: string;
+    presentation?: string;
+}
+type RuntimeStreamEvent = {
+    type: 'start';
+    runId?: string;
+    conversationId?: string;
+} | {
+    type: 'text';
+    content: string;
+} | {
+    type: 'thinking';
+    content: string;
+} | {
+    type: 'tool_call';
+    toolCall: RuntimeToolCall;
+} | {
+    type: 'tool_args_chunk';
+    toolCallId: string;
+    toolName: string;
+    chunk: string;
+} | {
+    type: 'tool_args';
+    toolCallId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+} | ({
+    type: 'tool_result';
+    toolCallId: string;
+    result?: unknown;
+    success?: boolean;
+    error?: string;
+} & RuntimeToolExecutionMetadata) | {
+    type: 'interrupt';
+    runId?: string;
+    interrupt: RuntimeInterrupt;
+} | {
+    type: 'cancelled';
+    runId?: string;
+} | {
+    type: 'done';
+    conversationId: string;
+    title?: string;
+} | {
+    type: 'error';
+    error: string;
+    code?: string;
+};
+interface RuntimeUsage {
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+}
+
+/**
+ * Runtime Provider - the core abstraction that all providers implement.
+ */
+
+interface RuntimeProviderCapabilities {
+    streamingText: boolean;
+    reasoning: boolean;
+    toolCalling: boolean;
+    parallelToolCalls: boolean;
+    toolArgsStreaming: boolean;
+    abort: boolean;
+    hitl: boolean;
+    conversations: boolean;
+    sessionResources: boolean;
+    resourcePicker: boolean;
+    embeddings: boolean;
+    rerank: boolean;
+}
+type RuntimeConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'error';
+type RuntimeConnectionErrorCode = 'NOT_FOUND' | 'CONNECTION_FAILED' | 'WEBSOCKET_ERROR' | 'AUTH_ERROR' | 'TIMEOUT' | 'UNKNOWN' | (string & {});
+interface RuntimeConnectionSnapshot {
+    status: RuntimeConnectionStatus;
+    isConnected: boolean;
+    error?: string;
+    errorCode?: RuntimeConnectionErrorCode;
+    lastChangedAt: number;
+}
+interface RuntimeChatRequest {
+    agentId: string;
+    messages: RuntimeMessage[];
+    conversationId?: string | null;
+    providerInstanceId?: string;
+    operationId?: string;
+    tools?: RuntimeToolDefinition[];
+    contexts?: RuntimeContext[];
+    resources?: RuntimeResourceRef[];
+    sessionResources?: RuntimeResource[];
+    signal?: AbortSignal;
+}
+interface RuntimeChatResponse {
+    content: string;
+    conversationId?: string;
+    usage?: RuntimeUsage;
+    toolResults?: RuntimeToolExecutionResult[];
+}
+interface RuntimeChatStreamRequest {
+    agentId: string;
+    messages: RuntimeMessage[];
+    conversationId?: string | null;
+    providerInstanceId?: string;
+    operationId?: string;
+    tools?: RuntimeToolDefinition[];
+    contexts?: RuntimeContext[];
+    resources?: RuntimeResourceRef[];
+    sessionResources?: RuntimeResource[];
+    signal?: AbortSignal;
+}
+interface RuntimeMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+}
+interface RuntimeContext {
+    id: string;
+    content: string;
+}
+interface RuntimeResourceRef {
+    providerId: string;
+    resourceId: string;
+}
+interface RuntimeResource {
+    id: string;
+    title: string;
+    content: string;
+    summary?: string;
+}
+interface RuntimeToolDefinition {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+}
+interface RuntimeToolExecutionResult {
+    toolCallId: string;
+    result?: unknown;
+    success: boolean;
+    error?: string;
+}
+interface RuntimeProviderDescriptor {
+    id: string;
+    kind: RuntimeProviderKind;
+    displayName: string;
+    capabilities: RuntimeProviderCapabilities;
+}
+interface RuntimeProvider {
+    readonly id: string;
+    readonly kind: RuntimeProviderKind;
+    readonly displayName: string;
+    readonly capabilities: RuntimeProviderCapabilities;
+    ensureReady(): Promise<void>;
+    dispose?(): Promise<void>;
+    isConnected?(): boolean;
+    getConnectionSnapshot?(): RuntimeConnectionSnapshot;
+    onConnectionChange?(callback: (snapshot: RuntimeConnectionSnapshot) => void): () => void;
+    chat(input: RuntimeChatRequest): Promise<RuntimeChatResponse>;
+    chatStream(input: RuntimeChatStreamRequest): AsyncIterable<RuntimeStreamEvent>;
+    cancel?(runId: string): Promise<void>;
+    sendPermissionResponse?(input: RuntimePermissionResponse): Promise<void>;
+}
+interface RuntimePermissionResponse {
+    runId: string;
+    toolCallId: string;
+    decision: 'approve' | 'deny' | 'cancel';
+    reason?: string;
+    response?: RuntimeHitlResponse;
+}
+interface RuntimeHitlResponse {
+    approved?: boolean;
+    remember?: boolean;
+    answer?: string;
+    selected_indices?: number[];
+    cancelled?: boolean;
+    timed_out?: boolean;
+}
+
+/**
+ * Agent Registry - provider-neutral agent configuration.
+ */
+
+type RuntimeAgentId = 'assistant' | 'writing' | 'generator' | 'formatter';
+type AgentExecutionMode = 'chat' | 'task' | 'formatter' | 'summary';
+interface RuntimeAgentConfig {
+    id: RuntimeAgentId | string;
+    name: string;
+    description?: string;
+    systemPrompt: string;
+    tools: string[];
+    executionMode?: AgentExecutionMode;
+    capabilities?: Partial<RuntimeProviderCapabilities>;
+}
+interface AgentIdResolver {
+    toRuntimeAgentId(input: string): RuntimeAgentId | string;
+    toProviderAgentId(shortId: RuntimeAgentId | string): Promise<string>;
+    isProviderManagedId(input: string): boolean;
+}
+interface RuntimeAgentRegistry {
+    register(config: RuntimeAgentConfig): void;
+    get(id: RuntimeAgentId | string): RuntimeAgentConfig | undefined;
+    list(): RuntimeAgentConfig[];
+    getToolsForAgent(id: RuntimeAgentId | string): RuntimeToolDefinition[];
+}
+
+/**
+ * Tool Registry - provider-neutral tool registration and execution.
+ */
+
+type ToolCategory = 'read-only' | 'local-file-read' | 'local-file-write' | 'note-mutation' | 'notebook-mutation' | 'network' | 'dangerous';
+interface RuntimeToolMetadata {
+    category: ToolCategory;
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+}
+type RuntimeToolHandler = (args: Record<string, unknown>, context?: RuntimeToolExecutionContext) => Promise<unknown>;
+interface RuntimeToolExecutionContext {
+    toolCallId: string;
+    signal?: AbortSignal;
+}
+interface RuntimeToolExecutionInput {
+    toolCallId: string;
+    name: string;
+    args: Record<string, unknown>;
+    signal?: AbortSignal;
+}
+interface RuntimeToolRegistration {
+    definition: RuntimeToolDefinition;
+    handler: RuntimeToolHandler;
+    metadata: RuntimeToolMetadata;
+}
+interface RuntimeToolRegistry {
+    register(tool: RuntimeToolDefinition, handler: RuntimeToolHandler, metadata?: Partial<RuntimeToolMetadata>): void;
+    get(name: string): RuntimeToolRegistration | undefined;
+    list(): RuntimeToolRegistration[];
+    execute(input: RuntimeToolExecutionInput): Promise<RuntimeToolExecutionResult>;
+}
+/**
+ * Create a tool registry instance.
+ */
+declare function createToolRegistry(): RuntimeToolRegistry;
+
+/**
+ * Permission Policy - controls mutation tool execution with HITL support.
+ *
+ * The runtime evaluates permissions before executing mutation tools.
+ * When a tool requires approval, the runtime emits an 'interrupt' event
+ * and waits for the UI to respond via the pending permission table.
+ */
+
+type PermissionDecision = {
+    type: 'allow';
+} | {
+    type: 'deny';
+    reason: string;
+} | {
+    type: 'ask';
+    interrupt: RuntimeInterrupt;
+};
+interface PermissionPolicy {
+    evaluate(input: RuntimeToolExecutionInput): Promise<PermissionDecision>;
+}
+/**
+ * Pending permission request -- tracks an in-flight approval request.
+ */
+interface PendingPermission {
+    id: string;
+    toolCallId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+    createdAt: number;
+    resolve: (decision: 'approve' | 'deny' | 'cancel') => void;
+}
+/**
+ * Permission Gate -- manages pending permission requests and resolution.
+ *
+ * Used by VercelProvider to enforce local HITL before mutation tool execution.
+ * SanqianProvider delegates HITL to the Sanqian backend.
+ */
+interface PermissionGate {
+    /** Evaluate and potentially block tool execution. Returns the final decision. */
+    requestPermission(input: RuntimeToolExecutionInput): Promise<PermissionDecision>;
+    /** Resolve a pending permission request (called when UI responds). */
+    resolvePermission(id: string, decision: 'approve' | 'deny' | 'cancel'): void;
+    /** Cancel all pending permissions (called on provider switch or stream cancel). */
+    cancelAll(reason: string): void;
+    /** Get all pending permission requests. */
+    listPending(): PendingPermission[];
+    /** Listen for new permission requests (for emitting interrupt events). */
+    onPermissionRequest(listener: (pending: PendingPermission) => void): () => void;
+}
+/**
+ * Create a permission gate that uses a policy and tool registry
+ * to decide whether tools need approval.
+ */
+declare function createPermissionGate(policy: PermissionPolicy): PermissionGate;
+/**
+ * Default policy: allow all tools.
+ */
+declare function createDefaultPermissionPolicy(): PermissionPolicy;
+/**
+ * Category-based policy: allow read-only, ask for mutations.
+ */
+declare function createCategoryPermissionPolicy(registry: RuntimeToolRegistry): PermissionPolicy;
+/**
+ * Sanitize tool error messages -- strip file paths, SQL errors, and secrets.
+ */
+declare function redactToolError(error: string): string;
+
+/**
+ * Conversation Store - provider-scoped conversation persistence.
+ */
+
+interface ConversationInfo {
+    id: string;
+    providerId: string;
+    agentId?: string;
+    title: string;
+    createdAt: string;
+    updatedAt: string;
+    messageCount: number;
+}
+interface ConversationDetail extends ConversationInfo {
+    messages: RuntimeConversationMessage[];
+}
+interface RuntimeConversationMessage extends RuntimeMessage {
+    id: string;
+    timestamp: string;
+    toolCalls?: Array<{
+        id: string;
+        name: string;
+        args: Record<string, unknown>;
+        result?: unknown;
+    }>;
+}
+interface ConversationPatch {
+    title?: string;
+}
+interface ListConversationsInput {
+    providerId?: string;
+    agentId?: string;
+    limit?: number;
+    offset?: number;
+}
+interface ConversationPage {
+    conversations: ConversationInfo[];
+    total: number;
+}
+interface GetConversationInput {
+    messageLimit?: number;
+}
+interface CreateConversationInput {
+    providerId: string;
+    agentId?: string;
+    title?: string;
+}
+interface ConversationStore {
+    list(input: ListConversationsInput): Promise<ConversationPage>;
+    get(id: string, input?: GetConversationInput): Promise<ConversationDetail | null>;
+    create(input: CreateConversationInput): Promise<ConversationDetail>;
+    appendMessages(id: string, messages: RuntimeConversationMessage[]): Promise<void>;
+    update(id: string, patch: ConversationPatch): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+/**
+ * In-memory conversation store for playground/testing.
+ */
+declare function createMemoryConversationStore(): ConversationStore;
+
+/**
+ * Active Work Tracking - manages in-flight AI operations.
+ */
+type ActiveRuntimeWorkKind = 'chat-panel-stream' | 'inline-chat-stream' | 'agent-task' | 'summary-generation' | 'embedding-indexing' | 'rerank-request';
+interface ActiveRuntimeWork {
+    id: string;
+    kind: ActiveRuntimeWorkKind;
+    providerId: string;
+    startedAt: number;
+    abort: () => void;
+}
+interface ActiveWorkTracker {
+    register(work: ActiveRuntimeWork): void;
+    unregister(id: string): void;
+    list(): ActiveRuntimeWork[];
+    listByProvider(providerId: string): ActiveRuntimeWork[];
+    cancelAll(reason: string): Promise<void>;
+    cancelByProvider(providerId: string, reason: string): Promise<void>;
+}
+declare function createActiveWorkTracker(): ActiveWorkTracker;
+
+/**
+ * AI Feature Readiness - replaces Sanqian-only feature readiness.
+ */
+
+interface AiFeatureRuntimeState {
+    enabled: boolean;
+    activeProviderId: string | null;
+    activeProviderKind: RuntimeProviderKind | null;
+    ready: boolean;
+    capabilities: RuntimeProviderCapabilities;
+    source: 'runtime-provider' | 'sanqian-discovery' | 'manual-disabled';
+    lastError?: string;
+}
+declare const EMPTY_CAPABILITIES: RuntimeProviderCapabilities;
+declare function createDisabledState(): AiFeatureRuntimeState;
+
+/**
+ * Secret Store - host-supplied secret storage interface.
+ */
+interface SecretRef {
+    id: string;
+    providerInstanceId: string;
+}
+interface SecretDescriptor {
+    id: string;
+    providerInstanceId: string;
+    label?: string;
+    maskedValue?: string;
+    createdAt: number;
+    updatedAt: number;
+}
+interface StoreSecretInput {
+    providerInstanceId: string;
+    label?: string;
+    value: string;
+}
+interface RuntimeSecretStore {
+    put(input: StoreSecretInput): Promise<SecretRef>;
+    get(ref: SecretRef): Promise<string>;
+    delete(ref: SecretRef): Promise<void>;
+    describe(ref: SecretRef): Promise<SecretDescriptor>;
+}
+/**
+ * In-memory secret store for playground/testing. NOT for production.
+ */
+declare function createMemorySecretStore(): RuntimeSecretStore;
+
+/**
+ * Runtime Session Manager - provider switching state machine.
+ */
+
+interface ProviderInstanceConfig {
+    id: string;
+    provider: RuntimeProvider;
+}
+interface SwitchOptions {
+    ifBusy: 'cancel-active-work';
+    timeoutMs?: number;
+}
+interface SwitchResult {
+    success: boolean;
+    previousProviderId?: string;
+    newProviderId?: string;
+    error?: string;
+}
+interface ProviderChangedEvent {
+    previousProviderId: string | null;
+    newProviderId: string | null;
+    capabilities: RuntimeProviderCapabilities;
+}
+interface RuntimeSessionManager {
+    getActiveProvider(): RuntimeProvider | null;
+    getActiveDescriptor(): RuntimeProviderDescriptor | null;
+    getRuntimeState(): AiFeatureRuntimeState;
+    switchProvider(config: ProviderInstanceConfig, options?: SwitchOptions): Promise<SwitchResult>;
+    cancelAll(reason: string): Promise<void>;
+    onProviderChanged(listener: (event: ProviderChangedEvent) => void): () => void;
+}
+declare function createSessionManager(workTracker: ActiveWorkTracker): RuntimeSessionManager;
+
+/**
+ * Task Pipeline - two-step agent task flow (content agent -> formatter agent).
+ */
+
+interface RuntimeTaskPipelineInput {
+    taskId: string;
+    contentAgentId: string;
+    contentMessages: RuntimeMessage[];
+    formatterConfig: RuntimeAgentConfig;
+    outputTools: RuntimeToolDefinition[];
+    outputContext: unknown;
+    signal?: AbortSignal;
+    outputFormat?: 'auto' | 'paragraph' | 'list' | 'table' | 'code' | 'quote';
+}
+interface RuntimeTaskPipeline {
+    executeWithFormatter(input: RuntimeTaskPipelineInput): AsyncIterable<RuntimeStreamEvent>;
+}
+/**
+ * Create a task pipeline that uses a RuntimeProvider for both content and formatter steps.
+ *
+ * The pipeline:
+ * 1. Runs the content agent to generate raw text
+ * 2. Runs the formatter agent with output tools to structure the result
+ *
+ * Cancellation via AbortSignal stops both steps.
+ */
+declare function createTaskPipeline(getProvider: () => RuntimeProvider | null): RuntimeTaskPipeline;
+
+/**
+ * Embedding and Rerank Provider contracts.
+ *
+ * Notes owns the vector DB, chunks, indexing queue, and stale-vector cleanup.
+ * The runtime owns provider contracts, readiness, and model-change signals.
+ *
+ * Key invariant: chat provider switching must NOT silently change
+ * the embedding provider or mutate the vector index.
+ */
+interface EmbeddingProviderConfig {
+    id: string;
+    model: string;
+    dimensions: number;
+    apiUrl?: string;
+    apiKey?: string;
+}
+interface EmbeddingProvider {
+    readonly id: string;
+    readonly model: string;
+    readonly dimensions: number;
+    ensureReady(): Promise<void>;
+    dispose?(): Promise<void>;
+    /** Embed multiple texts in a single batch. */
+    embedMany(texts: string[], options?: {
+        signal?: AbortSignal;
+    }): Promise<number[][]>;
+    /** Embed a single text. */
+    embed(text: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<number[]>;
+    /** Test the embedding API connection. */
+    test?(): Promise<{
+        success: boolean;
+        dimensions?: number;
+        error?: string;
+    }>;
+}
+interface RerankInput {
+    query: string;
+    documents: Array<{
+        id: string;
+        text: string;
+    }>;
+    topN?: number;
+}
+interface RerankResultItem {
+    id: string;
+    score: number;
+    index: number;
+}
+interface RerankResult {
+    results: RerankResultItem[];
+}
+interface RerankProvider {
+    readonly id: string;
+    readonly model: string;
+    ensureReady(): Promise<void>;
+    dispose?(): Promise<void>;
+    rerank(input: RerankInput, options?: {
+        signal?: AbortSignal;
+    }): Promise<RerankResult>;
+    /** Test the rerank API connection. */
+    test?(): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+}
+/**
+ * Model change event -- emitted when embedding model/dimensions change.
+ * Notes should pause indexing, mark vectors stale, and schedule rebuild.
+ */
+interface EmbeddingModelChangeEvent {
+    previousModel: string | null;
+    previousDimensions: number | null;
+    newModel: string;
+    newDimensions: number;
+}
+/**
+ * Embedding session -- manages active embedding/rerank providers
+ * separately from the chat provider.
+ */
+interface EmbeddingSession {
+    getEmbeddingProvider(): EmbeddingProvider | null;
+    getRerankProvider(): RerankProvider | null;
+    setEmbeddingProvider(provider: EmbeddingProvider): Promise<EmbeddingModelChangeEvent | null>;
+    setRerankProvider(provider: RerankProvider): Promise<void>;
+    clearEmbeddingProvider(): Promise<EmbeddingModelChangeEvent | null>;
+    clearRerankProvider(): Promise<void>;
+    onModelChange(listener: (event: EmbeddingModelChangeEvent) => void): () => void;
+}
+declare function createEmbeddingSession(): EmbeddingSession;
+
+/**
+ * ChatRuntimeBridge - the interface sanqian-chat ChatPanel consumes.
+ *
+ * Replaces CommonChatSdk + StreamHandlerSdk at the main-process IPC layer.
+ * The renderer ChatAdapter remains stable; only the IPC implementation
+ * routes through this bridge.
+ */
+
+interface ResourceProviderInfo {
+    id: string;
+    name: string;
+    description: string;
+    appName: string;
+    hasGetList?: boolean;
+    hasGetCurrent?: boolean;
+}
+interface ResourceListRequest {
+    providerId: string;
+    query?: string;
+    offset?: number;
+    limit?: number;
+}
+interface ResourceListPage {
+    items: Array<{
+        id: string;
+        title: string;
+        summary?: string;
+        [key: string]: unknown;
+    }>;
+    hasMore?: boolean;
+}
+interface BridgeSessionResource {
+    id: string;
+    title: string;
+    content: string;
+    summary?: string;
+}
+interface RuntimeSessionResourceEvent {
+    type: 'resource_pushed' | 'resource_removed' | 'resources_cleared';
+    resource?: BridgeSessionResource;
+    resourceId?: string;
+    appName?: string;
+}
+interface ChatRuntimeBridge {
+    ensureReady(): Promise<void>;
+    isConnected(): boolean;
+    getRuntimeState(): AiFeatureRuntimeState;
+    getCapabilities(): RuntimeProviderCapabilities;
+    chatStream(input: RuntimeChatStreamRequest): AsyncIterable<RuntimeStreamEvent>;
+    cancelStream?(input: {
+        streamId?: string;
+        runId?: string;
+    }): Promise<void>;
+    sendPermissionResponse?(input: RuntimePermissionResponse): Promise<void>;
+    listConversations(input: ListConversationsInput): Promise<ConversationPage>;
+    getConversation(id: string, input?: GetConversationInput): Promise<ConversationDetail | null>;
+    deleteConversation(id: string): Promise<void>;
+    listResourceProviders?(): Promise<ResourceProviderInfo[]>;
+    getResourceList?(input: ResourceListRequest): Promise<ResourceListPage>;
+    getSessionResources?(): BridgeSessionResource[];
+    fetchSessionResources?(agentId?: string): Promise<BridgeSessionResource[]>;
+    removeSessionResource?(id: string): Promise<void>;
+    onSessionResourceEvent?(listener: (event: RuntimeSessionResourceEvent) => void): () => void;
+}
+/**
+ * Resolve AI feature visibility from runtime state.
+ *
+ * showAIFeatures=auto means:
+ * - show if runtime provider is configured and ready, OR
+ * - show if Sanqian is installed and usable
+ */
+declare function resolveAiFeaturesFromRuntime(preference: 'auto' | 'enabled' | 'disabled', runtimeState: AiFeatureRuntimeState, sanqianInstalled: boolean): boolean;
+
+/**
+ * ChatRuntimeBridge implementation -- connects RuntimeSessionManager
+ * to the ChatRuntimeBridge interface that sanqian-chat ChatPanel consumes.
+ *
+ * Manages:
+ * - Stream ID -> AbortController mapping (replaces Notes' activeStreams map)
+ * - Stream ID -> runId mapping (for HITL routing)
+ * - Capability-gated resource/session methods
+ * - Conversation routing through ConversationStore
+ */
+
+interface ActiveStream {
+    streamId: string;
+    runId: string | null;
+    abortController: AbortController;
+    cancelled: boolean;
+}
+interface ChatRuntimeBridgeConfig {
+    sessionManager: RuntimeSessionManager;
+    conversationStore: ConversationStore;
+    permissionGate?: PermissionGate;
+}
+declare function createChatRuntimeBridge(config: ChatRuntimeBridgeConfig): ChatRuntimeBridge & {
+    /** Visible for testing: active stream tracking */
+    getActiveStreams(): Map<string, ActiveStream>;
+};
+
+/**
+ * Output Operations Queue - manages formatter tool output operations.
+ *
+ * Mirrors Notes' editor-agent.ts: initTaskOutput -> queueOp -> commitTaskOutput.
+ * The pipeline initializes a pending ops queue per task, formatter tools
+ * append operations, and on completion the queue is committed (sent to editor).
+ */
+type OutputOperationType = 'paragraph' | 'list' | 'table' | 'html' | 'heading' | 'codeBlock' | 'blockquote' | 'noteRef';
+interface OutputOperation {
+    type: OutputOperationType;
+    content: unknown;
+}
+interface EditorOutputContext {
+    targetBlockId: string;
+    blockIds?: string[];
+    pageId: string;
+    notebookId: string | null;
+    processMode: 'append' | 'replace';
+    outputBlockId: string | null;
+}
+interface PendingOutputOps {
+    context: EditorOutputContext;
+    operations: OutputOperation[];
+}
+interface InsertOutputData {
+    taskId: string;
+    context: EditorOutputContext;
+    operations: OutputOperation[];
+}
+/**
+ * Validate output operation content structure.
+ * Returns error message if invalid, null if valid.
+ */
+declare function validateOutputContent(type: OutputOperationType, content: unknown): string | null;
+/**
+ * Output Operations Manager - manages pending operations per task.
+ *
+ * Lifecycle:
+ * 1. initTaskOutput(taskId, context) -- create pending queue
+ * 2. queueOp(taskId, type, content) -- formatter tools call this
+ * 3. commitTaskOutput(taskId) -- flush to editor
+ * 4. clearTaskOutput(taskId) -- discard on cancel/error
+ */
+interface OutputOperationsManager {
+    initTaskOutput(taskId: string, context: EditorOutputContext): void;
+    queueOp(taskId: string, type: OutputOperationType, content: unknown): {
+        success: boolean;
+        error?: string;
+    };
+    getTaskOutput(taskId: string): PendingOutputOps | null;
+    commitTaskOutput(taskId: string): InsertOutputData | null;
+    clearTaskOutput(taskId: string): void;
+}
+declare function createOutputOperationsManager(): OutputOperationsManager;
+
+interface SdkToolDefinition {
+    name: string;
+    description: string;
+    parameters?: Record<string, unknown>;
+    handler?: (args: Record<string, unknown>) => Promise<unknown>;
+}
+interface SdkContextProvider {
+    id: string;
+    name: string;
+    description: string;
+    getCurrent?: () => Promise<{
+        content: string;
+    } | null>;
+    getList?: (options?: {
+        query?: string;
+        offset?: number;
+        limit?: number;
+    }) => Promise<{
+        items: Array<{
+            id: string;
+            title: string;
+            summary?: string;
+            [key: string]: unknown;
+        }>;
+        hasMore?: boolean;
+    }>;
+    getById?: (id: string) => Promise<{
+        id: string;
+        content: string;
+        title?: string;
+        [key: string]: unknown;
+    } | null>;
+}
+interface SdkAgentConfig {
+    agent_id: string;
+    name: string;
+    description?: string;
+    system_prompt?: string;
+    tools?: string[];
+    skills?: string[];
+    attached_contexts?: string[];
+}
+interface SdkChatMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+}
+interface SdkChatResponse {
+    message: {
+        content: string;
+        role: string;
+    };
+    conversationId: string;
+    title?: string;
+    usage?: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+        total_tokens?: number;
+    };
+}
+interface SdkChatStreamEvent {
+    type: 'start' | 'text' | 'thinking' | 'tool_call' | 'tool_args_chunk' | 'tool_args' | 'tool_result' | 'done' | 'error' | 'interrupt' | 'cancelled';
+    content?: string;
+    tool_call?: {
+        id: string;
+        function: {
+            name: string;
+            arguments: string;
+        };
+    };
+    tool_call_id?: string;
+    tool_name?: string;
+    chunk?: string;
+    args?: Record<string, unknown>;
+    result?: unknown;
+    success?: boolean;
+    error?: string;
+    status?: string;
+    conversationId?: string;
+    title?: string;
+    run_id?: string;
+    interrupt_type?: string;
+    interrupt_payload?: unknown;
+    action_required?: string;
+    settings_tab?: string;
+    settings_sub_tab?: string;
+    command_exit_code?: number;
+    duration_ms?: number;
+    sandboxed?: boolean;
+    timed_out?: boolean;
+    truncated?: boolean;
+    stdout_path?: string;
+    stderr_path?: string;
+    presentation?: string;
+}
+interface SdkConversationInfo {
+    conversation_id: string;
+    agent_id: string;
+    title?: string;
+    message_count: number;
+    created_at?: string;
+    updated_at?: string;
+}
+interface SdkConversationDetail extends SdkConversationInfo {
+    messages?: Array<{
+        id: string;
+        role: string;
+        content: string;
+        tool_calls?: unknown;
+        tool_call_id?: string | null;
+        thinking?: string | null;
+        created_at?: string;
+        message_id?: number;
+    }>;
+}
+interface SdkHitlResponse {
+    approved?: boolean;
+    remember?: boolean;
+    answer?: string;
+    selected_indices?: number[];
+    cancelled?: boolean;
+    timed_out?: boolean;
+}
+interface SdkSessionResource {
+    id?: string;
+    title: string;
+    content: string;
+    summary?: string;
+}
+interface SdkStoredSessionResource extends SdkSessionResource {
+    fullId: string;
+    appName: string;
+    pushedAt: string;
+}
+interface SdkEmbeddingConfig {
+    available: boolean;
+    apiUrl?: string;
+    apiKey?: string;
+    modelName?: string;
+    dimensions?: number;
+}
+interface SdkRerankConfig {
+    available: boolean;
+    apiUrl?: string;
+    apiKey?: string;
+    modelName?: string;
+}
+type SdkEventName = 'connected' | 'disconnected' | 'registered' | 'error' | 'tool_call' | 'resourcePushed' | 'resourceRemoved';
+interface SanqianSdkPort {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    ensureReady(): Promise<void>;
+    isConnected(): boolean;
+    acquireReconnect(): void;
+    releaseReconnect(): void;
+    on(event: SdkEventName, handler: (...args: unknown[]) => void): void;
+    off(event: SdkEventName, handler: (...args: unknown[]) => void): void;
+    removeAllListeners(): void;
+    createAgent(config: SdkAgentConfig): Promise<{
+        agent_id: string;
+    }>;
+    chat(agentId: string, messages: SdkChatMessage[], options?: {
+        conversationId?: string;
+        persistHistory?: boolean;
+    }): Promise<SdkChatResponse>;
+    chatStream(agentId: string, messages: SdkChatMessage[], options?: {
+        conversationId?: string;
+        persistHistory?: boolean;
+        attachedContexts?: string[];
+        attachedResources?: string[];
+        sessionResources?: string[];
+        signal?: AbortSignal;
+    }): AsyncGenerator<SdkChatStreamEvent>;
+    cancelRun(runId: string): void;
+    sendHitlResponse(runId: string, response: SdkHitlResponse): void;
+    listConversations(options: {
+        agentId?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        conversations: SdkConversationInfo[];
+        total: number;
+    }>;
+    getConversation(id: string, options?: {
+        messageLimit?: number;
+    }): Promise<SdkConversationDetail>;
+    deleteConversation(id: string): Promise<void>;
+    getSessionResources(): SdkStoredSessionResource[];
+    pushResource(resource: SdkSessionResource): Promise<SdkStoredSessionResource>;
+    removeResource(resourceId: string): Promise<void>;
+    fetchSessionResources?(agentId?: string): Promise<SdkStoredSessionResource[]>;
+    getEmbeddingConfig(): Promise<SdkEmbeddingConfig>;
+    getRerankConfig(): Promise<SdkRerankConfig>;
+}
+
+/**
+ * SanqianProvider - RuntimeProvider backed by @yushaw/sanqian-sdk.
+ *
+ * Absorbs the responsibilities of SanqianAppClient:
+ * - App registration with tools and contexts
+ * - Private agent sync (assistant, writing, generator, formatter)
+ * - Chat streaming with AbortSignal forwarding
+ * - Event conversion to RuntimeStreamEvent
+ * - Conversation proxy
+ * - HITL proxy
+ * - Session resource proxy
+ * - Embedding/rerank config fetch
+ */
+
+interface SanqianProviderConfig {
+    /** Provider instance ID */
+    id?: string;
+    /** Display name */
+    displayName?: string;
+    /** App name for Sanqian registration */
+    appName: string;
+    /** App version */
+    appVersion: string;
+    /** SDK port (inject for testing, or create from real SDK) */
+    sdk: SanqianSdkPort;
+    /** Agent configs to register */
+    agents?: RuntimeAgentConfig[];
+    /** Tool definitions to register with Sanqian */
+    tools?: SdkToolDefinition[];
+    /** Context providers to register with Sanqian */
+    contexts?: SdkContextProvider[];
+}
+declare class SanqianProvider implements RuntimeProvider {
+    readonly id: string;
+    readonly kind: RuntimeProviderKind;
+    readonly displayName: string;
+    readonly capabilities: RuntimeProviderCapabilities;
+    private sdk;
+    private appName;
+    private agentConfigs;
+    private agentIdResolver;
+    private disposed;
+    private ready;
+    private connectionStatus;
+    private connectionError;
+    private connectionErrorCode;
+    private connectionLastChangedAt;
+    private readonly connectionListeners;
+    private readonly handleSdkConnected;
+    private readonly handleSdkDisconnected;
+    private readonly handleSdkError;
+    constructor(config: SanqianProviderConfig);
+    ensureReady(): Promise<void>;
+    dispose(): Promise<void>;
+    isDisposed(): boolean;
+    private syncAgents;
+    /**
+     * Get the registered Sanqian agent ID for a runtime agent ID.
+     */
+    resolveAgentId(shortId: string): Promise<string>;
+    /**
+     * Get the runtime agent ID for a registered Sanqian agent ID.
+     */
+    normalizeAgentId(registeredId: string): string;
+    chat(input: RuntimeChatRequest): Promise<RuntimeChatResponse>;
+    chatStream(input: RuntimeChatStreamRequest): AsyncIterable<RuntimeStreamEvent>;
+    cancel(runId: string): Promise<void>;
+    sendPermissionResponse(input: RuntimePermissionResponse): Promise<void>;
+    listConversations(options?: {
+        agentId?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        conversations: SdkConversationInfo[];
+        total: number;
+    }>;
+    getConversation(id: string, options?: {
+        messageLimit?: number;
+    }): Promise<SdkConversationDetail>;
+    deleteConversation(id: string): Promise<void>;
+    getSessionResources(): SdkStoredSessionResource[];
+    pushResource(resource: SdkSessionResource): Promise<SdkStoredSessionResource>;
+    removeResource(resourceId: string): Promise<void>;
+    getEmbeddingConfig(): Promise<SdkEmbeddingConfig | null>;
+    getRerankConfig(): Promise<SdkRerankConfig | null>;
+    acquireReconnect(): void;
+    releaseReconnect(): void;
+    isConnected(): boolean;
+    getConnectionSnapshot(): RuntimeConnectionSnapshot;
+    onConnectionChange(callback: (snapshot: RuntimeConnectionSnapshot) => void): () => void;
+    on(event: string, handler: (...args: unknown[]) => void): void;
+    off(event: string, handler: (...args: unknown[]) => void): void;
+    listAvailableAgents(): Promise<unknown[]>;
+    private ensureNotDisposed;
+    private registerConnectionEvents;
+    private unregisterConnectionEvents;
+    private updateConnection;
+}
+
+/**
+ * Agent ID Resolver - maps short runtime agent IDs to Sanqian registered IDs.
+ *
+ * Sanqian registers agents with format "appName:agentId" (e.g. "sanqian-notes:assistant").
+ * The runtime uses short IDs ("assistant", "writing", etc.).
+ * This resolver bridges the two.
+ */
+
+declare function createSanqianAgentIdResolver(appName: string): AgentIdResolver & {
+    setMapping(shortId: string, registeredId: string): void;
+    clearMappings(): void;
+};
+
+/**
+ * Convert Sanqian SDK stream events to RuntimeStreamEvent.
+ */
+
+declare function convertSdkStreamEvent(event: SdkChatStreamEvent): RuntimeStreamEvent | null;
+
+/**
+ * MockSanqianSdk - deterministic SDK mock for testing SanqianProvider.
+ *
+ * Simulates Sanqian backend behavior without network or real backend.
+ */
+
+interface MockScenario {
+    agentId?: string;
+    chatResponse?: string;
+    streamEvents?: SdkChatStreamEvent[];
+    error?: string;
+}
+interface MockSdkConfig {
+    appName?: string;
+    connected?: boolean;
+    readinessError?: string;
+    scenarios?: MockScenario[];
+    embeddingConfig?: SdkEmbeddingConfig;
+    rerankConfig?: SdkRerankConfig;
+}
+declare class MockSanqianSdk implements SanqianSdkPort {
+    private appName;
+    private connected;
+    private readinessError;
+    private scenarios;
+    private agents;
+    private conversations;
+    private sessionResources;
+    private listeners;
+    private embeddingConfig;
+    private rerankConfig;
+    readonly connectCalls: number[];
+    readonly disconnectCalls: number[];
+    readonly ensureReadyCalls: number[];
+    readonly createAgentCalls: SdkAgentConfig[];
+    readonly chatCalls: Array<{
+        agentId: string;
+        messages: SdkChatMessage[];
+        options?: unknown;
+    }>;
+    readonly chatStreamCalls: Array<{
+        agentId: string;
+        messages: SdkChatMessage[];
+        options?: unknown;
+    }>;
+    readonly cancelRunCalls: string[];
+    readonly hitlResponseCalls: Array<{
+        runId: string;
+        response: SdkHitlResponse;
+    }>;
+    constructor(config?: MockSdkConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    ensureReady(): Promise<void>;
+    isConnected(): boolean;
+    acquireReconnect(): void;
+    releaseReconnect(): void;
+    on(event: SdkEventName, handler: (...args: unknown[]) => void): void;
+    off(event: SdkEventName, handler: (...args: unknown[]) => void): void;
+    removeAllListeners(): void;
+    private emit;
+    createAgent(config: SdkAgentConfig): Promise<{
+        agent_id: string;
+    }>;
+    chat(agentId: string, messages: SdkChatMessage[], options?: {
+        conversationId?: string;
+        persistHistory?: boolean;
+    }): Promise<SdkChatResponse>;
+    chatStream(agentId: string, messages: SdkChatMessage[], options?: {
+        conversationId?: string;
+        signal?: AbortSignal;
+        attachedResources?: string[];
+        sessionResources?: string[];
+    }): AsyncGenerator<SdkChatStreamEvent>;
+    cancelRun(runId: string): void;
+    sendHitlResponse(runId: string, response: SdkHitlResponse): void;
+    listConversations(options: {
+        agentId?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        conversations: SdkConversationInfo[];
+        total: number;
+    }>;
+    getConversation(id: string): Promise<SdkConversationDetail>;
+    deleteConversation(id: string): Promise<void>;
+    /** Test helper: seed a conversation */
+    seedConversation(detail: SdkConversationDetail): void;
+    getSessionResources(): SdkStoredSessionResource[];
+    pushResource(resource: SdkSessionResource): Promise<SdkStoredSessionResource>;
+    removeResource(resourceId: string): Promise<void>;
+    fetchSessionResources(): Promise<SdkStoredSessionResource[]>;
+    getEmbeddingConfig(): Promise<SdkEmbeddingConfig>;
+    getRerankConfig(): Promise<SdkRerankConfig>;
+    private findScenario;
+    /** Simulate readiness failure for testing rollback */
+    setReadinessError(error: string | null): void;
+    /** Force connection state for testing */
+    setConnected(connected: boolean): void;
+}
+
+/**
+ * Sanqian Embedding Provider - uses embedding config from Sanqian backend.
+ *
+ * Calls OpenAI-compatible embedding API with config fetched from Sanqian SDK.
+ * This is the same code path Notes currently uses in embedding/api.ts.
+ */
+
+interface SanqianEmbeddingConfig {
+    apiUrl: string;
+    apiKey: string;
+    modelName: string;
+    dimensions: number;
+    /** 'openai' | 'zhipu' | 'local' */
+    apiType?: string;
+}
+declare class SanqianEmbeddingProvider implements EmbeddingProvider {
+    readonly id: string;
+    readonly model: string;
+    readonly dimensions: number;
+    private config;
+    private disposed;
+    constructor(config: SanqianEmbeddingConfig, id?: string);
+    ensureReady(): Promise<void>;
+    dispose(): Promise<void>;
+    embedMany(texts: string[], options?: {
+        signal?: AbortSignal;
+    }): Promise<number[][]>;
+    embed(text: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<number[]>;
+    test(): Promise<{
+        success: boolean;
+        dimensions?: number;
+        error?: string;
+    }>;
+    private callApi;
+    private callOllama;
+}
+
+/**
+ * Sanqian Rerank Provider - calls rerank API with config from Sanqian backend.
+ *
+ * Supports Zhipu BigModel, Cohere, and other OpenAI-compatible rerank APIs.
+ */
+
+interface SanqianRerankConfig {
+    apiUrl: string;
+    apiKey: string;
+    modelName: string;
+}
+declare class SanqianRerankProvider implements RerankProvider {
+    readonly id: string;
+    readonly model: string;
+    private config;
+    private disposed;
+    constructor(config: SanqianRerankConfig, id?: string);
+    ensureReady(): Promise<void>;
+    dispose(): Promise<void>;
+    rerank(input: RerankInput, options?: {
+        signal?: AbortSignal;
+    }): Promise<RerankResult>;
+    test(): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+}
+
+/**
+ * VercelProvider - RuntimeProvider backed by Vercel AI SDK.
+ *
+ * Uses @ai-sdk/openai-compatible for DeepSeek/OpenAI-compatible endpoints.
+ * Supports local BYOK mode where users provide their own API keys.
+ *
+ * Key differences from SanqianProvider:
+ * - Tool execution happens locally (not on a remote backend)
+ * - Conversations are stored locally via ConversationStore
+ * - HITL/permissions are enforced locally before tool execution
+ * - No session resources or resource picker (capability-disabled)
+ * - Formatter pipeline runs as two local streamText() calls
+ */
+
+interface VercelProviderConfig {
+    id?: string;
+    displayName?: string;
+    /** API key for the provider */
+    apiKey: string;
+    /** Base URL (e.g. https://api.deepseek.com) */
+    baseURL: string;
+    /** Model name (e.g. deepseek-chat) */
+    model: string;
+    /** Provider name for display */
+    providerName?: string;
+    /** Agent configs (system prompts, tool lists) */
+    agents?: RuntimeAgentConfig[];
+    /** Tool registry for local tool execution */
+    toolRegistry?: RuntimeToolRegistry;
+    /** Max tool call steps per request */
+    maxSteps?: number;
+}
+declare class VercelProvider implements RuntimeProvider {
+    readonly id: string;
+    readonly kind: RuntimeProviderKind;
+    readonly displayName: string;
+    readonly capabilities: RuntimeProviderCapabilities;
+    private apiKey;
+    private baseURL;
+    private modelName;
+    private providerName;
+    private agentConfigs;
+    private toolRegistry;
+    private maxSteps;
+    private disposed;
+    private ready;
+    constructor(config: VercelProviderConfig);
+    ensureReady(): Promise<void>;
+    dispose(): Promise<void>;
+    isDisposed(): boolean;
+    chat(input: RuntimeChatRequest): Promise<RuntimeChatResponse>;
+    chatStream(input: RuntimeChatStreamRequest): AsyncIterable<RuntimeStreamEvent>;
+    cancel(_runId: string): Promise<void>;
+    sendPermissionResponse(_input: RuntimePermissionResponse): Promise<void>;
+    private createProvider;
+    private buildMessages;
+    private resolveTools;
+    private redactSecrets;
+    private ensureNotDisposed;
+}
+
+/**
+ * Convert runtime tool definitions to Vercel AI SDK tools.
+ *
+ * Bypasses the `tool()` helper because AI SDK v5/v6 has a bug where
+ * `tool()` returns `{ parameters }` but `prepareToolsAndToolChoice`
+ * reads `inputSchema` (vercel/ai#7924, PR #15249 -- canary only).
+ *
+ * Instead, we construct tool objects with `inputSchema` directly,
+ * using zod v3 schemas for correct JSON Schema serialization.
+ */
+
+interface VercelToolLike {
+    type: 'function';
+    description: string;
+    inputSchema: z.ZodTypeAny;
+    execute?: (args: Record<string, unknown>) => Promise<unknown>;
+}
+/**
+ * Convert runtime tool definitions to Vercel AI SDK-compatible tool objects.
+ *
+ * Returns objects with `inputSchema` (not `parameters`) to match what
+ * `prepareToolsAndToolChoice` expects internally.
+ */
+declare function convertToolsForVercel(tools: RuntimeToolDefinition[], registry: RuntimeToolRegistry | null, options?: {
+    signal?: AbortSignal;
+}): Record<string, VercelToolLike>;
+
+/**
+ * Vercel Embedding Provider - uses Vercel AI SDK's embedMany for BYOK mode.
+ *
+ * Wraps @ai-sdk/openai-compatible to call any OpenAI-compatible embedding API
+ * using the host's own API key.
+ */
+
+interface VercelEmbeddingConfig {
+    apiKey: string;
+    baseURL: string;
+    model: string;
+    dimensions: number;
+    providerName?: string;
+}
+declare class VercelEmbeddingProvider implements EmbeddingProvider {
+    readonly id: string;
+    readonly model: string;
+    readonly dimensions: number;
+    private config;
+    private disposed;
+    constructor(config: VercelEmbeddingConfig, id?: string);
+    ensureReady(): Promise<void>;
+    dispose(): Promise<void>;
+    embedMany(texts: string[], options?: {
+        signal?: AbortSignal;
+    }): Promise<number[][]>;
+    embed(text: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<number[]>;
+    test(): Promise<{
+        success: boolean;
+        dimensions?: number;
+        error?: string;
+    }>;
+    private createProvider;
+    private redact;
+}
+
+export { type ActiveRuntimeWork, type ActiveRuntimeWorkKind, type ActiveStream, type ActiveWorkTracker, type AgentExecutionMode, type AgentIdResolver, type AiFeatureRuntimeState, type AuthMode, type BillingMode, type BridgeSessionResource, type ChatRuntimeBridge, type ChatRuntimeBridgeConfig, type ConversationDetail, type ConversationInfo, type ConversationPage, type ConversationPatch, type ConversationStore, type CreateConversationInput, EMPTY_CAPABILITIES, type EditorOutputContext, type EmbeddingModelChangeEvent, type EmbeddingProvider, type EmbeddingProviderConfig, type EmbeddingSession, type ExecutionTarget, type GetConversationInput, type HistoryLocation, type InsertOutputData, type ListConversationsInput, MockSanqianSdk, type MockScenario, type MockSdkConfig, type OutputOperation, type OutputOperationType, type OutputOperationsManager, type PendingOutputOps, type PendingPermission, type PermissionDecision, type PermissionGate, type PermissionPolicy, type ProviderChangedEvent, type ProviderInstanceConfig, type RerankInput, type RerankProvider, type RerankResult, type RerankResultItem, type ResourceListPage, type ResourceListRequest, type ResourceProviderInfo, type RuntimeAgentConfig, type RuntimeAgentId, type RuntimeAgentRegistry, type RuntimeChatRequest, type RuntimeChatResponse, type RuntimeChatStreamRequest, type RuntimeConnectionErrorCode, type RuntimeConnectionSnapshot, type RuntimeConnectionStatus, type RuntimeContext, type RuntimeConversationMessage, type RuntimeHitlResponse, type RuntimeInterrupt, type RuntimeMessage, type RuntimePermissionResponse, type RuntimeProfile, type RuntimeProvider, type RuntimeProviderCapabilities, type RuntimeProviderDescriptor, type RuntimeProviderKind, type RuntimeResource, type RuntimeResourceRef, type RuntimeSecretStore, type RuntimeSessionManager, type RuntimeSessionResourceEvent, type RuntimeStreamEvent, type RuntimeTaskPipeline, type RuntimeTaskPipelineInput, type RuntimeToolCall, type RuntimeToolDefinition, type RuntimeToolExecutionContext, type RuntimeToolExecutionInput, type RuntimeToolExecutionMetadata, type RuntimeToolExecutionResult, type RuntimeToolHandler, type RuntimeToolMetadata, type RuntimeToolRegistration, type RuntimeToolRegistry, type RuntimeUsage, type SanqianEmbeddingConfig, SanqianEmbeddingProvider, SanqianProvider, type SanqianProviderConfig, type SanqianRerankConfig, SanqianRerankProvider, type SanqianSdkPort, type SecretDescriptor, type SecretRef, type StoreSecretInput, type SwitchOptions, type SwitchResult, type ToolCategory, type VercelEmbeddingConfig, VercelEmbeddingProvider, VercelProvider, type VercelProviderConfig, convertSdkStreamEvent, convertToolsForVercel, createActiveWorkTracker, createCategoryPermissionPolicy, createChatRuntimeBridge, createDefaultPermissionPolicy, createDisabledState, createEmbeddingSession, createMemoryConversationStore, createMemorySecretStore, createOutputOperationsManager, createPermissionGate, createSanqianAgentIdResolver, createSessionManager, createTaskPipeline, createToolRegistry, redactToolError, resolveAiFeaturesFromRuntime, validateOutputContent };