@canonmsg/claude-code-plugin 0.21.2 → 0.22.0

package/README.md

@@ -1,4 +1,4 @@
-# Canon Plugin for Claude Code
+# Canon Host for Claude Code
 
 Connect Claude Code to [Canon](https://github.com/HeyBobChan/canon) — a messaging app where AI agents are first-class citizens. Control Claude Code from your phone.
 
@@ -67,22 +67,6 @@ canon-register --name "Frontend" --description "React work" --phone "+1..." --pr
 CANON_AGENT=frontend canon-claude --cwd ~/projects/frontend
 ```
 
-## Channel mode (alternative)
-
-For a lighter integration without session controls, run Canon as a channel plugin inside your own Claude Code session. The `canon-channel-server` binary (installed by this package) is an MCP stdio server that Claude Code launches.
-
-Register the channel server with Claude Code's MCP config and provide your Canon API key via the `CANON_API_KEY` environment variable:
-
-```bash
-# Register once per Claude Code project
-claude mcp add canon-channel canon-channel-server
-
-# Then start Claude Code with your Canon key in the environment
-CANON_API_KEY=agk_live_... claude
-```
-
-Channel mode forwards messages between Canon conversations and the embedded Claude Code session without managing session lifecycle. It is shown as non-revivable by `canon-necromance`. Use `canon-claude` host mode when you want phone-controlled runtime sessions with setup and live controls.
-
 ## Development
 
 ```bash

package/dist/host.js

@@ -1099,7 +1099,6 @@ function createSession(conversationId, environment, agentId, port, typingSignals
         cwd,
         environment,
         query: q,
-        controlApplySeq: new Map(),
         sendInput,
         enqueueInbound: (msg, intent = 'queue', sourceMessageId, markAccepted = false, isOwnerTurn = false, artifactRoutingMode = 'disabled') => enqueueInboundMessage(msg, intent, sourceMessageId, markAccepted, isOwnerTurn, artifactRoutingMode),
         state: buildClaudeInitialSessionState({

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-export { main as serverMain } from './server.js';
 export { main as hostMain } from './host.js';
 export { main as registerMain } from './register.js';
 export { main as setupMain } from './setup.js';

package/dist/index.js

@@ -1,4 +1,3 @@
-export { main as serverMain } from './server.js';
 export { main as hostMain } from './host.js';
 export { main as registerMain } from './register.js';
 export { main as setupMain } from './setup.js';

package/dist/session-state.d.ts

@@ -54,7 +54,6 @@ export declare function buildClaudeInitialSessionState(input: {
 }): ClaudeHostSessionState;
 export interface ClaudeSessionControlTarget {
     state: ClaudeHostSessionState;
-    controlApplySeq: Map<string, number>;
     closed: boolean;
     query: Pick<Query, 'setModel' | 'setPermissionMode' | 'applyFlagSettings'>;
     writeState: () => void;

package/dist/session-state.js

@@ -29,21 +29,23 @@ export function buildClaudeInitialSessionState(input) {
         state: 'idle',
     };
 }
-function nextControlApplySeq(target, controlId) {
-    const nextSeq = (target.controlApplySeq.get(controlId) ?? 0) + 1;
-    target.controlApplySeq.set(controlId, nextSeq);
-    return nextSeq;
-}
-function applyOptimisticControl(input) {
-    const seq = nextControlApplySeq(input.target, input.controlId);
-    const applyPromise = (async () => input.apply())();
-    void applyPromise
-        .catch((error) => {
-        if (input.target.closed || input.target.controlApplySeq.get(input.controlId) !== seq) {
+/**
+ * Apply a control to the Claude SDK. W2-A2 deleted the seq-guarded optimistic
+ * revert machinery (commit c356bdf8) that masked the 2–11s control poll: the
+ * bridge is event-push now (~100ms), so the state is already published by the
+ * caller's writeState() and the SDK apply is fired without a revert dance. A
+ * failed apply surfaces as a runtime-control error (the display truth the app
+ * reads) — the same shape codex uses. `value` is the requested value for the
+ * error record; `controlId` scopes the error.
+ */
+function applyControl(input) {
+    // Fire the SDK apply SYNCHRONOUSLY (an async setter may still resolve later);
+    // wrap so a synchronous throw is caught in the same rejection path.
+    void (async () => input.apply())().catch((error) => {
+        if (input.target.closed)
             return;
-        }
-        input.revert();
         input.target.setRuntimeControlError(input.controlId, input.value, error);
+        input.target.writeState();
     });
 }
 function setRuntimeControlValue(state, controlId, value) {
@@ -58,20 +60,13 @@ export function applyClaudeSessionControl(target, ctrl) {
         target.setRuntimeControlError('model', String(ctrl.model), new Error('Unsupported Claude model.'));
     }
     else if (nextModel && nextModel !== target.state.model) {
-        const previous = target.state.model;
         target.state.model = nextModel;
         target.clearRuntimeControlError('model');
-        applyOptimisticControl({
+        applyControl({
             target,
             controlId: 'model',
             value: nextModel,
             apply: () => target.query.setModel(nextModel),
-            revert: () => {
-                if (previous === undefined)
-                    delete target.state.model;
-                else
-                    target.state.model = previous;
-            },
         });
     }
     const nextPermissionMode = parseClaudePermissionMode(ctrl.permissionMode);
@@ -79,41 +74,27 @@ export function applyClaudeSessionControl(target, ctrl) {
         target.setRuntimeControlError('permissionMode', ctrl.permissionMode, new Error(`Unsupported Claude permission mode: ${ctrl.permissionMode}`));
     }
     else if (nextPermissionMode && nextPermissionMode !== target.state.permissionMode) {
-        // Claude Code applies permission-mode changes asynchronously. We publish
-        // the requested value immediately so Canon does not show a stale "requested"
-        // state while the SDK catches up, then revert if the current apply fails.
-        const previous = target.state.permissionMode;
+        // Claude Code applies permission-mode changes asynchronously; publish the
+        // requested value immediately (writeState below) and surface an error if the
+        // apply fails.
         target.state.permissionMode = nextPermissionMode;
         target.clearRuntimeControlError('permissionMode');
-        applyOptimisticControl({
+        applyControl({
             target,
             controlId: 'permissionMode',
             value: nextPermissionMode,
             apply: () => target.query.setPermissionMode(nextPermissionMode),
-            revert: () => {
-                if (previous === undefined)
-                    delete target.state.permissionMode;
-                else
-                    target.state.permissionMode = previous;
-            },
         });
     }
     const nextEffort = normalizeClaudeEffortLevel(ctrl.effort);
     if (nextEffort && nextEffort !== target.state.effort) {
-        const previous = target.state.effort;
         target.state.effort = nextEffort;
         target.clearRuntimeControlError('effort');
-        applyOptimisticControl({
+        applyControl({
             target,
             controlId: 'effort',
             value: nextEffort,
             apply: () => target.query.applyFlagSettings({ effortLevel: nextEffort }),
-            revert: () => {
-                if (previous === undefined)
-                    delete target.state.effort;
-                else
-                    target.state.effort = previous;
-            },
         });
     }
     else if (ctrl.effort !== undefined && !nextEffort) {
@@ -126,20 +107,13 @@ export function applyClaudeSessionControl(target, ctrl) {
             target.setRuntimeControlError('thinking', String(runtimeControlValues.thinking), new Error('Unsupported Claude thinking mode.'));
         }
         else if (nextThinking !== target.state.runtimeControlValues?.thinking) {
-            const previous = target.state.runtimeControlValues?.thinking;
             setRuntimeControlValue(target.state, 'thinking', nextThinking);
             target.clearRuntimeControlError('thinking');
-            applyOptimisticControl({
+            applyControl({
                 target,
                 controlId: 'thinking',
                 value: nextThinking,
                 apply: () => target.query.applyFlagSettings({ alwaysThinkingEnabled: claudeThinkingToFlagValue(nextThinking) }),
-                revert: () => {
-                    if (previous === undefined)
-                        delete target.state.runtimeControlValues?.thinking;
-                    else
-                        setRuntimeControlValue(target.state, 'thinking', previous);
-                },
             });
         }
     }
@@ -149,20 +123,13 @@ export function applyClaudeSessionControl(target, ctrl) {
             target.setRuntimeControlError('ultracode', String(runtimeControlValues.ultracode), new Error('Unsupported Claude ultracode mode.'));
         }
         else if (nextUltracode !== target.state.runtimeControlValues?.ultracode) {
-            const previous = target.state.runtimeControlValues?.ultracode;
             setRuntimeControlValue(target.state, 'ultracode', nextUltracode);
             target.clearRuntimeControlError('ultracode');
-            applyOptimisticControl({
+            applyControl({
                 target,
                 controlId: 'ultracode',
                 value: nextUltracode,
                 apply: () => target.query.applyFlagSettings({ ultracode: nextUltracode === 'on' }),
-                revert: () => {
-                    if (previous === undefined)
-                        delete target.state.runtimeControlValues?.ultracode;
-                    else
-                        setRuntimeControlValue(target.state, 'ultracode', previous);
-                },
             });
         }
     }

package/dist/setup.d.ts

@@ -2,8 +2,7 @@
 /**
  * Setup script for the Canon Claude Code plugin.
  *
- * Run after `npm install -g @canonmsg/claude-code-plugin` to:
- * 1. Install the /canon-register and /canon-configure skills
- * 2. Show the user how to add the MCP server to their .mcp.json
+ * Run after `npm install -g @canonmsg/claude-code-plugin` to install the
+ * /canon-register and /canon-configure skills.
  */
 export declare function main(): void;

package/dist/setup.js

@@ -2,15 +2,14 @@
 /**
  * Setup script for the Canon Claude Code plugin.
  *
- * Run after `npm install -g @canonmsg/claude-code-plugin` to:
- * 1. Install the /canon-register and /canon-configure skills
- * 2. Show the user how to add the MCP server to their .mcp.json
+ * Run after `npm install -g @canonmsg/claude-code-plugin` to install the
+ * /canon-register and /canon-configure skills.
  */
 import { mkdirSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { runCli } from './cli-entry.js';
-const HELP = `canon-setup — install Claude Code Canon skills and print MCP setup
+const HELP = `canon-setup — install Claude Code Canon skills
 
 USAGE
   canon-setup
@@ -19,8 +18,7 @@ FLAGS
   --help, -h       Show this help
   --version, -V    Show package version
 
-This command writes Canon Claude Code skill files under ~/.claude/skills and
-prints the MCP server configuration for Claude Code channel mode.`;
+This command writes Canon Claude Code skill files under ~/.claude/skills.`;
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const home = process.env.HOME || process.env.USERPROFILE || '';
 const skillsDir = join(home, '.claude', 'skills');
@@ -45,27 +43,6 @@ function installSkills() {
         console.log(`  Installed /canon-${skill}`);
     }
 }
-// ── Show MCP config instructions ───────────────────────────────────────
-function showMcpInstructions() {
-    // Find the installed server.js path
-    const serverPath = join(__dirname, 'server.js');
-    console.log(`
-Add this to your project's .mcp.json (or ~/.mcp.json for global):
-
-{
-  "mcpServers": {
-    "canon-channel": {
-      "command": "node",
-      "args": ["${serverPath}"]
-    }
-  }
-}
-
-Then start Claude Code with:
-
-  claude --dangerously-load-development-channels server:canon-channel
-`);
-}
 // ── Main ───────────────────────────────────────────────────────────────
 export function main() {
     console.log('Canon Claude Code Plugin Setup');
@@ -75,8 +52,7 @@ export function main() {
     console.log('\nRegistering your agent...');
     console.log('  Run /canon-register in Claude Code to register a new agent');
     console.log('  Run /canon-configure if you already have an API key\n');
-    console.log('MCP server configuration:');
-    showMcpInstructions();
+    console.log('Run `canon-claude` to connect this agent to Canon.');
 }
 runCli(import.meta.url, main, (error) => {
     console.error('[canon-setup] Fatal error:', error);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.21.2",
-  "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
+  "version": "0.22.0",
+  "description": "Canon host for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,15 +12,13 @@
     }
   },
   "bin": {
-    "canon-channel-server": "dist/server.js",
     "canon-claude": "dist/host.js",
     "canon-register": "dist/register.js",
     "canon-setup": "dist/setup.js"
   },
   "files": [
     "dist",
-    "skills",
-    ".claude-plugin"
+    "skills"
   ],
   "scripts": {
     "prepare:workspace-deps": "node ../../scripts/run-workspace-prep.mjs ../../packages/core ../../packages/agent-sdk ../../packages/framework ../../packages/bridge ../../packages/agent-host",
@@ -31,11 +29,11 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.3.200",
-    "@canonmsg/agent-host": "^0.4.0",
-    "@canonmsg/agent-sdk": "^3.4.4",
-    "@canonmsg/bridge": "^0.2.3",
-    "@canonmsg/core": "^3.2.1",
-    "@canonmsg/framework": "^0.2.0",
+    "@canonmsg/agent-host": "^0.5.0",
+    "@canonmsg/agent-sdk": "^4.0.0",
+    "@canonmsg/bridge": "^0.3.0",
+    "@canonmsg/core": "^3.3.0",
+    "@canonmsg/framework": "^0.3.0",
     "@modelcontextprotocol/sdk": "^1.29.0"
   },
   "engines": {

package/skills/configure/SKILL.md

@@ -36,15 +36,9 @@ Add an existing Canon agent API key as a named profile.
 
 5. Write the updated profiles to `~/.canon/agents.json`.
 
-6. Tell the user: **"API key saved as profile '<profile>'. Restart Claude Code to connect."**
+6. Tell the user: **"API key saved as profile '<profile>'. Run `canon-claude` to connect."**
 
-   If they have multiple agents and want to pin one, add to `.mcp.json`:
-   ```json
-   {
-     "mcpServers": {
-       "canon-channel": {
-         "env": { "CANON_AGENT": "<profile>" }
-       }
-     }
-   }
+   If they have multiple agents and want to pin one, start the host with the profile name:
+   ```bash
+   CANON_AGENT=<profile> canon-claude
    ```

package/.claude-plugin/plugin.json

@@ -1,25 +0,0 @@
-{
-  "name": "Canon",
-  "description": "Connect Claude Code to Canon — messaging where AI agents are first-class citizens",
-  "version": "0.1.0",
-  "channels": [
-    {
-      "server": "canon-channel",
-      "userConfig": {
-        "api_key": {
-          "description": "Canon agent API key (agk_live_...)",
-          "sensitive": true
-        }
-      }
-    }
-  ],
-  "mcpServers": {
-    "canon-channel": {
-      "command": "node",
-      "args": ["${CLAUDE_PLUGIN_ROOT}/dist/server.js"],
-      "env": {
-        "CANON_PLUGIN_API_KEY": "${user_config.api_key}"
-      }
-    }
-  }
-}

package/dist/approval-server.d.ts

@@ -1,33 +0,0 @@
-import type { ApprovalManager } from '@canonmsg/core/host';
-/**
- * HTTP server that bridges Claude Code's PermissionRequest hook
- * to Canon's ApprovalManager.
- *
- * Listens on localhost for POST /approve from Claude Code hooks.
- */
-export declare class ApprovalHttpServer {
-    private server;
-    private manager;
-    private port;
-    private getConversationId;
-    private getIsOwnerTurn;
-    private token;
-    private maxBodyBytes;
-    private requestTimeoutMs;
-    constructor(manager: ApprovalManager, getConversationId: () => string | null, opts?: {
-        port?: number;
-        token?: string;
-        maxBodyBytes?: number;
-        requestTimeoutMs?: number;
-        getIsOwnerTurn?: () => boolean;
-    });
-    private static readonly MAX_PORT_RETRIES;
-    get authToken(): string;
-    start(): Promise<number>;
-    stop(): Promise<void>;
-    private handleRequest;
-    private hasValidToken;
-    private handleApproval;
-    private sendHookResponse;
-    private classifyRisk;
-}

package/dist/approval-server.js

@@ -1,200 +0,0 @@
-import { createServer } from 'node:http';
-import { randomBytes, timingSafeEqual } from 'node:crypto';
-import { buildClaudeApprovalDetails, classifyClaudeApprovalCategory, classifyClaudeApprovalRisk, } from './tool-policy.js';
-/**
- * HTTP server that bridges Claude Code's PermissionRequest hook
- * to Canon's ApprovalManager.
- *
- * Listens on localhost for POST /approve from Claude Code hooks.
- */
-export class ApprovalHttpServer {
-    server = null;
-    manager;
-    port;
-    getConversationId;
-    getIsOwnerTurn;
-    token;
-    maxBodyBytes;
-    requestTimeoutMs;
-    constructor(manager, getConversationId, opts) {
-        this.manager = manager;
-        this.getConversationId = getConversationId;
-        this.getIsOwnerTurn = opts?.getIsOwnerTurn ?? (() => true);
-        this.port = opts?.port ?? 19420;
-        this.token = opts?.token ?? randomBytes(32).toString('base64url');
-        this.maxBodyBytes = opts?.maxBodyBytes ?? 64 * 1024;
-        this.requestTimeoutMs = opts?.requestTimeoutMs ?? 10_000;
-    }
-    static MAX_PORT_RETRIES = 10;
-    get authToken() {
-        return this.token;
-    }
-    async start() {
-        const startPort = this.port;
-        return new Promise((resolve, reject) => {
-            this.server = createServer((req, res) => this.handleRequest(req, res));
-            this.server.on('error', (err) => {
-                if (err.code === 'EADDRINUSE') {
-                    this.port++;
-                    if (this.port - startPort >= ApprovalHttpServer.MAX_PORT_RETRIES) {
-                        reject(new Error(`No available port found in range ${startPort}–${this.port}`));
-                        return;
-                    }
-                    this.server.listen(this.port, '127.0.0.1');
-                }
-                else {
-                    reject(err);
-                }
-            });
-            this.server.listen(this.port, '127.0.0.1', () => {
-                const address = this.server?.address();
-                if (address && typeof address === 'object') {
-                    this.port = address.port;
-                }
-                console.error(`[canon] Approval server listening on 127.0.0.1:${this.port}`);
-                resolve(this.port);
-            });
-        });
-    }
-    async stop() {
-        return new Promise((resolve) => {
-            if (this.server) {
-                this.server.close(() => resolve());
-            }
-            else {
-                resolve();
-            }
-        });
-    }
-    handleRequest(req, res) {
-        if (req.method !== 'POST' || req.url !== '/approve') {
-            res.writeHead(404, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'Not found' }));
-            return;
-        }
-        req.setTimeout(this.requestTimeoutMs, () => {
-            res.writeHead(408, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'Request timeout' }));
-            req.destroy();
-        });
-        if (!this.hasValidToken(req)) {
-            res.writeHead(401, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'Unauthorized' }));
-            return;
-        }
-        let body = '';
-        req.on('data', (chunk) => {
-            if (res.writableEnded)
-                return;
-            if (body.length + chunk.length > this.maxBodyBytes) {
-                res.writeHead(413, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Request body too large' }));
-                req.destroy();
-                return;
-            }
-            body += chunk.toString();
-        });
-        req.on('end', () => {
-            if (res.writableEnded)
-                return;
-            this.handleApproval(body, res).catch((err) => {
-                console.error('[canon] Approval handler error:', err);
-                if (res.writableEnded)
-                    return;
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Internal error' }));
-            });
-        });
-    }
-    hasValidToken(req) {
-        const authHeader = req.headers.authorization;
-        const bearer = typeof authHeader === 'string' && authHeader.toLowerCase().startsWith('bearer ')
-            ? authHeader.slice('bearer '.length).trim()
-            : null;
-        const headerToken = req.headers['x-canon-approval-token'];
-        const supplied = bearer || (typeof headerToken === 'string' ? headerToken : null);
-        if (!supplied)
-            return false;
-        const expected = Buffer.from(this.token);
-        const received = Buffer.from(supplied);
-        return expected.length === received.length && timingSafeEqual(expected, received);
-    }
-    async handleApproval(body, res) {
-        let payload;
-        try {
-            payload = JSON.parse(body);
-        }
-        catch {
-            res.writeHead(400, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'Invalid JSON' }));
-            return;
-        }
-        const toolName = payload.tool_name ?? 'Unknown';
-        const toolInput = payload.tool_input ?? {};
-        // Determine risk level
-        const riskLevel = this.classifyRisk(toolName, toolInput);
-        const isOwnerTurn = this.getIsOwnerTurn();
-        // Find the conversation to send the approval to.
-        const conversationId = this.getConversationId();
-        if (!conversationId) {
-            console.error('[canon] No active conversation for approval — falling back to ask');
-            // Can't send approval message, fall through to terminal prompt.
-            this.sendHookResponse(res, 'ask');
-            return;
-        }
-        // Check session rules first for owner-triggered turns. Non-owner-triggered
-        // tools require a fresh owner decision so an old "approve all" does not
-        // turn into remote control of the owner's local runtime.
-        const existingRule = isOwnerTurn ? this.manager.checkSessionRules(toolName, conversationId) : null;
-        if (existingRule) {
-            const decision = existingRule.type === 'deny-tool' ? 'deny' : 'allow';
-            this.sendHookResponse(res, decision);
-            return;
-        }
-        try {
-            const result = await this.manager.requestApproval(conversationId, toolName, toolInput, {
-                riskLevel,
-                risk: classifyClaudeApprovalRisk(toolName, toolInput),
-                category: classifyClaudeApprovalCategory(toolName),
-                native: {
-                    runtime: 'claude-code',
-                    method: 'PermissionRequest',
-                    ...(payload.session_id ? { requestId: payload.session_id } : {}),
-                },
-                details: buildClaudeApprovalDetails(toolName, toolInput),
-                ignoreSessionRules: !isOwnerTurn,
-                allowSessionRule: isOwnerTurn,
-            });
-            this.sendHookResponse(res, result.decision);
-        }
-        catch (err) {
-            console.error('[canon] Approval request failed:', err);
-            // On error, fall back to terminal prompt
-            this.sendHookResponse(res, 'ask');
-        }
-    }
-    sendHookResponse(res, behavior) {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-            hookSpecificOutput: {
-                hookEventName: 'PermissionRequest',
-                decision: { behavior },
-            },
-        }));
-    }
-    classifyRisk(toolName, toolInput) {
-        if (toolName !== 'Bash')
-            return 'normal';
-        const cmd = typeof toolInput.command === 'string' ? toolInput.command : '';
-        const destructivePatterns = [
-            /\brm\s+(-rf?|--force)/,
-            /\bgit\s+push\s+--force/,
-            /\bgit\s+reset\s+--hard/,
-            /\bdrop\s+(table|database)/i,
-            /\bformat\b/,
-        ];
-        return destructivePatterns.some((p) => p.test(cmd))
-            ? 'destructive'
-            : 'normal';
-    }
-}

package/dist/mcp-args.d.ts

@@ -1,45 +0,0 @@
-import type { DirectSessionSelection, SendContextualMessageOptions } from '@canonmsg/core/contract';
-export type McpParseResult<T> = {
-    ok: true;
-    value: T;
-} | {
-    ok: false;
-    error: string;
-};
-type ContentType = 'text' | 'image' | 'audio' | 'video' | 'file';
-export interface ReplyArgs {
-    conversationId: string;
-    text: string;
-}
-export declare function parseReplyArgs(value: unknown): McpParseResult<ReplyArgs>;
-export interface SendMessageArgs {
-    conversationId: string;
-    text: string;
-    contentType: ContentType;
-    imageUrl?: string;
-    audioUrl?: string;
-    videoUrl?: string;
-    fileUrl?: string;
-    mediaPath?: string;
-    fileName?: string;
-    mimeType?: string;
-    durationMs?: number;
-}
-export declare function parseSendMessageArgs(value: unknown): McpParseResult<SendMessageArgs>;
-export interface SendContextualMessageArgs {
-    sourceConversationId: string;
-    targetConversationId?: string;
-    targetUserId?: string;
-    text: string;
-    selfContext: SendContextualMessageOptions['selfContext'];
-    sessionSelection?: DirectSessionSelection;
-    messageOptions?: SendContextualMessageOptions['messageOptions'];
-}
-export declare function parseSendContextualMessageArgs(value: unknown): McpParseResult<SendContextualMessageArgs>;
-export interface SetTypingArgs {
-    conversationId: string;
-    typing: boolean;
-    status?: 'typing' | 'thinking';
-}
-export declare function parseSetTypingArgs(value: unknown): McpParseResult<SetTypingArgs>;
-export {};