invoke()

client.invoke(
    mcp: str,
    action: str,
    intent_token: IntentToken,
    params: dict = None,
    merkle_proof: list = None,
    user_email: str = None
) -> MCPInvocationResult

await client.invoke(
  mcp: string,
  action: string,
  intentToken: IntentToken,
  params?: Record<string, any>,
  merkleProof?: Array<Record<string, any>>,
  userEmail?: string
): Promise<MCPInvocationResult>

{
    "success": bool,               # Whether action succeeded
    "data": any,                   # Response data from MCP
    "error": str,                  # Error message (if failed)
    "execution_time_ms": int,      # Execution duration
    "mcp": str,                    # MCP that executed
    "action": str                  # Action that ran
}

interface MCPInvocationResult {
  mcp: string;                  // MCP identifier
  action: string;               // Action that was invoked
  result: any;                  // Action result data
  status: string;               // Execution status
  executionTime?: number;       // Time taken (seconds)
  verified: boolean;            // Token verification status
  metadata: Record<string, any> // Extra metadata
}

# Basic invocation
result = client.invoke(
    mcp="analytics-mcp",
    action="analyze",
    intent_token=token,
    params={"data": [1, 2, 3, 4, 5], "metrics": ["mean", "std"]}
)

if result["success"]:
    print(f"Results: {result['data']}")
    print(f"Took: {result['execution_time_ms']}ms")
else:
    print(f"Error: {result['error']}")

# With error handling
try:
    result = client.invoke("data-mcp", "fetch_data", token, {"source": "db"})

    if result["success"]:
        data = result["data"]
    else:
        logger.error(f"MCP error: {result['error']}")

except TokenExpiredError:
    # Get fresh token
    token = client.get_intent_token(plan)["token"]
    result = client.invoke("data-mcp", "fetch_data", token, {"source": "db"})

except VerificationError as e:
    # Action not in plan
    logger.error(f"Verification failed: {e}")
    # Need to recreate plan with correct actions

# Custom timeout
result = client.invoke(
    "analytics-mcp",
    "long_analysis",
    token,
    {"dataset": "large"},
    timeout=120  # 2 minutes
)

import { 
  ArmorIQClient, 
  TokenExpiredException, 
  IntentMismatchException 
} from '@armoriq/sdk';

// Basic invocation
const result = await client.invoke(
  'analytics-mcp',
  'analyze',
  token,
  { data: [1, 2, 3, 4, 5], metrics: ['mean', 'std'] }
);

console.log(`Results: ${JSON.stringify(result.result)}`);
console.log(`Took: ${result.executionTime?.toFixed(2)}s`);

// With error handling
try {
  const result = await client.invoke(
    'data-mcp',
    'fetch_data',
    token,
    { source: 'db' }
  );
  const data = result.result;
} catch (error) {
  if (error instanceof TokenExpiredException) {
    // Get fresh token
    const newToken = await client.getIntentToken(planCapture);
    const result = await client.invoke(
      'data-mcp',
      'fetch_data',
      newToken,
      { source: 'db' }
    );
  } else if (error instanceof IntentMismatchException) {
    // Action not in plan
    console.error(`Verification failed: ${error.message}`);
    // Need to recreate plan with correct actions
  }
}

// Sequential invocation from complete workflow
const result1 = await client.invoke('weather-mcp', 'get_weather', token, { city: 'Boston' });
console.log(`Boston weather: ${JSON.stringify(result1.result)}`);

const result2 = await client.invoke('weather-mcp', 'get_weather', token, { city: 'New York' });
console.log(`New York weather: ${JSON.stringify(result2.result)}`);