@muxoai/sdk 0.3.1 → 0.4.0-preview.20261010.2

package/dist/index.d.ts

@@ -1,349 +1,1352 @@
-import type { AnalyticsTrackInput, AppSearchInput, AuthUsersInput, BrowserDriveInput, ComputeContainerInput, DbQueryInput, DbWriteInput, DeployContainerInput, DeployEdgeInput, DeploySiteInput, DnsManageInput, DomainsRegisterInput, EmailSendInput, Envelope, FeatureFlagInput, KvStoreInput, LlmChatInput, LlmEmbedInput, LlmImageInput, LlmSttInput, LlmTtsInput, MemorySearchInput, MemoryStoreInput, ObservabilityLogInput, PaymentEvent, PaymentsChargeInput, PaymentsIntentInput, PaymentsListInput, PaymentsRefundInput, PaymentsStatus, QueueEmitInput, SandboxInput, SmsSendInput, StorageObjectInput, ToolCard, ToolContract, ToolRunResult, ToolsDiscoverInput, ToolsInspectInput, ToolsRunInput, VectorSearchInput, VideoGenerateInput, WebCrawlInput, WebExtractInput, WebMonitorInput, WebScrapeInput, WebSearchInput, ContextScope, ContextPacket, ContextDiff, ContextMemory, EntityResolution, LedgerEntry, EvalReport, Session } from './types';
-export type { AnalyticsTrackInput, AppSearchInput, AuthUsersInput, BrowserDriveInput, ComputeContainerInput, DbQueryInput, DbWriteInput, DeployContainerInput, DeployEdgeInput, DeploySiteInput, DnsManageInput, DomainsRegisterInput, EmailSendInput, Envelope, FeatureFlagInput, KvStoreInput, LlmChatInput, LlmEmbedInput, LlmImageInput, LlmSttInput, LlmTtsInput, MemorySearchInput, MemoryStoreInput, MuxoError, ObservabilityLogInput, PaymentEvent, PaymentIntentResult, PaymentsChargeInput, PaymentsIntentInput, PaymentsListInput, PaymentsRefundInput, PaymentsStatus, QueueEmitInput, RefundResult, SandboxInput, SmsSendInput, StorageObjectInput, ToolCard, ToolContract, ToolHealth, ToolInputSchema, ToolPrice, ToolRunResult, ToolsDiscoverInput, ToolsInspectInput, ToolsRunInput, Usage, VectorSearchInput, VideoGenerateInput, WebCrawlInput, WebExtractInput, WebMonitorInput, WebScrapeInput, WebSearchInput, ContextScope, ContextPacket, ContextDiff, ContextMemory, EntityResolution, LedgerEntry, EvalReport, Session, } from './types';
-export { OrgBrain, type OrgBrainOptions, type AnswerPath, type BrainOrg, type BrainSpace, type BrainAnswer, type BrainApproval, type BrainSelf, type CreateSpaceInput, } from './brain.js';
-export interface MuxoOptions {
-    /** Omit to bootstrap: a keyless client can call `keys.create()` for a free key. */
-    key?: string;
-    baseUrl?: string;
+import { z } from 'zod';
+
+declare const riskSchema: z.ZodEnum<{
+	read: "read";
+	write: "write";
+	admin: "admin";
+	financial: "financial";
+	provisioning: "provisioning";
+	destructive: "destructive";
+}>;
+export type ActionRisk = z.infer<typeof riskSchema>;
+declare const operations: {
+	readonly get_organization: {
+		lane?: "read" | "write" | "admin" | "financial" | "provisioning" | "destructive";
+		path: string;
+		title: string;
+		description: string;
+		scope: string | null;
+		input: z.ZodObject<{}, z.core.$strict>;
+		output: z.ZodObject<{
+			organization_id: z.ZodString;
+			project_id: z.ZodString;
+			profile_id: z.ZodString;
+			name: z.ZodString;
+			role: z.ZodLiteral<"owner">;
+			budget: z.ZodObject<{
+				currency: z.ZodLiteral<"USD">;
+				lifetime_cap_minor: z.ZodNumber;
+				committed_bound_minor: z.ZodNumber;
+				remaining_minor: z.ZodNumber;
+				automatic_recharge: z.ZodLiteral<false>;
+			}, z.core.$strict>;
+		}, z.core.$strict>;
+		annotations: {
+			readOnlyHint: boolean;
+			destructiveHint: boolean;
+			idempotentHint: boolean;
+			openWorldHint: boolean;
+		};
+	};
+	readonly get_profile: {
+		lane?: "read" | "write" | "admin" | "financial" | "provisioning" | "destructive";
+		path: string;
+		title: string;
+		description: string;
+		scope: string | null;
+		input: z.ZodObject<{}, z.core.$strict>;
+		output: z.ZodObject<{
+			id: z.ZodString;
+			name: z.ZodOptional<z.ZodString>;
+			email: z.ZodOptional<z.ZodEmail>;
+			nickname: z.ZodOptional<z.ZodString>;
+		}, z.core.$strict>;
+		annotations: {
+			readOnlyHint: boolean;
+			destructiveHint: boolean;
+			idempotentHint: boolean;
+			openWorldHint: boolean;
+		};
+	};
+	readonly search_tools: {
+		lane?: "read" | "write" | "admin" | "financial" | "provisioning" | "destructive";
+		path: string;
+		title: string;
+		description: string;
+		scope: string | null;
+		input: z.ZodObject<{
+			query: z.ZodString;
+			toolkit: z.ZodOptional<z.ZodString>;
+			kind: z.ZodOptional<z.ZodEnum<{
+				toolkit: "toolkit";
+				tool: "tool";
+				provider: "provider";
+				service: "service";
+			}>>;
+			limit: z.ZodDefault<z.ZodNumber>;
+			cursor: z.ZodOptional<z.ZodString>;
+		}, z.core.$strict>;
+		output: z.ZodObject<{
+			tools: z.ZodArray<z.ZodObject<{
+				id: z.ZodString;
+				version: z.ZodString;
+				title: z.ZodString;
+				description: z.ZodString;
+				risk: z.ZodEnum<{
+					read: "read";
+					write: "write";
+					admin: "admin";
+					financial: "financial";
+					provisioning: "provisioning";
+					destructive: "destructive";
+				}>;
+				certification: z.ZodEnum<{
+					discovered: "discovered";
+					reviewed: "reviewed";
+					contract_tested: "contract_tested";
+					enabled: "enabled";
+					quarantined: "quarantined";
+				}>;
+				readiness: z.ZodObject<{
+					state: z.ZodEnum<{
+						approval_required: "approval_required";
+						payment_required: "payment_required";
+						ready: "ready";
+						unavailable: "unavailable";
+						connection_required: "connection_required";
+						scope_required: "scope_required";
+						owner_action_required: "owner_action_required";
+						restricted: "restricted";
+					}>;
+					reason: z.ZodString;
+				}, z.core.$strict>;
+				catalogue: z.ZodOptional<z.ZodDiscriminatedUnion<[
+					z.ZodObject<{
+						kind: z.ZodLiteral<"toolkit">;
+						supplier: z.ZodLiteral<"composio">;
+						slug: z.ZodString;
+						source_url: z.ZodURL;
+						managed_oauth: z.ZodNullable<z.ZodBoolean>;
+						instant_tools: z.ZodNullable<z.ZodBoolean>;
+						no_auth: z.ZodNullable<z.ZodBoolean>;
+						tools_count: z.ZodNumber;
+					}, z.core.$strict>,
+					z.ZodObject<{
+						kind: z.ZodLiteral<"tool">;
+						supplier: z.ZodLiteral<"composio">;
+						slug: z.ZodString;
+						source_url: z.ZodURL;
+						instant_tool: z.ZodBoolean;
+						no_auth: z.ZodNullable<z.ZodBoolean>;
+					}, z.core.$strict>,
+					z.ZodObject<{
+						kind: z.ZodLiteral<"provider">;
+						supplier: z.ZodLiteral<"projects">;
+						slug: z.ZodString;
+						source_url: z.ZodURL;
+						observed_at: z.ZodISODateTime;
+						native_reference: z.ZodString;
+						categories: z.ZodArray<z.ZodString>;
+					}, z.core.$strict>,
+					z.ZodObject<{
+						kind: z.ZodLiteral<"service">;
+						supplier: z.ZodLiteral<"projects">;
+						provider_id: z.ZodString;
+						service_id: z.ZodString;
+						source_url: z.ZodURL;
+						observed_at: z.ZodISODateTime;
+						supplier_availability: z.ZodString;
+						categories: z.ZodArray<z.ZodString>;
+					}, z.core.$strict>
+				], "kind">>;
+			}, z.core.$strict>>;
+			next_cursor: z.ZodNullable<z.ZodString>;
+		}, z.core.$strict>;
+		annotations: {
+			readOnlyHint: boolean;
+			destructiveHint: boolean;
+			idempotentHint: boolean;
+			openWorldHint: boolean;
+		};
+	};
+	readonly inspect_tool: {
+		lane?: "read" | "write" | "admin" | "financial" | "provisioning" | "destructive";
+		path: string;
+		title: string;
+		description: string;
+		scope: string | null;
+		input: z.ZodObject<{
+			tool_id: z.ZodString;
+			version: z.ZodOptional<z.ZodString>;
+		}, z.core.$strict>;
+		output: z.ZodObject<{
+			id: z.ZodString;
+			version: z.ZodString;
+			title: z.ZodString;
+			description: z.ZodString;
+			risk: z.ZodEnum<{
+				read: "read";
+				write: "write";
+				admin: "admin";
+				financial: "financial";
+				provisioning: "provisioning";
+				destructive: "destructive";
+			}>;
+			certification: z.ZodEnum<{
+				discovered: "discovered";
+				reviewed: "reviewed";
+				contract_tested: "contract_tested";
+				enabled: "enabled";
+				quarantined: "quarantined";
+			}>;
+			readiness: z.ZodObject<{
+				state: z.ZodEnum<{
+					approval_required: "approval_required";
+					payment_required: "payment_required";
+					ready: "ready";
+					unavailable: "unavailable";
+					connection_required: "connection_required";
+					scope_required: "scope_required";
+					owner_action_required: "owner_action_required";
+					restricted: "restricted";
+				}>;
+				reason: z.ZodString;
+			}, z.core.$strict>;
+			catalogue: z.ZodOptional<z.ZodDiscriminatedUnion<[
+				z.ZodObject<{
+					kind: z.ZodLiteral<"toolkit">;
+					supplier: z.ZodLiteral<"composio">;
+					slug: z.ZodString;
+					source_url: z.ZodURL;
+					managed_oauth: z.ZodNullable<z.ZodBoolean>;
+					instant_tools: z.ZodNullable<z.ZodBoolean>;
+					no_auth: z.ZodNullable<z.ZodBoolean>;
+					tools_count: z.ZodNumber;
+				}, z.core.$strict>,
+				z.ZodObject<{
+					kind: z.ZodLiteral<"tool">;
+					supplier: z.ZodLiteral<"composio">;
+					slug: z.ZodString;
+					source_url: z.ZodURL;
+					instant_tool: z.ZodBoolean;
+					no_auth: z.ZodNullable<z.ZodBoolean>;
+				}, z.core.$strict>,
+				z.ZodObject<{
+					kind: z.ZodLiteral<"provider">;
+					supplier: z.ZodLiteral<"projects">;
+					slug: z.ZodString;
+					source_url: z.ZodURL;
+					observed_at: z.ZodISODateTime;
+					native_reference: z.ZodString;
+					categories: z.ZodArray<z.ZodString>;
+				}, z.core.$strict>,
+				z.ZodObject<{
+					kind: z.ZodLiteral<"service">;
+					supplier: z.ZodLiteral<"projects">;
+					provider_id: z.ZodString;
+					service_id: z.ZodString;
+					source_url: z.ZodURL;
+					observed_at: z.ZodISODateTime;
+					supplier_availability: z.ZodString;
+					categories: z.ZodArray<z.ZodString>;
+				}, z.core.$strict>
+			], "kind">>;
+			input_schema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+			output_schema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+			supplier_details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+		}, z.core.$strict>;
+		annotations: {
+			readOnlyHint: boolean;
+			destructiveHint: boolean;
+			idempotentHint: boolean;
+			openWorldHint: boolean;
+		};
+	};
+	readonly start_connection: {
+		lane?: "read" | "write" | "admin" | "financial" | "provisioning" | "destructive";
+		path: string;
+		title: string;
+		description: string;
+		scope: string | null;
+		input: z.ZodObject<{
+			toolkit: z.ZodString;
+			operation_id: z.ZodString;
+			connection_route: z.ZodOptional<z.ZodLiteral<"managed">>;
+		}, z.core.$strict>;
+		output: z.ZodObject<{
+			connection_id: z.ZodString;
+			state: z.ZodLiteral<"pending">;
+			handoff_url: z.ZodURL;
+			expires_at: z.ZodISODateTime;
+		}, z.core.$strict>;
+		annotations: {
+			readOnlyHint: boolean;
+			destructiveHint: boolean;
+			idempotentHint: boolean;
+			openWorldHint: boolean;
+		};
+	};
+	readonly connection_status: {
+		lane?: "read" | "write" | "admin" | "financial" | "provisioning" | "destructive";
+		path: string;
+		title: string;
+		description: string;
+		scope: string | null;
+		input: z.ZodObject<{
+			toolkit: z.ZodOptional<z.ZodString>;
+			connection_id: z.ZodOptional<z.ZodString>;
+			connection_route: z.ZodOptional<z.ZodLiteral<"managed">>;
+		}, z.core.$strict>;
+		output: z.ZodObject<{
+			connections: z.ZodArray<z.ZodObject<{
+				id: z.ZodString;
+				toolkit: z.ZodString;
+				label: z.ZodString;
+				execution_version: z.ZodOptional<z.ZodString>;
+				consent_expires_at: z.ZodOptional<z.ZodISODateTime>;
+				disconnect_state: z.ZodOptional<z.ZodEnum<{
+					claimed: "claimed";
+					succeeded: "succeeded";
+					unknown_outcome: "unknown_outcome";
+				}>>;
+				state: z.ZodEnum<{
+					pending: "pending";
+					ready: "ready";
+					unavailable: "unavailable";
+					scope_required: "scope_required";
+					revoked: "revoked";
+				}>;
+			}, z.core.$strict>>;
+		}, z.core.$strict>;
+		annotations: {
+			readOnlyHint: boolean;
+			destructiveHint: boolean;
+			idempotentHint: boolean;
+			openWorldHint: boolean;
+		};
+	};
+	readonly plan_action: {
+		lane?: "read" | "write" | "admin" | "financial" | "provisioning" | "destructive";
+		path: string;
+		title: string;
+		description: string;
+		scope: string | null;
+		input: z.ZodObject<{
+			tool_id: z.ZodString;
+			version: z.ZodString;
+			arguments: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+			connection_id: z.ZodOptional<z.ZodString>;
+			audience: z.ZodString;
+			operation_id: z.ZodString;
+			funding: z.ZodOptional<z.ZodObject<{
+				resource_id: z.ZodString;
+				mode: z.ZodEnum<{
+					customer_funded: "customer_funded";
+					muxo_funded: "muxo_funded";
+				}>;
+			}, z.core.$strict>>;
+		}, z.core.$strict>;
+		output: z.ZodObject<{
+			plan_id: z.ZodString;
+			tool_id: z.ZodString;
+			version: z.ZodString;
+			risk: z.ZodEnum<{
+				read: "read";
+				write: "write";
+				admin: "admin";
+				financial: "financial";
+				provisioning: "provisioning";
+				destructive: "destructive";
+			}>;
+			readiness: z.ZodObject<{
+				state: z.ZodEnum<{
+					approval_required: "approval_required";
+					payment_required: "payment_required";
+					ready: "ready";
+					unavailable: "unavailable";
+					connection_required: "connection_required";
+					scope_required: "scope_required";
+					owner_action_required: "owner_action_required";
+					restricted: "restricted";
+				}>;
+				reason: z.ZodString;
+			}, z.core.$strict>;
+			expires_at: z.ZodISODateTime;
+			cost: z.ZodObject<{
+				supplier_units: z.ZodNullable<z.ZodNumber>;
+				supplier_unit: z.ZodNullable<z.ZodString>;
+				supplier_cash_minor: z.ZodNullable<z.ZodNumber>;
+				muxo_cash_minor: z.ZodNullable<z.ZodNumber>;
+				currency: z.ZodNullable<z.ZodString>;
+				treatment: z.ZodEnum<{
+					included: "included";
+					external_provider: "external_provider";
+					muxo_tool_usage: "muxo_tool_usage";
+					muxo_resource: "muxo_resource";
+					muxo_provisioning: "muxo_provisioning";
+					muxo_internal: "muxo_internal";
+					unresolved: "unresolved";
+				}>;
+				funding_mode: z.ZodOptional<z.ZodEnum<{
+					customer_funded: "customer_funded";
+					muxo_funded: "muxo_funded";
+				}>>;
+			}, z.core.$strict>;
+			approval_url: z.ZodNullable<z.ZodURL>;
+			payment: z.ZodOptional<z.ZodObject<{
+				state: z.ZodEnum<{
+					approval_required: "approval_required";
+					payment_required: "payment_required";
+					checkout_pending: "checkout_pending";
+					checkout_uncertain: "checkout_uncertain";
+					payment_processing: "payment_processing";
+					payment_failed: "payment_failed";
+					funded: "funded";
+					suspended: "suspended";
+				}>;
+				amount_minor: z.ZodNumber;
+				currency: z.ZodLiteral<"USD">;
+				handoff_url: z.ZodNullable<z.ZodURL>;
+				supplier_ready: z.ZodBoolean;
+				automatic_recharge: z.ZodLiteral<false>;
+				refund: z.ZodOptional<z.ZodObject<{
+					treatment: z.ZodLiteral<"automatic_whole_cent_fractional_manual">;
+					recorded_at: z.ZodISODateTime;
+					state: z.ZodEnum<{
+						claimed: "claimed";
+						uncertain: "uncertain";
+						blocked: "blocked";
+						not_needed: "not_needed";
+						fractional_only: "fractional_only";
+						pending: "pending";
+						requires_action: "requires_action";
+						succeeded: "succeeded";
+						failed: "failed";
+						canceled: "canceled";
+					}>;
+					refund_amount_minor: z.ZodNumber;
+					refunded_minor: z.ZodNumber;
+					refund_due_usd_24: z.ZodString;
+					fractional_refund_due_usd_24: z.ZodString;
+					reconciliation_required: z.ZodBoolean;
+					automatic_retry: z.ZodLiteral<false>;
+				}, z.core.$strict>>;
+			}, z.core.$strict>>;
+			credits: z.ZodOptional<z.ZodObject<{
+				treatment: z.ZodEnum<{
+					subscription_credits: "subscription_credits";
+					usage_credits: "usage_credits";
+				}>;
+				maximum_usd_24: z.ZodString;
+				maximum_credits: z.ZodString;
+				usd_per_credit: z.ZodLiteral<"0.01">;
+				rate_hash: z.ZodString;
+				terms_hash: z.ZodString;
+				automatic_overages: z.ZodLiteral<false>;
+				automatic_topups: z.ZodLiteral<false>;
+			}, z.core.$strict>>;
+			intent_hash: z.ZodOptional<z.ZodString>;
+		}, z.core.$strict>;
+		annotations: {
+			readOnlyHint: boolean;
+			destructiveHint: boolean;
+			idempotentHint: boolean;
+			openWorldHint: boolean;
+		};
+	};
+	readonly get_plan: {
+		lane?: "read" | "write" | "admin" | "financial" | "provisioning" | "destructive";
+		path: string;
+		title: string;
+		description: string;
+		scope: string | null;
+		input: z.ZodObject<{
+			plan_id: z.ZodString;
+		}, z.core.$strict>;
+		output: z.ZodObject<{
+			plan: z.ZodObject<{
+				plan_id: z.ZodString;
+				tool_id: z.ZodString;
+				version: z.ZodString;
+				risk: z.ZodEnum<{
+					read: "read";
+					write: "write";
+					admin: "admin";
+					financial: "financial";
+					provisioning: "provisioning";
+					destructive: "destructive";
+				}>;
+				readiness: z.ZodObject<{
+					state: z.ZodEnum<{
+						approval_required: "approval_required";
+						payment_required: "payment_required";
+						ready: "ready";
+						unavailable: "unavailable";
+						connection_required: "connection_required";
+						scope_required: "scope_required";
+						owner_action_required: "owner_action_required";
+						restricted: "restricted";
+					}>;
+					reason: z.ZodString;
+				}, z.core.$strict>;
+				expires_at: z.ZodISODateTime;
+				cost: z.ZodObject<{
+					supplier_units: z.ZodNullable<z.ZodNumber>;
+					supplier_unit: z.ZodNullable<z.ZodString>;
+					supplier_cash_minor: z.ZodNullable<z.ZodNumber>;
+					muxo_cash_minor: z.ZodNullable<z.ZodNumber>;
+					currency: z.ZodNullable<z.ZodString>;
+					treatment: z.ZodEnum<{
+						included: "included";
+						external_provider: "external_provider";
+						muxo_tool_usage: "muxo_tool_usage";
+						muxo_resource: "muxo_resource";
+						muxo_provisioning: "muxo_provisioning";
+						muxo_internal: "muxo_internal";
+						unresolved: "unresolved";
+					}>;
+					funding_mode: z.ZodOptional<z.ZodEnum<{
+						customer_funded: "customer_funded";
+						muxo_funded: "muxo_funded";
+					}>>;
+				}, z.core.$strict>;
+				approval_url: z.ZodNullable<z.ZodURL>;
+				payment: z.ZodOptional<z.ZodObject<{
+					state: z.ZodEnum<{
+						approval_required: "approval_required";
+						payment_required: "payment_required";
+						checkout_pending: "checkout_pending";
+						checkout_uncertain: "checkout_uncertain";
+						payment_processing: "payment_processing";
+						payment_failed: "payment_failed";
+						funded: "funded";
+						suspended: "suspended";
+					}>;
+					amount_minor: z.ZodNumber;
+					currency: z.ZodLiteral<"USD">;
+					handoff_url: z.ZodNullable<z.ZodURL>;
+					supplier_ready: z.ZodBoolean;
+					automatic_recharge: z.ZodLiteral<false>;
+					refund: z.ZodOptional<z.ZodObject<{
+						treatment: z.ZodLiteral<"automatic_whole_cent_fractional_manual">;
+						recorded_at: z.ZodISODateTime;
+						state: z.ZodEnum<{
+							claimed: "claimed";
+							uncertain: "uncertain";
+							blocked: "blocked";
+							not_needed: "not_needed";
+							fractional_only: "fractional_only";
+							pending: "pending";
+							requires_action: "requires_action";
+							succeeded: "succeeded";
+							failed: "failed";
+							canceled: "canceled";
+						}>;
+						refund_amount_minor: z.ZodNumber;
+						refunded_minor: z.ZodNumber;
+						refund_due_usd_24: z.ZodString;
+						fractional_refund_due_usd_24: z.ZodString;
+						reconciliation_required: z.ZodBoolean;
+						automatic_retry: z.ZodLiteral<false>;
+					}, z.core.$strict>>;
+				}, z.core.$strict>>;
+				credits: z.ZodOptional<z.ZodObject<{
+					treatment: z.ZodEnum<{
+						subscription_credits: "subscription_credits";
+						usage_credits: "usage_credits";
+					}>;
+					maximum_usd_24: z.ZodString;
+					maximum_credits: z.ZodString;
+					usd_per_credit: z.ZodLiteral<"0.01">;
+					rate_hash: z.ZodString;
+					terms_hash: z.ZodString;
+					automatic_overages: z.ZodLiteral<false>;
+					automatic_topups: z.ZodLiteral<false>;
+				}, z.core.$strict>>;
+				intent_hash: z.ZodOptional<z.ZodString>;
+			}, z.core.$strict>;
+			arguments: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+			approved: z.ZodBoolean;
+			run_id: z.ZodNullable<z.ZodString>;
+			next_action: z.ZodEnum<{
+				payment_required: "payment_required";
+				expired: "expired";
+				unavailable: "unavailable";
+				human_approval_required: "human_approval_required";
+				supplier_funding_required: "supplier_funding_required";
+				execute_read: "execute_read";
+				execute_write: "execute_write";
+				execute_admin: "execute_admin";
+				execute_financial: "execute_financial";
+				execute_provisioning: "execute_provisioning";
+				execute_destructive: "execute_destructive";
+				inspect_run: "inspect_run";
+			}>;
+			automatic_retry: z.ZodLiteral<false>;
+		}, z.core.$strict>;
+		annotations: {
+			readOnlyHint: boolean;
+			destructiveHint: boolean;
+			idempotentHint: boolean;
+			openWorldHint: boolean;
+		};
+	};
+	readonly get_run_context: {
+		lane?: "read" | "write" | "admin" | "financial" | "provisioning" | "destructive";
+		path: string;
+		title: string;
+		description: string;
+		scope: string | null;
+		input: z.ZodObject<{
+			run_id: z.ZodString;
+			max_bytes: z.ZodDefault<z.ZodNumber>;
+			audience: z.ZodDefault<z.ZodLiteral<"private">>;
+		}, z.core.$strict>;
+		output: z.ZodObject<{
+			state: z.ZodEnum<{
+				ready: "ready";
+				partial: "partial";
+				expired: "expired";
+				unavailable: "unavailable";
+			}>;
+			packet: z.ZodNullable<z.ZodObject<{
+				kind: z.ZodLiteral<"untrusted_run_context">;
+				run_id: z.ZodString;
+				receipt_id: z.ZodNullable<z.ZodString>;
+				tool_id: z.ZodString;
+				version: z.ZodString;
+				generated_at: z.ZodISODateTime;
+				expires_at: z.ZodNullable<z.ZodISODateTime>;
+				audience: z.ZodLiteral<"private">;
+				items: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+				coverage: z.ZodObject<{
+					available: z.ZodNumber;
+					included: z.ZodNumber;
+					omitted: z.ZodNumber;
+				}, z.core.$strict>;
+				notes: z.ZodArray<z.ZodString>;
+			}, z.core.$strict>>;
+			bytes: z.ZodNumber;
+			persisted: z.ZodLiteral<false>;
+			supplier_calls: z.ZodLiteral<0>;
+		}, z.core.$strict>;
+		annotations: {
+			readOnlyHint: boolean;
+			destructiveHint: boolean;
+			idempotentHint: boolean;
+			openWorldHint: boolean;
+		};
+	};
+	readonly execute_read: {
+		annotations: {
+			idempotentHint: boolean;
+			readOnlyHint: boolean;
+			destructiveHint: boolean;
+			openWorldHint: boolean;
+		};
+		lane?: "read" | "write" | "admin" | "financial" | "provisioning" | "destructive";
+		path: string;
+		title: string;
+		description: string;
+		scope: string | null;
+		input: z.ZodObject<{
+			plan_id: z.ZodString;
+			operation_id: z.ZodString;
+		}, z.core.$strict>;
+		output: z.ZodObject<{
+			run_id: z.ZodString;
+			state: z.ZodEnum<{
+				succeeded: "succeeded";
+				failed: "failed";
+				unknown_outcome: "unknown_outcome";
+				planned: "planned";
+				waiting_for_user: "waiting_for_user";
+				awaiting_approval: "awaiting_approval";
+				reserved: "reserved";
+				running: "running";
+				cancelled: "cancelled";
+				partially_completed: "partially_completed";
+			}>;
+			receipt_id: z.ZodNullable<z.ZodString>;
+			result: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+			sources: z.ZodArray<z.ZodObject<{
+				id: z.ZodString;
+				url: z.ZodURL;
+				title: z.ZodString;
+			}, z.core.$strict>>;
+			cost: z.ZodNullable<z.ZodObject<{
+				supplier_units: z.ZodNullable<z.ZodNumber>;
+				supplier_unit: z.ZodNullable<z.ZodString>;
+				supplier_cash_minor: z.ZodNullable<z.ZodNumber>;
+				muxo_cash_minor: z.ZodNullable<z.ZodNumber>;
+				currency: z.ZodNullable<z.ZodString>;
+				treatment: z.ZodEnum<{
+					included: "included";
+					external_provider: "external_provider";
+					muxo_tool_usage: "muxo_tool_usage";
+					muxo_resource: "muxo_resource";
+					muxo_provisioning: "muxo_provisioning";
+					muxo_internal: "muxo_internal";
+					unresolved: "unresolved";
+				}>;
+				funding_mode: z.ZodOptional<z.ZodEnum<{
+					customer_funded: "customer_funded";
+					muxo_funded: "muxo_funded";
+				}>>;
+			}, z.core.$strict>>;
+		}, z.core.$strict>;
+	};
+	readonly execute_write: {
+		annotations: {
+			idempotentHint: boolean;
+			readOnlyHint: boolean;
+			destructiveHint: boolean;
+			openWorldHint: boolean;
+		};
+		lane?: "read" | "write" | "admin" | "financial" | "provisioning" | "destructive";
+		path: string;
+		title: string;
+		description: string;
+		scope: string | null;
+		input: z.ZodObject<{
+			plan_id: z.ZodString;
+			operation_id: z.ZodString;
+		}, z.core.$strict>;
+		output: z.ZodObject<{
+			run_id: z.ZodString;
+			state: z.ZodEnum<{
+				succeeded: "succeeded";
+				failed: "failed";
+				unknown_outcome: "unknown_outcome";
+				planned: "planned";
+				waiting_for_user: "waiting_for_user";
+				awaiting_approval: "awaiting_approval";
+				reserved: "reserved";
+				running: "running";
+				cancelled: "cancelled";
+				partially_completed: "partially_completed";
+			}>;
+			receipt_id: z.ZodNullable<z.ZodString>;
+			result: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+			sources: z.ZodArray<z.ZodObject<{
+				id: z.ZodString;
+				url: z.ZodURL;
+				title: z.ZodString;
+			}, z.core.$strict>>;
+			cost: z.ZodNullable<z.ZodObject<{
+				supplier_units: z.ZodNullable<z.ZodNumber>;
+				supplier_unit: z.ZodNullable<z.ZodString>;
+				supplier_cash_minor: z.ZodNullable<z.ZodNumber>;
+				muxo_cash_minor: z.ZodNullable<z.ZodNumber>;
+				currency: z.ZodNullable<z.ZodString>;
+				treatment: z.ZodEnum<{
+					included: "included";
+					external_provider: "external_provider";
+					muxo_tool_usage: "muxo_tool_usage";
+					muxo_resource: "muxo_resource";
+					muxo_provisioning: "muxo_provisioning";
+					muxo_internal: "muxo_internal";
+					unresolved: "unresolved";
+				}>;
+				funding_mode: z.ZodOptional<z.ZodEnum<{
+					customer_funded: "customer_funded";
+					muxo_funded: "muxo_funded";
+				}>>;
+			}, z.core.$strict>>;
+		}, z.core.$strict>;
+	};
+	readonly execute_admin: {
+		annotations: {
+			idempotentHint: boolean;
+			readOnlyHint: boolean;
+			destructiveHint: boolean;
+			openWorldHint: boolean;
+		};
+		lane?: "read" | "write" | "admin" | "financial" | "provisioning" | "destructive";
+		path: string;
+		title: string;
+		description: string;
+		scope: string | null;
+		input: z.ZodObject<{
+			plan_id: z.ZodString;
+			operation_id: z.ZodString;
+		}, z.core.$strict>;
+		output: z.ZodObject<{
+			run_id: z.ZodString;
+			state: z.ZodEnum<{
+				succeeded: "succeeded";
+				failed: "failed";
+				unknown_outcome: "unknown_outcome";
+				planned: "planned";
+				waiting_for_user: "waiting_for_user";
+				awaiting_approval: "awaiting_approval";
+				reserved: "reserved";
+				running: "running";
+				cancelled: "cancelled";
+				partially_completed: "partially_completed";
+			}>;
+			receipt_id: z.ZodNullable<z.ZodString>;
+			result: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+			sources: z.ZodArray<z.ZodObject<{
+				id: z.ZodString;
+				url: z.ZodURL;
+				title: z.ZodString;
+			}, z.core.$strict>>;
+			cost: z.ZodNullable<z.ZodObject<{
+				supplier_units: z.ZodNullable<z.ZodNumber>;
+				supplier_unit: z.ZodNullable<z.ZodString>;
+				supplier_cash_minor: z.ZodNullable<z.ZodNumber>;
+				muxo_cash_minor: z.ZodNullable<z.ZodNumber>;
+				currency: z.ZodNullable<z.ZodString>;
+				treatment: z.ZodEnum<{
+					included: "included";
+					external_provider: "external_provider";
+					muxo_tool_usage: "muxo_tool_usage";
+					muxo_resource: "muxo_resource";
+					muxo_provisioning: "muxo_provisioning";
+					muxo_internal: "muxo_internal";
+					unresolved: "unresolved";
+				}>;
+				funding_mode: z.ZodOptional<z.ZodEnum<{
+					customer_funded: "customer_funded";
+					muxo_funded: "muxo_funded";
+				}>>;
+			}, z.core.$strict>>;
+		}, z.core.$strict>;
+	};
+	readonly execute_financial: {
+		annotations: {
+			idempotentHint: boolean;
+			readOnlyHint: boolean;
+			destructiveHint: boolean;
+			openWorldHint: boolean;
+		};
+		lane?: "read" | "write" | "admin" | "financial" | "provisioning" | "destructive";
+		path: string;
+		title: string;
+		description: string;
+		scope: string | null;
+		input: z.ZodObject<{
+			plan_id: z.ZodString;
+			operation_id: z.ZodString;
+		}, z.core.$strict>;
+		output: z.ZodObject<{
+			run_id: z.ZodString;
+			state: z.ZodEnum<{
+				succeeded: "succeeded";
+				failed: "failed";
+				unknown_outcome: "unknown_outcome";
+				planned: "planned";
+				waiting_for_user: "waiting_for_user";
+				awaiting_approval: "awaiting_approval";
+				reserved: "reserved";
+				running: "running";
+				cancelled: "cancelled";
+				partially_completed: "partially_completed";
+			}>;
+			receipt_id: z.ZodNullable<z.ZodString>;
+			result: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+			sources: z.ZodArray<z.ZodObject<{
+				id: z.ZodString;
+				url: z.ZodURL;
+				title: z.ZodString;
+			}, z.core.$strict>>;
+			cost: z.ZodNullable<z.ZodObject<{
+				supplier_units: z.ZodNullable<z.ZodNumber>;
+				supplier_unit: z.ZodNullable<z.ZodString>;
+				supplier_cash_minor: z.ZodNullable<z.ZodNumber>;
+				muxo_cash_minor: z.ZodNullable<z.ZodNumber>;
+				currency: z.ZodNullable<z.ZodString>;
+				treatment: z.ZodEnum<{
+					included: "included";
+					external_provider: "external_provider";
+					muxo_tool_usage: "muxo_tool_usage";
+					muxo_resource: "muxo_resource";
+					muxo_provisioning: "muxo_provisioning";
+					muxo_internal: "muxo_internal";
+					unresolved: "unresolved";
+				}>;
+				funding_mode: z.ZodOptional<z.ZodEnum<{
+					customer_funded: "customer_funded";
+					muxo_funded: "muxo_funded";
+				}>>;
+			}, z.core.$strict>>;
+		}, z.core.$strict>;
+	};
+	readonly execute_provisioning: {
+		annotations: {
+			idempotentHint: boolean;
+			readOnlyHint: boolean;
+			destructiveHint: boolean;
+			openWorldHint: boolean;
+		};
+		lane?: "read" | "write" | "admin" | "financial" | "provisioning" | "destructive";
+		path: string;
+		title: string;
+		description: string;
+		scope: string | null;
+		input: z.ZodObject<{
+			plan_id: z.ZodString;
+			operation_id: z.ZodString;
+		}, z.core.$strict>;
+		output: z.ZodObject<{
+			run_id: z.ZodString;
+			state: z.ZodEnum<{
+				succeeded: "succeeded";
+				failed: "failed";
+				unknown_outcome: "unknown_outcome";
+				planned: "planned";
+				waiting_for_user: "waiting_for_user";
+				awaiting_approval: "awaiting_approval";
+				reserved: "reserved";
+				running: "running";
+				cancelled: "cancelled";
+				partially_completed: "partially_completed";
+			}>;
+			receipt_id: z.ZodNullable<z.ZodString>;
+			result: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+			sources: z.ZodArray<z.ZodObject<{
+				id: z.ZodString;
+				url: z.ZodURL;
+				title: z.ZodString;
+			}, z.core.$strict>>;
+			cost: z.ZodNullable<z.ZodObject<{
+				supplier_units: z.ZodNullable<z.ZodNumber>;
+				supplier_unit: z.ZodNullable<z.ZodString>;
+				supplier_cash_minor: z.ZodNullable<z.ZodNumber>;
+				muxo_cash_minor: z.ZodNullable<z.ZodNumber>;
+				currency: z.ZodNullable<z.ZodString>;
+				treatment: z.ZodEnum<{
+					included: "included";
+					external_provider: "external_provider";
+					muxo_tool_usage: "muxo_tool_usage";
+					muxo_resource: "muxo_resource";
+					muxo_provisioning: "muxo_provisioning";
+					muxo_internal: "muxo_internal";
+					unresolved: "unresolved";
+				}>;
+				funding_mode: z.ZodOptional<z.ZodEnum<{
+					customer_funded: "customer_funded";
+					muxo_funded: "muxo_funded";
+				}>>;
+			}, z.core.$strict>>;
+		}, z.core.$strict>;
+	};
+	readonly execute_destructive: {
+		annotations: {
+			idempotentHint: boolean;
+			readOnlyHint: boolean;
+			destructiveHint: boolean;
+			openWorldHint: boolean;
+		};
+		lane?: "read" | "write" | "admin" | "financial" | "provisioning" | "destructive";
+		path: string;
+		title: string;
+		description: string;
+		scope: string | null;
+		input: z.ZodObject<{
+			plan_id: z.ZodString;
+			operation_id: z.ZodString;
+		}, z.core.$strict>;
+		output: z.ZodObject<{
+			run_id: z.ZodString;
+			state: z.ZodEnum<{
+				succeeded: "succeeded";
+				failed: "failed";
+				unknown_outcome: "unknown_outcome";
+				planned: "planned";
+				waiting_for_user: "waiting_for_user";
+				awaiting_approval: "awaiting_approval";
+				reserved: "reserved";
+				running: "running";
+				cancelled: "cancelled";
+				partially_completed: "partially_completed";
+			}>;
+			receipt_id: z.ZodNullable<z.ZodString>;
+			result: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+			sources: z.ZodArray<z.ZodObject<{
+				id: z.ZodString;
+				url: z.ZodURL;
+				title: z.ZodString;
+			}, z.core.$strict>>;
+			cost: z.ZodNullable<z.ZodObject<{
+				supplier_units: z.ZodNullable<z.ZodNumber>;
+				supplier_unit: z.ZodNullable<z.ZodString>;
+				supplier_cash_minor: z.ZodNullable<z.ZodNumber>;
+				muxo_cash_minor: z.ZodNullable<z.ZodNumber>;
+				currency: z.ZodNullable<z.ZodString>;
+				treatment: z.ZodEnum<{
+					included: "included";
+					external_provider: "external_provider";
+					muxo_tool_usage: "muxo_tool_usage";
+					muxo_resource: "muxo_resource";
+					muxo_provisioning: "muxo_provisioning";
+					muxo_internal: "muxo_internal";
+					unresolved: "unresolved";
+				}>;
+				funding_mode: z.ZodOptional<z.ZodEnum<{
+					customer_funded: "customer_funded";
+					muxo_funded: "muxo_funded";
+				}>>;
+			}, z.core.$strict>>;
+		}, z.core.$strict>;
+	};
+	readonly get_run: {
+		lane?: "read" | "write" | "admin" | "financial" | "provisioning" | "destructive";
+		path: string;
+		title: string;
+		description: string;
+		scope: string | null;
+		input: z.ZodObject<{
+			run_id: z.ZodString;
+		}, z.core.$strict>;
+		output: z.ZodObject<{
+			run_id: z.ZodString;
+			state: z.ZodEnum<{
+				succeeded: "succeeded";
+				failed: "failed";
+				unknown_outcome: "unknown_outcome";
+				planned: "planned";
+				waiting_for_user: "waiting_for_user";
+				awaiting_approval: "awaiting_approval";
+				reserved: "reserved";
+				running: "running";
+				cancelled: "cancelled";
+				partially_completed: "partially_completed";
+			}>;
+			receipt_id: z.ZodNullable<z.ZodString>;
+			result: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+			sources: z.ZodArray<z.ZodObject<{
+				id: z.ZodString;
+				url: z.ZodURL;
+				title: z.ZodString;
+			}, z.core.$strict>>;
+			cost: z.ZodNullable<z.ZodObject<{
+				supplier_units: z.ZodNullable<z.ZodNumber>;
+				supplier_unit: z.ZodNullable<z.ZodString>;
+				supplier_cash_minor: z.ZodNullable<z.ZodNumber>;
+				muxo_cash_minor: z.ZodNullable<z.ZodNumber>;
+				currency: z.ZodNullable<z.ZodString>;
+				treatment: z.ZodEnum<{
+					included: "included";
+					external_provider: "external_provider";
+					muxo_tool_usage: "muxo_tool_usage";
+					muxo_resource: "muxo_resource";
+					muxo_provisioning: "muxo_provisioning";
+					muxo_internal: "muxo_internal";
+					unresolved: "unresolved";
+				}>;
+				funding_mode: z.ZodOptional<z.ZodEnum<{
+					customer_funded: "customer_funded";
+					muxo_funded: "muxo_funded";
+				}>>;
+			}, z.core.$strict>>;
+		}, z.core.$strict>;
+		annotations: {
+			readOnlyHint: boolean;
+			destructiveHint: boolean;
+			idempotentHint: boolean;
+			openWorldHint: boolean;
+		};
+	};
+	readonly cancel_run: {
+		lane?: "read" | "write" | "admin" | "financial" | "provisioning" | "destructive";
+		path: string;
+		title: string;
+		description: string;
+		scope: string | null;
+		input: z.ZodObject<{
+			run_id: z.ZodString;
+			operation_id: z.ZodString;
+		}, z.core.$strict>;
+		output: z.ZodObject<{
+			run_id: z.ZodString;
+			state: z.ZodEnum<{
+				succeeded: "succeeded";
+				failed: "failed";
+				unknown_outcome: "unknown_outcome";
+				planned: "planned";
+				waiting_for_user: "waiting_for_user";
+				awaiting_approval: "awaiting_approval";
+				reserved: "reserved";
+				running: "running";
+				cancelled: "cancelled";
+				partially_completed: "partially_completed";
+			}>;
+			receipt_id: z.ZodNullable<z.ZodString>;
+			result: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+			sources: z.ZodArray<z.ZodObject<{
+				id: z.ZodString;
+				url: z.ZodURL;
+				title: z.ZodString;
+			}, z.core.$strict>>;
+			cost: z.ZodNullable<z.ZodObject<{
+				supplier_units: z.ZodNullable<z.ZodNumber>;
+				supplier_unit: z.ZodNullable<z.ZodString>;
+				supplier_cash_minor: z.ZodNullable<z.ZodNumber>;
+				muxo_cash_minor: z.ZodNullable<z.ZodNumber>;
+				currency: z.ZodNullable<z.ZodString>;
+				treatment: z.ZodEnum<{
+					included: "included";
+					external_provider: "external_provider";
+					muxo_tool_usage: "muxo_tool_usage";
+					muxo_resource: "muxo_resource";
+					muxo_provisioning: "muxo_provisioning";
+					muxo_internal: "muxo_internal";
+					unresolved: "unresolved";
+				}>;
+				funding_mode: z.ZodOptional<z.ZodEnum<{
+					customer_funded: "customer_funded";
+					muxo_funded: "muxo_funded";
+				}>>;
+			}, z.core.$strict>>;
+		}, z.core.$strict>;
+		annotations: {
+			readOnlyHint: boolean;
+			destructiveHint: boolean;
+			idempotentHint: boolean;
+			openWorldHint: boolean;
+		};
+	};
+	readonly get_receipt: {
+		lane?: "read" | "write" | "admin" | "financial" | "provisioning" | "destructive";
+		path: string;
+		title: string;
+		description: string;
+		scope: string | null;
+		input: z.ZodObject<{
+			receipt_id: z.ZodString;
+		}, z.core.$strict>;
+		output: z.ZodObject<{
+			receipt_id: z.ZodString;
+			run_id: z.ZodString;
+			tool_id: z.ZodString;
+			version: z.ZodString;
+			outcome: z.ZodEnum<{
+				succeeded: "succeeded";
+				failed: "failed";
+				unknown_outcome: "unknown_outcome";
+				cancelled: "cancelled";
+				partially_completed: "partially_completed";
+			}>;
+			cost: z.ZodObject<{
+				supplier_units: z.ZodNullable<z.ZodNumber>;
+				supplier_unit: z.ZodNullable<z.ZodString>;
+				supplier_cash_minor: z.ZodNullable<z.ZodNumber>;
+				muxo_cash_minor: z.ZodNullable<z.ZodNumber>;
+				currency: z.ZodNullable<z.ZodString>;
+				treatment: z.ZodEnum<{
+					included: "included";
+					external_provider: "external_provider";
+					muxo_tool_usage: "muxo_tool_usage";
+					muxo_resource: "muxo_resource";
+					muxo_provisioning: "muxo_provisioning";
+					muxo_internal: "muxo_internal";
+					unresolved: "unresolved";
+				}>;
+				funding_mode: z.ZodOptional<z.ZodEnum<{
+					customer_funded: "customer_funded";
+					muxo_funded: "muxo_funded";
+				}>>;
+			}, z.core.$strict>;
+			recorded_at: z.ZodISODateTime;
+			native: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+		}, z.core.$strict>;
+		annotations: {
+			readOnlyHint: boolean;
+			destructiveHint: boolean;
+			idempotentHint: boolean;
+			openWorldHint: boolean;
+		};
+	};
+};
+export type OperationName = keyof typeof operations;
+export type OperationInput<N extends OperationName> = z.input<(typeof operations)[N]["input"]>;
+export type OperationOutput<N extends OperationName> = z.output<(typeof operations)[N]["output"]>;
+declare const errorCodeSchema: z.ZodEnum<{
+	approval_required: "approval_required";
+	payment_required: "payment_required";
+	unknown_outcome: "unknown_outcome";
+	supplier_funding_required: "supplier_funding_required";
+	unauthenticated: "unauthenticated";
+	insufficient_scope: "insufficient_scope";
+	forbidden: "forbidden";
+	invalid_input: "invalid_input";
+	not_found: "not_found";
+	not_configured: "not_configured";
+	conflict: "conflict";
+	budget_exceeded: "budget_exceeded";
+	rate_limited: "rate_limited";
+	internal: "internal";
+}>;
+type ErrorCode = z.infer<typeof errorCodeSchema>;
+export type SurfaceResult<T = unknown> = {
+	ok: true;
+	data: T;
+} | {
+	ok: false;
+	error: {
+		code: ErrorCode;
+		message: string;
+	};
+};
+declare const workspaceCommand: z.ZodObject<{
+	operation: z.ZodEnum<{
+		execute_read: "execute_read";
+		execute_write: "execute_write";
+		execute_admin: "execute_admin";
+		execute_financial: "execute_financial";
+		execute_provisioning: "execute_provisioning";
+		execute_destructive: "execute_destructive";
+		get_run: "get_run";
+		get_organization: "get_organization";
+		get_profile: "get_profile";
+		search_tools: "search_tools";
+		inspect_tool: "inspect_tool";
+		start_connection: "start_connection";
+		connection_status: "connection_status";
+		plan_action: "plan_action";
+		get_plan: "get_plan";
+		get_run_context: "get_run_context";
+		cancel_run: "cancel_run";
+		get_receipt: "get_receipt";
+		initialize: "initialize";
+		request_human_handoff: "request_human_handoff";
+		review_human_handoff: "review_human_handoff";
+		confirm_human_handoff: "confirm_human_handoff";
+		human_handoff_receipt: "human_handoff_receipt";
+		review_invitation: "review_invitation";
+		confirm_invitation: "confirm_invitation";
+		snapshot: "snapshot";
+		get_free_plan: "get_free_plan";
+		get_subscription_credits: "get_subscription_credits";
+		get_prepaid_credits: "get_prepaid_credits";
+		plan_prepaid_topup: "plan_prepaid_topup";
+		get_prepaid_plan: "get_prepaid_plan";
+		review_prepaid: "review_prepaid";
+		checkout_prepaid: "checkout_prepaid";
+		plan_subscription: "plan_subscription";
+		get_subscription_plan: "get_subscription_plan";
+		review_subscription: "review_subscription";
+		checkout_subscription: "checkout_subscription";
+		cancel_subscription: "cancel_subscription";
+		invite: "invite";
+		accept: "accept";
+		revoke_invitation: "revoke_invitation";
+		update_member: "update_member";
+		grant_project: "grant_project";
+		share_source: "share_source";
+		register_source: "register_source";
+		register_document: "register_document";
+		inspect_source: "inspect_source";
+		revoke_source: "revoke_source";
+		delegate: "delegate";
+		revoke_delegation: "revoke_delegation";
+		connection_handoff: "connection_handoff";
+		disconnect_connection: "disconnect_connection";
+		review_plan: "review_plan";
+		approve_action: "approve_action";
+		plan_resource: "plan_resource";
+		get_resource_plan: "get_resource_plan";
+		review_resource: "review_resource";
+		approve_resource: "approve_resource";
+		execute_resource: "execute_resource";
+		resource_receipt: "resource_receipt";
+		reconcile_resource: "reconcile_resource";
+		list_resources: "list_resources";
+		resource_runtime: "resource_runtime";
+		register_resource_source: "register_resource_source";
+		memory_consent: "memory_consent";
+		revoke_memory_consent: "revoke_memory_consent";
+		memory_submit: "memory_submit";
+		memory_capture: "memory_capture";
+		memory_approve: "memory_approve";
+		memory_read: "memory_read";
+		memory_search: "memory_search";
+		memory_bootstrap: "memory_bootstrap";
+		memory_navigate: "memory_navigate";
+		memory_retract: "memory_retract";
+		memory_erase: "memory_erase";
+		memory_export: "memory_export";
+		memory_maintain: "memory_maintain";
+		memory_index: "memory_index";
+	}>;
+	arguments: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+}, z.core.$strict>;
+export type WorkspaceCommand = z.input<typeof workspaceCommand>;
+declare const workspaceContextSchema: z.ZodObject<{
+	id: z.ZodString;
+	projectId: z.ZodString;
+}, z.core.$strict>;
+type WorkspaceContext = z.infer<typeof workspaceContextSchema>;
+declare const workspaceOrganizationSchema: z.ZodObject<{
+	version: z.ZodLiteral<"workspace-v2">;
+	organization_id: z.ZodString;
+	project_id: z.ZodString;
+	profile_id: z.ZodString;
+	actor_id: z.ZodString;
+	kind: z.ZodEnum<{
+		service: "service";
+		human: "human";
+	}>;
+	role: z.ZodEnum<{
+		owner: "owner";
+		lead: "lead";
+		member: "member";
+		operator: "operator";
+		billing: "billing";
+	}>;
+	permissions: z.ZodArray<z.ZodEnum<{
+		plan: "plan";
+		resource: "resource";
+		billing: "billing";
+		approve: "approve";
+		memory: "memory";
+	}>>;
+}, z.core.$strict>;
+type WorkspaceOperationOutput<N extends OperationName> = N extends "get_organization" ? z.infer<typeof workspaceOrganizationSchema> : OperationOutput<N>;
+export type ClientErrorCode = "invalid_input" | "invalid_credential" | "transport_error" | "invalid_response" | "timeout" | "cancelled";
+/** Safe to report to a harness. Never retains raw exceptions, arguments, or tokens. */
+export declare class MuxoClientError extends Error {
+	readonly code: ClientErrorCode;
+	readonly operation?: OperationName | undefined;
+	readonly outcomeUnknown: boolean;
+	readonly operationId?: string | undefined;
+	constructor(code: ClientErrorCode, operation?: OperationName | undefined, outcomeUnknown?: boolean, operationId?: string | undefined);
+	toResult(): {
+		ok: false;
+		error: {
+			code: ClientErrorCode;
+			message: string;
+		};
+		recovery: {
+			outcome_unknown: boolean;
+			automatic_retry: false;
+			next_action: string;
+			operation_id?: string;
+			operation?: "execute_read" | "execute_write" | "execute_admin" | "execute_financial" | "execute_provisioning" | "execute_destructive" | "get_run" | "get_organization" | "get_profile" | "search_tools" | "inspect_tool" | "start_connection" | "connection_status" | "plan_action" | "get_plan" | "get_run_context" | "cancel_run" | "get_receipt";
+		};
+	};
 }
-/**
- * Which packet and session a capability call belongs to.
- *
- * Both are optional and advisory: they never change whether a call is allowed,
- * only how well the resulting receipt can be explained afterwards.
- */
-export interface CallBinding {
-    /** The packet whose context grounded this call, from `context.fetch`/`query`. */
-    packetId?: string;
-    /** The session whose context window this call joins. */
-    session?: string;
+export declare class MuxoClient {
+	private readonly options;
+	private readonly baseUrl;
+	private readonly transport;
+	private readonly timeoutMs;
+	readonly workspaceContext: Readonly<WorkspaceContext> | null;
+	constructor(options: {
+		baseUrl: string;
+		/** Resolve a protected OAuth token or scoped server key, never log it. */
+		credential: () => string | Promise<string>;
+		fetch?: typeof fetch;
+		/** Deadline includes credential resolution and response streaming. No retries. */
+		timeoutMs?: number;
+		/** Routing hint only. The server verifies the exact live workspace grant. */
+		workspace?: WorkspaceContext;
+	});
+	/** Explicit tenant address is verified server-side. No retries or human authority substitution. */
+	workspace(id: string, raw: WorkspaceCommand, signal?: AbortSignal): Promise<{
+		ok: true;
+		data: import("zod").JSONType;
+	} | {
+		ok: false;
+		error: {
+			code: string;
+			message: string;
+		};
+	}>;
+	workspaceCall<N extends OperationName>(name: N, input: OperationInput<N>, signal?: AbortSignal): Promise<SurfaceResult<WorkspaceOperationOutput<N>>>;
+	call<N extends OperationName>(name: N, input: OperationInput<N>, signal?: AbortSignal): Promise<SurfaceResult<OperationOutput<N>>>;
 }
-export declare class Muxo {
-    readonly key: string;
-    readonly baseUrl: string;
-    constructor({ key, baseUrl }?: MuxoOptions);
-    private request;
-    /**
-     * Call a capability.
-     *
-     * `packetId` and `session` are Muxo's governance fields, not the capability's
-     * arguments: they label the signed ledger entry and fold the call into a
-     * session's context window, which is what turns a receipt from "what ran"
-     * into "what ran, on what grounding". They are stripped before the input
-     * reaches the provider. Omit them and the call still meters, budgets, and
-     * signs — it is just harder to reconstruct afterwards.
-     */
-    call<T = unknown>(capability: string, input: object, opts?: CallBinding): Promise<Envelope<T>>;
-    search: (input: WebSearchInput) => Promise<Envelope<unknown>>;
-    read_page: (input: WebScrapeInput) => Promise<Envelope<unknown>>;
-    extract: (input: WebExtractInput) => Promise<Envelope<unknown>>;
-    crawl_site: (input: WebCrawlInput) => Promise<Envelope<unknown>>;
-    watch_page: (input: WebMonitorInput) => Promise<Envelope<unknown>>;
-    browse: (input: BrowserDriveInput) => Promise<Envelope<unknown>>;
-    ask_ai: (input: LlmChatInput) => Promise<Envelope<unknown>>;
-    embed: (input: LlmEmbedInput) => Promise<Envelope<unknown>>;
-    say: (input: LlmTtsInput) => Promise<Envelope<unknown>>;
-    make_image: (input: LlmImageInput) => Promise<Envelope<unknown>>;
-    transcribe: (input: LlmSttInput) => Promise<Envelope<unknown>>;
-    run_code: (input: SandboxInput) => Promise<Envelope<unknown>>;
-    run_container: (input: ComputeContainerInput) => Promise<Envelope<unknown>>;
-    publish_site: (input: DeploySiteInput) => Promise<Envelope<unknown>>;
-    deploy_container: (input: DeployContainerInput) => Promise<Envelope<unknown>>;
-    deploy_edge: (input: DeployEdgeInput) => Promise<Envelope<unknown>>;
-    buy_domain: (input: DomainsRegisterInput) => Promise<Envelope<unknown>>;
-    manage_dns: (input: DnsManageInput) => Promise<Envelope<unknown>>;
-    cache: (input: KvStoreInput) => Promise<Envelope<unknown>>;
-    save: (input: DbWriteInput) => Promise<Envelope<unknown>>;
-    query: (input: DbQueryInput) => Promise<Envelope<unknown>>;
-    store_file: (input: StorageObjectInput) => Promise<Envelope<unknown>>;
-    search_similar: (input: VectorSearchInput) => Promise<Envelope<unknown>>;
-    send_email: (input: EmailSendInput) => Promise<Envelope<unknown>>;
-    log: (input: ObservabilityLogInput) => Promise<Envelope<unknown>>;
-    enqueue: (input: QueueEmitInput) => Promise<Envelope<unknown>>;
-    send_text: (input: SmsSendInput) => Promise<Envelope<unknown>>;
-    track: (input: AnalyticsTrackInput) => Promise<Envelope<unknown>>;
-    search_app: (input: AppSearchInput) => Promise<Envelope<unknown>>;
-    remember: (input: MemoryStoreInput) => Promise<Envelope<unknown>>;
-    recall: (input: MemorySearchInput) => Promise<Envelope<unknown>>;
-    check_flag: (input: FeatureFlagInput) => Promise<Envelope<unknown>>;
-    make_video: (input: VideoGenerateInput) => Promise<Envelope<unknown>>;
-    users: (input: AuthUsersInput) => Promise<Envelope<unknown>>;
-    charge: (input: PaymentsChargeInput) => Promise<Envelope<unknown>>;
-    refund: (input: PaymentsRefundInput) => Promise<Envelope<unknown>>;
-    payment: (input: PaymentsIntentInput) => Promise<Envelope<unknown>>;
-    payment_history: (input?: PaymentsListInput) => Promise<Envelope<unknown>>;
-    find_tools: (input: ToolsDiscoverInput) => Promise<Envelope<ToolCard[]>>;
-    inspect_tool: (input: ToolsInspectInput) => Promise<Envelope<ToolContract>>;
-    run_tool: (input: ToolsRunInput) => Promise<Envelope<ToolRunResult>>;
-    web: {
-        search: (input: WebSearchInput) => Promise<Envelope<unknown>>;
-        scrape: (input: WebScrapeInput) => Promise<Envelope<unknown>>;
-        extract: (input: WebExtractInput) => Promise<Envelope<unknown>>;
-        crawl: (input: WebCrawlInput) => Promise<Envelope<unknown>>;
-        monitor: (input: WebMonitorInput) => Promise<Envelope<unknown>>;
-    };
-    browser: {
-        drive: (input: BrowserDriveInput) => Promise<Envelope<unknown>>;
-    };
-    llm: {
-        chat: (input: LlmChatInput) => Promise<Envelope<unknown>>;
-        embed: (input: LlmEmbedInput) => Promise<Envelope<unknown>>;
-        tts: (input: LlmTtsInput) => Promise<Envelope<unknown>>;
-        image: (input: LlmImageInput) => Promise<Envelope<unknown>>;
-        stt: (input: LlmSttInput) => Promise<Envelope<unknown>>;
-    };
-    compute: {
-        sandbox: (input: SandboxInput) => Promise<Envelope<unknown>>;
-        container: (input: ComputeContainerInput) => Promise<Envelope<unknown>>;
-    };
-    deploy: {
-        site: (input: DeploySiteInput) => Promise<Envelope<unknown>>;
-        container: (input: DeployContainerInput) => Promise<Envelope<unknown>>;
-        edge: (input: DeployEdgeInput) => Promise<Envelope<unknown>>;
-    };
-    domains: {
-        register: (input: DomainsRegisterInput) => Promise<Envelope<unknown>>;
-    };
-    dns: {
-        manage: (input: DnsManageInput) => Promise<Envelope<unknown>>;
-    };
-    kv: {
-        store: (input: KvStoreInput) => Promise<Envelope<unknown>>;
-    };
-    db: {
-        write: (input: DbWriteInput) => Promise<Envelope<unknown>>;
-        query: (input: DbQueryInput) => Promise<Envelope<unknown>>;
-    };
-    storage: {
-        object: (input: StorageObjectInput) => Promise<Envelope<unknown>>;
-    };
-    vectors: {
-        search: (input: VectorSearchInput) => Promise<Envelope<unknown>>;
-    };
-    email: {
-        send: (input: EmailSendInput) => Promise<Envelope<unknown>>;
-    };
-    observability: {
-        log: (input: ObservabilityLogInput) => Promise<Envelope<unknown>>;
-    };
-    queue: {
-        emit: (input: QueueEmitInput) => Promise<Envelope<unknown>>;
-    };
-    sms: {
-        send: (input: SmsSendInput) => Promise<Envelope<unknown>>;
-    };
-    analytics: {
-        track: (input: AnalyticsTrackInput) => Promise<Envelope<unknown>>;
-    };
-    appsearch: {
-        query: (input: AppSearchInput) => Promise<Envelope<unknown>>;
-    };
-    memory: {
-        store: (input: MemoryStoreInput) => Promise<Envelope<unknown>>;
-        search: (input: MemorySearchInput) => Promise<Envelope<unknown>>;
-    };
-    featureflags: {
-        evaluate: (input: FeatureFlagInput) => Promise<Envelope<unknown>>;
-    };
-    video: {
-        generate: (input: VideoGenerateInput) => Promise<Envelope<unknown>>;
-    };
-    auth: {
-        users: (input: AuthUsersInput) => Promise<Envelope<unknown>>;
-    };
-    payments: {
-        charge: (input: PaymentsChargeInput) => Promise<Envelope<unknown>>;
-        refund: (input: PaymentsRefundInput) => Promise<Envelope<unknown>>;
-        intent: (input: PaymentsIntentInput) => Promise<Envelope<unknown>>;
-        list: (input?: PaymentsListInput) => Promise<Envelope<unknown>>;
-        onboard: () => Promise<Envelope<PaymentsStatus & {
-            onboarding_url: string | null;
-        }>>;
-        status: () => Promise<Envelope<PaymentsStatus>>;
-        events: (limit?: number) => Promise<Envelope<{
-            events: PaymentEvent[];
-        }>>;
-        setWebhook: (url: string) => Promise<Envelope<{
-            url: string;
-            secret: string;
-        }>>;
-        clearWebhook: () => Promise<Envelope<{
-            cleared: boolean;
-        }>>;
-    };
-    tools: {
-        discover: (input: ToolsDiscoverInput) => Promise<Envelope<ToolCard[]>>;
-        inspect: (input: ToolsInspectInput) => Promise<Envelope<ToolContract>>;
-        run: (input: ToolsRunInput) => Promise<Envelope<ToolRunResult>>;
-    };
-    /** Ingest into the entity spine — `docs`, `csv`, `records` (SQL/CRM rows), `http`, or `tool`. */
-    ingest: (input: {
-        docs?: {
-            id: string;
-            text: string;
-            type?: string;
-            name?: string;
-        }[];
-        csv?: Record<string, unknown>;
-        records?: Record<string, unknown>;
-        http?: Record<string, unknown>;
-        tool?: Record<string, unknown>;
-    }) => Promise<Envelope<{
-        entities: number;
-        facts: number;
-    }>>;
-    context: {
-        fetch: (input: {
-            task: string;
-            scope?: ContextScope;
-            entities?: string[];
-            tokenBudget?: number;
-        }) => Promise<Envelope<ContextPacket>>;
-        query: (input: {
-            question: string;
-            scope?: ContextScope;
-            tokenBudget?: number;
-        }) => Promise<Envelope<{
-            answer: string;
-            packet: ContextPacket;
-        }>>;
-        diff: (cursor: string) => Promise<Envelope<ContextDiff>>;
-        replay: (packetId: string, at?: number) => Promise<Envelope<ContextPacket>>;
-        ledger: (query?: {
-            entity?: string;
-            session?: string;
-            since?: number;
-            actions?: boolean;
-            decisions?: boolean;
-        }) => Promise<Envelope<LedgerEntry[]>>;
-        /** Sign a human judgment about a proposed call into the same prev-hash
-         *  chain as the calls, so a refusal is as provable as an approval. `args`
-         *  is hashed server-side and never stored raw. */
-        decide: (input: {
-            action: string;
-            outcome: "approved" | "rejected" | "amended";
-            decidedBy: string;
-            args?: Record<string, unknown>;
-            surface?: string;
-            credits?: number;
-            approvalId?: string;
-        }) => Promise<Envelope<{
-            seq: number;
-            kind: string;
-            contentHash: string;
-            decision: unknown;
-        }>>;
-        writeback: (input: {
-            entity: string;
-            rows: unknown[];
-            scope?: ContextScope;
-            approval?: boolean;
-        }) => Promise<Envelope<{
-            applied: number;
-            auditId: string;
-        }>>;
-        eval: () => Promise<Envelope<EvalReport>>;
-    };
-    memoryPlane: {
-        add: (input: {
-            text: string;
-            scope?: ContextScope;
-            entityIds?: string[];
-            confidence?: number;
-        }) => Promise<Envelope<ContextMemory>>;
-        search: (query: string, k?: number) => Promise<Envelope<ContextMemory[]>>;
-        forget: (id: string) => Promise<Envelope<{
-            forgotten: boolean;
-        }>>;
-    };
-    entity: {
-        resolve: (ref: string, type?: string) => Promise<Envelope<EntityResolution>>;
-        graph: (id: string) => Promise<Envelope<{
-            entityId: string;
-            relations: unknown[];
-            neighbors: string[];
-        }>>;
-    };
-    sessions: {
-        create: (input?: {
-            scope?: ContextScope;
-            ttlMs?: number;
-            id?: string;
-            metadata?: Record<string, unknown>;
-        }) => Promise<Envelope<Session>>;
-        list: () => Promise<Envelope<Session[]>>;
-        /** Read a session, including its persisted context `window`. */
-        get: (id: string) => Promise<Envelope<Session>>;
-        use: (id: string) => Promise<Envelope<Session>>;
-        forget: (id: string) => Promise<Envelope<{
-            forgotten: boolean;
-        }>>;
-    };
-    /**
-     * Call a capability bound to a session, so the call joins that session's
-     * context window and its receipt carries the session.
-     *
-     * This is the grounded-call path: create a session, `context.fetch` into it,
-     * then call through here and every subsequent call is already sitting on the
-     * grounding the session accumulated — no re-fetch per tool call, and a
-     * receipt that can reconstruct the whole sequence.
-     */
-    grounded: {
-        fetch: (session: string, input: {
-            task: string;
-            scope?: ContextScope;
-            entities?: string[];
-            tokenBudget?: number;
-        }) => Promise<Envelope<ContextPacket>>;
-        query: (session: string, input: {
-            question: string;
-            scope?: ContextScope;
-            tokenBudget?: number;
-        }) => Promise<Envelope<{
-            answer: string;
-            packet: ContextPacket;
-        }>>;
-        call: <T = unknown>(session: string, capability: string, input: object, packetId?: string) => Promise<Envelope<T>>;
-    };
-    actions: {
-        import: (kind: "toolkit" | "mcp" | "connectors", name: string) => Promise<Envelope<{
-            kind: string;
-            name: string;
-            url?: string;
-        }>>;
-        list: (kind: "toolkit" | "mcp" | "connectors", name: string) => Promise<Envelope<{
-            kind: string;
-            name: string;
-            actions: unknown[];
-        }>>;
-        run: (kind: "toolkit" | "mcp" | "connectors", name: string, action: string, args?: Record<string, unknown>) => Promise<Envelope<unknown>>;
-    };
-    credits: {
-        balance: () => Promise<Envelope<unknown>>;
-        packs: () => Promise<{
-            ok: false;
-            error: import("./types").MuxoError;
-        } | unknown[]>;
-        checkout: (pack: string) => Promise<Envelope<unknown>>;
-    };
-    workflows: {
-        run: (name: string, params?: Record<string, string | number | boolean>) => Promise<Envelope<unknown>>;
-        executions: (name: string) => Promise<Envelope<unknown>>;
-    };
-    status: () => Promise<Envelope<unknown>>;
-    capabilities: () => Promise<Envelope<unknown>>;
-    usage: () => Promise<Envelope<unknown>>;
-    manifest: {
-        get: () => Promise<Envelope<unknown>>;
-        put: (text: string) => Promise<Envelope<unknown>>;
-        versions: () => Promise<Envelope<unknown>>;
-        plan: (text: string) => Promise<Envelope<unknown>>;
-    };
-    keys: {
-        list: () => Promise<Envelope<unknown>>;
-        create: () => Promise<Envelope<unknown>>;
-        revoke: (id: string) => Promise<Envelope<unknown>>;
-    };
-    rollback(version?: number): Promise<Envelope<unknown>>;
-}
-//# sourceMappingURL=index.d.ts.map
+
+export {};