import z$1, { z } from 'zod';
declare enum JsonRpcMessageType {
Request = "request",
Response = "response",
Notification = "notification"
}
/**
* Standard JSON-RPC 2.0 error codes
* @see https://www.jsonrpc.org/specification#error_object
*/
declare enum JsonRpcErrorCode {
PARSE_ERROR = -32700,
INVALID_REQUEST = -32600,
METHOD_NOT_FOUND = -32601,
INVALID_PARAMS = -32602,
INTERNAL_ERROR = -32603,
AUTHENTICATION_ERROR = -32001,
ENTITY_NOT_FOUND = -32004,
/** Session's CLI process has disconnected or died */
SESSION_DISCONNECTED = -32005
}
/**
* The interaction mode determines how Droid operates.
* - Auto: Droid can execute actions based on autonomy level
* - Spec: Droid is in planning/research mode only (read-only operations)
* - Mission: Droid orchestrates missions with read-only tools and orchestrator controls
*/
declare enum DroidInteractionMode {
Auto = "auto",
Spec = "spec",
/** @deprecated Use Mission instead. Kept for protocol compatibility. */
AGI = "agi",
Mission = "mission"
}
/**
* Supported operating system platforms
*/
declare enum Platform {
Darwin = "darwin",
Windows = "win32",
Linux = "linux"
}
/**
* Autonomy level determines what actions Droid can perform without user confirmation.
* - Off: User controls all actions (confirmation required for everything)
* - Low: Allow file edits and read-only commands
* - Medium: Allow reversible commands
* - High: Allow all commands without prompts
*/
declare enum AutonomyLevel {
Off = "off",
Low = "low",
Medium = "medium",
High = "high"
}
/**
* Combined autonomy mode for backward compatibility.
* This is derived from DroidInteractionMode + AutonomyLevel:
* - Normal = Auto + Off
* - Spec = Spec mode (autonomy level ignored)
* - AutoLow = Auto + Low
* - AutoMedium = Auto + Medium
* - AutoHigh = Auto + High
* @deprecated Use DroidInteractionMode + AutonomyLevel instead
*/
declare enum AutonomyMode {
Normal = "normal",
Spec = "spec",
AutoLow = "auto-low",
AutoMedium = "auto-medium",
AutoHigh = "auto-high"
}
declare enum ToolConfirmationOutcome {
ProceedOnce = "proceed_once",
ProceedAlways = "proceed_always",
/** Like ProceedAlways, but persists the exact file path instead of its parent directory. */
ProceedAlwaysForExactPath = "proceed_always_file",
ProceedAutoRun = "proceed_auto_run",
ProceedAutoRunLow = "proceed_auto_run_low",
ProceedAutoRunMedium = "proceed_auto_run_medium",
ProceedAutoRunHigh = "proceed_auto_run_high",
ProceedNewSession = "proceed_new_session",
ProceedNewSessionLow = "proceed_new_session_low",
ProceedNewSessionMedium = "proceed_new_session_medium",
ProceedNewSessionHigh = "proceed_new_session_high",
ProceedEdit = "proceed_edit",
/** MCP: Persist approval for specific tool(s) across sessions */
ProceedAlwaysTools = "proceed_always_tools",
/** MCP: Persist approval for all tools from a server across sessions */
ProceedAlwaysServer = "proceed_always_server",
Cancel = "cancel"
}
declare enum ToolConfirmationType {
Edit = "edit",
Execute = "exec",
Create = "create",
AskUser = "ask_user",
ExitSpecMode = "exit_spec_mode",
ProposeMission = "propose_mission",
StartMissionRun = "start_mission_run",
ApplyPatch = "apply_patch",
McpTool = "mcp_tool",
SandboxViolation = "sandbox_violation"
}
declare enum SandboxViolationType {
FilesystemRead = "filesystem-read",
FilesystemWrite = "filesystem-write",
Network = "network"
}
declare enum SandboxViolationReason {
DenyList = "deny-list",
NotAllowed = "not-allowed"
}
declare enum SandboxOperationType {
Read = "read",
Write = "write",
Network = "network"
}
declare enum DroidServerMethod {
INITIALIZE_SESSION = "droid.initialize_session",
LOAD_SESSION = "droid.load_session",
ADD_USER_MESSAGE = "droid.add_user_message",
RESOLVE_QUEUED_USER_MESSAGE = "droid.resolve_queued_user_message",
CLOSE_SESSION = "droid.close_session",
INTERRUPT_SESSION = "droid.interrupt_session",
KILL_WORKER_SESSION = "droid.kill_worker_session",
UPDATE_SESSION_SETTINGS = "droid.update_session_settings",
TOGGLE_MCP_SERVER = "droid.toggle_mcp_server",
AUTHENTICATE_MCP_SERVER = "droid.authenticate_mcp_server",
CANCEL_MCP_AUTH = "droid.cancel_mcp_auth",
CLEAR_MCP_AUTH = "droid.clear_mcp_auth",
ADD_MCP_SERVER = "droid.add_mcp_server",
REMOVE_MCP_SERVER = "droid.remove_mcp_server",
LIST_MCP_REGISTRY = "droid.list_mcp_registry",
LIST_MCP_TOOLS = "droid.list_mcp_tools",
LIST_TOOLS = "droid.list_tools",
LIST_MCP_SERVERS = "droid.list_mcp_servers",
TOGGLE_MCP_TOOL = "droid.toggle_mcp_tool",
SUBMIT_MCP_AUTH_CODE = "droid.submit_mcp_auth_code",
LIST_SKILLS = "droid.list_skills",
LIST_COMMANDS = "droid.list_commands",
SUBMIT_BUG_REPORT = "droid.submit_bug_report",
GET_REWIND_INFO = "droid.get_rewind_info",
EXECUTE_REWIND = "droid.execute_rewind",
COMPACT_SESSION = "droid.compact_session",
FORK_SESSION = "droid.fork_session",
RENAME_SESSION = "droid.rename_session",
GET_CONTEXT_STATS = "droid.get_context_stats",
GET_CONTEXT_BREAKDOWN = "droid.get_context_breakdown",
WARMUP_CACHE = "droid.warmup_cache"
}
declare enum QueuePlacement {
EndOfTurn = "end_of_turn",
EndOfLoop = "end_of_loop"
}
declare enum ResolveQueuedUserMessageAction {
UpdateQueue = "update_queue",
Delete = "delete"
}
declare enum DroidClientMethod {
SESSION_NOTIFICATION = "droid.session_notification",
REQUEST_PERMISSION = "droid.request_permission",
ASK_USER = "droid.ask_user"
}
declare enum SessionNotificationType {
TOOL_RESULT = "tool_result",
TOOL_PROGRESS_UPDATE = "tool_progress_update",
CREATE_MESSAGE = "create_message",
ERROR = "error",
DROID_WORKING_STATE_CHANGED = "droid_working_state_changed",
SESSION_COMPACTED = "session_compacted",
LOOP_STATE_CHANGED = "loop_state_changed",
PERMISSION_RESOLVED = "permission_resolved",
SETTINGS_UPDATED = "settings_updated",
SESSION_TITLE_UPDATED = "session_title_updated",
MCP_STATUS_CHANGED = "mcp_status_changed",
ASSISTANT_TEXT_DELTA = "assistant_text_delta",
ASSISTANT_TEXT_COMPLETE = "assistant_text_complete",
STRUCTURED_OUTPUT = "structured_output",
THINKING_TEXT_DELTA = "thinking_text_delta",
THINKING_TEXT_COMPLETE = "thinking_text_complete",
SESSION_TOKEN_USAGE_CHANGED = "session_token_usage_changed",
MISSION_STATE_CHANGED = "mission_state_changed",
MISSION_FEATURES_CHANGED = "mission_features_changed",
MISSION_PROGRESS_ENTRY = "mission_progress_entry",
MISSION_HEARTBEAT = "mission_heartbeat",
MISSION_WORKER_STARTED = "mission_worker_started",
MISSION_WORKER_COMPLETED = "mission_worker_completed",
MCP_AUTH_REQUIRED = "mcp_auth_required",
MCP_AUTH_COMPLETED = "mcp_auth_completed",
HOOK_EXECUTION_STARTED = "hook_execution_started",
HOOK_EXECUTION_COMPLETED = "hook_execution_completed",
TOOL_CALL = "tool_call",
QUEUED_MESSAGES_DISCARDED = "queued_messages_discarded",
/**
* Internal daemon keep-alive signal emitted while a long-running tool
* (e.g. Execute) is actively executing but not streaming output. Used by
* the daemon to refresh session inactivity timeouts. Not forwarded to
* external clients.
*/
TOOL_EXECUTION_HEARTBEAT = "tool_execution_heartbeat"
}
declare enum StructuredOutputErrorCode {
MissingStructuredOutput = "missing_structured_output",
InvalidStructuredOutput = "invalid_structured_output",
InvalidSchema = "invalid_schema",
SchemaValidationFailed = "schema_validation_failed"
}
declare enum McpAuthOutcome {
Success = "success",
Cancelled = "cancelled",
Failed = "failed"
}
declare enum McpServerStatus {
Connecting = "connecting",
Connected = "connected",
Disconnected = "disconnected",
Failed = "failed",
Disabled = "disabled"
}
declare enum McpServerType {
Stdio = "stdio",
Http = "http",
Sse = "sse"
}
declare enum McpStatus {
NotInitialized = "not-initialized",
Initializing = "initializing",
Ready = "ready",
NoServers = "no-servers",
Failed = "failed"
}
declare enum DroidErrorType {
CONNECTION_ERROR = "ConnectionError",
PROTOCOL_ERROR = "ProtocolError",
SESSION_ERROR = "SessionError",
TIMEOUT_ERROR = "TimeoutError",
DROID_CLIENT_ERROR = "DroidClientError",
PROCESS_EXIT_ERROR = "ProcessExitError",
ERROR = "Error"
}
declare enum DroidWorkingState {
Idle = "idle",
Thinking = "thinking",
StreamingAssistantMessage = "streaming_assistant_message",
WaitingForToolConfirmation = "waiting_for_tool_confirmation",
ExecutingTool = "executing_tool",
CompactingConversation = "compacting_conversation"
}
declare enum DroidLoopStatus {
Waiting = "waiting",
Running = "running",
Due = "due",
Stopped = "stopped",
Error = "error"
}
declare enum DroidLoopStopReason {
UserStopped = "user_stopped",
ManualMessage = "manual_message",
Interrupted = "interrupted",
SessionClosed = "session_closed",
ProcessExited = "process_exited",
Error = "error"
}
declare enum ContextStatsAccuracy {
Exact = "exact",
Estimated = "estimated"
}
declare enum ToolExecutionRenderStatus {
Streaming = "streaming",
Pending = "pending",
Executing = "executing",
Completed = "completed",
Error = "error"
}
declare enum DecompSessionType {
Orchestrator = "orchestrator",
Worker = "worker"
}
/** Mission state enum (used by orchestrator mission runner). */
declare enum MissionState {
/** Idle. Waiting for user to send a message. */
AwaitingInput = "awaiting_input",
/** Orchestrator is creating mission artifacts after user accepted proposal. */
Initializing = "initializing",
/** Runner is active, spawning/monitoring workers. User input disabled. */
Running = "running",
/** User paused execution. Resumable. */
Paused = "paused",
/** Worker returned control or failed. Orchestrator acts next. */
OrchestratorTurn = "orchestrator_turn",
/** All features done. Terminal state. */
Completed = "completed"
}
/** Feature status enum (mirrors orchestrator feature lifecycle). */
declare enum FeatureStatus {
Pending = "pending",
InProgress = "in_progress",
Completed = "completed",
Cancelled = "cancelled"
}
/** Success state for feature completion. */
declare enum FeatureSuccessState {
Success = "success",
Partial = "partial",
Failure = "failure"
}
/** Issue severity for discovered issues. */
declare enum IssueSeverity {
Blocking = "blocking",
NonBlocking = "non_blocking",
Suggestion = "suggestion"
}
/** Dismissal item type. */
declare enum DismissalType {
DiscoveredIssue = "discovered_issue",
CriticalContext = "critical_context",
IncompleteWork = "incomplete_work"
}
/** Progress log entry type. */
declare enum ProgressLogEntryType {
MissionAccepted = "mission_accepted",
MissionPaused = "mission_paused",
MissionResumed = "mission_resumed",
MissionRunStarted = "mission_run_started",
WorkerStarted = "worker_started",
WorkerSelectedFeature = "worker_selected_feature",
WorkerCompleted = "worker_completed",
WorkerFailed = "worker_failed",
WorkerPaused = "worker_paused",
HandoffItemsDismissed = "handoff_items_dismissed",
MilestoneValidationTriggered = "milestone_validation_triggered"
}
/** Structured failure cause used by orchestrators to branch on auto-pause vs requeue. */
declare enum WorkerFailureReason {
UnrecoverableUsage402 = "unrecoverable_usage_402"
}
/** Structured cause for automatically-triggered mission pauses. */
declare enum MissionPauseReason {
UnrecoverableUsage402 = "unrecoverable_usage_402"
}
/**
* Color-key discriminators for the `/context` window usage breakdown. Each key
* maps to a CSS variable in the rendering surface (CLI chalk colors or web
* design tokens), so adding a new category requires updating both ends.
*/
declare enum ContextCategoryColorKey {
SystemPrompt = "systemPrompt",
SystemTools = "systemTools",
McpTools = "mcpTools",
UserInfo = "userInfo",
AgentsMd = "agentsMd",
CustomAgents = "customAgents",
Skills = "skills",
Messages = "messages"
}
declare enum MessageVisibility {
Both = "both",
LLMOnly = "llm_only",
UserOnly = "user_only"
}
declare enum MessageRoleNoSystem {
User = "user",
Assistant = "assistant",
Tool = "tool"
}
declare enum MessageRole {
User = "user",
Assistant = "assistant",
Tool = "tool",
System = "system"
}
declare enum MessageContentBlockType {
Text = "text",
Image = "image",
Thinking = "thinking",
RedactedThinking = "redacted_thinking",
ToolUse = "tool_use",
ToolResult = "tool_result",
Document = "document"
}
declare enum DocumentSourceType {
Base64 = "base64",
Text = "text"
}
declare enum SessionPlatform {
Slack = "slack",
Web = "web",
Api = "api",
SessionsApi = "sessions_api",
Linear = "linear",
ReadinessRemediation = "readiness-remediation",
ReadinessEvaluation = "readiness-evaluation",
Automation = "automation",
WikiGeneration = "wiki-generation",
WikiCISetup = "wiki-ci-setup"
}
declare enum SessionOrigin {
Web = "web",
Desktop = "desktop",
CliTui = "cli_tui",
CliExec = "cli_exec",
CliAcp = "cli_acp",
Slack = "slack",
Linear = "linear",
SessionsApi = "sessions_api",
Api = "api",
Automation = "automation",
ReadinessRemediation = "readiness-remediation",
ReadinessEvaluation = "readiness-evaluation",
WikiGeneration = "wiki-generation",
WikiCiSetup = "wiki-ci-setup"
}
/**
* ModelID enum defines unique identifiers for language models.
*
* These IDs are independent of provider (Anthropic, OpenAI, etc.) and reasoning effort (Low, Medium, High).
* They represent the core model identity that remains consistent regardless of how the model is accessed.
*/
declare enum ModelID {
CLAUDE_SONNET_3_5 = "claude-3-5-sonnet-20241022",
CLAUDE_SONNET_3_7 = "claude-3-7-sonnet-20250219",
CLAUDE_SONNET_4 = "claude-sonnet-4-20250514",
CLAUDE_OPUS_4 = "claude-opus-4-1-20250805",
CLAUDE_HAIKU_3_5 = "claude-3-5-haiku-20241022",
CLAUDE_SONNET_4_5 = "claude-sonnet-4-5-20250929",
CLAUDE_OPUS_4_5 = "claude-opus-4-5-20251101",
CLAUDE_HAIKU_4_5 = "claude-haiku-4-5-20251001",
CLAUDE_SONNET_4_6 = "claude-sonnet-4-6",
CLAUDE_OPUS_4_6 = "claude-opus-4-6",
CLAUDE_OPUS_4_6_FAST = "claude-opus-4-6-fast",
CLAUDE_OPUS_4_7 = "claude-opus-4-7",
CLAUDE_OPUS_4_7_FAST = "claude-opus-4-7-fast",
CLAUDE_OPUS_4_8 = "claude-opus-4-8",
CLAUDE_OPUS_4_8_FAST = "claude-opus-4-8-fast",
ASPEN_0515 = "aspen-05-15",
ALMOND_0527 = "almond-05-27",
GPT_5 = "gpt-5-2025-08-07",
GPT_5_MINI = "gpt-5-mini-2025-08-07",
GPT_5_NANO = "gpt-5-nano-2025-08-07",
GPT_5_CODEX = "gpt-5-codex",
GPT_5_1 = "gpt-5.1",
GPT_5_1_CODEX = "gpt-5.1-codex",
GPT_5_1_CODEX_MAX = "gpt-5.1-codex-max",
GPT_5_2 = "gpt-5.2",
GPT_5_2_CODEX = "gpt-5.2-codex",
GPT_5_3_CODEX = "gpt-5.3-codex",
GPT_5_3_CODEX_FAST = "gpt-5.3-codex-fast",
GPT_5_4 = "gpt-5.4",
GPT_5_4_FAST = "gpt-5.4-fast",
GPT_5_4_MINI = "gpt-5.4-mini",
GPT_5_5 = "gpt-5.5",
GPT_5_5_FAST = "gpt-5.5-fast",
GPT_5_5_PRO = "gpt-5.5-pro",
OLM_0305 = "olm-03-05",
ORBIT_0409 = "orbit-04-09",
OLIVE_0522 = "olive-05-22",
ORIEL_0601 = "oriel-06-01",
OXIDE_0601 = "oxide-06-01",
OXBOW_0601 = "oxbow-06-01",
OCELOT_0601 = "ocelot-06-01",
GEMINI_2_5_FLASH = "gemini-2.5-flash",
GEMINI_2_5_PRO = "gemini-2.5-pro",
GEMINI_3_PRO = "gemini-3-pro-preview",
GEMINI_3_FLASH = "gemini-3-flash-preview",
GEMINI_3_1_PRO = "gemini-3.1-pro-preview",
GEMINI_3_5_FLASH = "gemini-3.5-flash",
GANTRY_0507 = "gantry-05-07",
TITAN_0212 = "titan-02-12",
GLM_4_6 = "glm-4.6",
GLM_4_7 = "glm-4.7",
KIMI_K2_5 = "kimi-k2.5",
KIMI_K2_6 = "kimi-k2.6",
DEEPSEEK_V4_PRO = "deepseek-v4-pro",
MINIMAX_M2_5 = "minimax-m2.5",
MINIMAX_M2_7 = "minimax-m2.7",
GLM_5 = "glm-5",
GLM_5_1 = "glm-5.1",
FACTORY_ROUTER = "factory-router"
}
declare enum OpenAIPhase {
Commentary = "commentary",
FinalAnswer = "final_answer"
}
/**
* Wire-format field name for assistant-message reasoning on the OpenAI
* Chat Completions endpoint. OpenAI / XAI capture reasoning in `reasoning`;
* vLLM / SGLang / Fireworks' Kimi deployments use `reasoning_content`.
*/
declare enum ChatCompletionReasoningField {
Reasoning = "reasoning",
ReasoningContent = "reasoning_content"
}
/**
* Enum defining the reasoning effort levels for LLMs.
* This determines how much "thinking" the model does before responding.
*/
declare enum ReasoningEffort {
None = "none",
Dynamic = "dynamic",
Off = "off",
Minimal = "minimal",
Low = "low",
Medium = "medium",
High = "high",
ExtraHigh = "xhigh",
Max = "max"
}
declare enum ModelProvider {
ANTHROPIC = "anthropic",
OPENAI = "openai",
GENERIC_CHAT_COMPLETION_API = "generic-chat-completion-api",
FACTORY = "factory",
GOOGLE = "google",
XAI = "xai",
VOYAGE = "voyage",
/**
* BYOK custom models served over the AWS Bedrock Converse API
* (`ConverseStream`). Distinct from {@link ModelProvider.ANTHROPIC}
* Bedrock routing (which speaks the Anthropic Messages dialect over the
* Bedrock SDK): this provider speaks the native Converse schema and is
* never used for first-party / proxy-routed models.
*/
BEDROCK_CONVERSE = "bedrock-converse"
}
declare enum ApiProvider {
BEDROCK = "bedrock",
ANTHROPIC = "anthropic",
VERTEX_ANTHROPIC = "vertex_anthropic",
BEDROCK_ANTHROPIC = "bedrock_anthropic",
BEDROCK_CONVERSE = "bedrock_converse",
OPENAI = "openai",
AZURE_OPENAI = "azure_openai",
GOOGLE = "google",
XAI = "xai",
FIREWORKS = "fireworks",
BASETEN = "baseten",
SNOWFLAKE = "snowflake"
}
declare enum ModelKind {
Concrete = "concrete",
Router = "router"
}
declare enum LLMModelTier {
Standard = "standard",
Premium = "premium",
Overage = "overage"
}
/**
* Settings hierarchy level enum.
* Precedence order (highest to lowest): Org -> Runtime -> Folder -> Project -> User
*/
declare enum SettingsLevel {
Org = "org",
Runtime = "runtime",
User = "user",
Project = "project",
Folder = "folder",
Dynamic = "dynamic",
BuiltIn = "builtin"
}
declare enum DroidLocation {
Project = "project",
Personal = "personal"
}
declare enum SkillLocation {
Project = "project",
Personal = "personal",
Builtin = "builtin"
}
declare enum SandboxMode {
PerCommand = "per-command",
WholeProcess = "whole-process"
}
declare enum DiffMode {
Github = "github",
Unified = "unified"
}
declare enum SoundFocusMode {
Always = "always",
Focused = "focused",
Unfocused = "unfocused"
}
declare enum TodoDisplayMode {
Inline = "inline",
Pinned = "pinned"
}
declare enum SubagentSoundMode {
Off = "off",
Quiet = "quiet",
Inherit = "inherit"
}
declare enum LogoAnimationMode {
Once = "once",
Always = "always",
Off = "off"
}
declare enum ToolResultDisplay {
Expanded = "expanded",
Compact = "compact"
}
declare const FACTORY_CLIENT_HEADER = "X-Factory-Client";
declare const FACTORY_CLIENT_VERSION = "X-Client-Version";
declare const ACTIVE_ORGANIZATION_HEADER = "X-Factory-Org-Id";
/**
* Legacy envelope field for old JSON-RPC peers - `factoryApiVersion` must be set to this value.
*
* @deprecated Do not change this value; use `factoryProtocolVersion` for runtime compatibility.
*/
declare const LEGACY_FACTORY_API_VERSION: "1.0.0";
declare const FACTORY_PROTOCOL_VERSION: "1.66.0";
declare const JSONRPC_VERSION: "2.0";
/**
* Sentinel ModelID value for the Factory routing model.
*/
declare const FACTORY_ROUTER_MODEL_ID: "factory-router";
/**
* Sentinel value used by CompactionModelSchema to mean "use the session's
* current model for compaction".
*/
declare const CURRENT_COMPACTION_MODEL = "current-model";
/** Sized comparably to a trimmed user message in the classifier context budget. */
declare const FACTORY_ROUTER_GUIDANCE_MAX_LENGTH = 2000;
declare const FACTORY_ROUTER_RULES_MAX_COUNT = 20;
declare const FACTORY_ROUTER_RULE_WHEN_MAX_LENGTH = 300;
declare const FACTORY_ROUTER_RULE_GUIDANCE_MAX_LENGTH = 600;
/**
* System reminder tag constants used for marking content as hidden from users.
*/
declare const SYSTEM_REMINDER_START = "";
declare const SYSTEM_REMINDER_END = "";
/**
* System notification tag constants used for marking notifications as hidden from users.
*/
declare const SYSTEM_NOTIFICATION_START = "";
declare const SYSTEM_NOTIFICATION_END = "";
declare const EXIT_SPEC_MODE_REJECTED_MESSAGE = "Plan not approved - remaining in Spec Mode. Provide feedback to refine the spec.";
declare const LOOP_INTERVAL_POLICY: {
readonly minMs: number;
readonly maxMs: number;
readonly displayRange: "1m–24h";
readonly examples: "5m, 30m, 2h";
};
declare const DROID_IN_PROGRESS_STATES: DroidWorkingState[];
declare const DroidInteractionModeSchema: z.ZodNativeEnum;
/**
* Trace context metadata for distributed tracing propagation.
* Follows W3C Trace Context standard for cross-service trace correlation.
* @see https://www.w3.org/TR/trace-context/
*/
declare const TraceContextMetaSchema: z.ZodObject<{
/** W3C traceparent header value (e.g., "00-0af7651916cd43dd8448eb211c80319c-00f067aa0ba902b7-01") */
traceparent: z.ZodOptional;
/** W3C tracestate header value for vendor-specific trace data */
tracestate: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
traceparent?: string | undefined;
tracestate?: string | undefined;
}, {
traceparent?: string | undefined;
tracestate?: string | undefined;
}>;
declare const JsonRpcEnvelopeSchema: z.ZodObject<{
jsonrpc: z.ZodLiteral<"2.0">;
factoryApiVersion: z.ZodLiteral<"1.0.0">;
/** Optional runtime compatibility signal; tolerate absence while old peers roll forward. */
factoryProtocolVersion: z.ZodOptional;
/** Optional metadata for trace context propagation (MCP-style) */
_meta: z.ZodOptional;
/** W3C tracestate header value for vendor-specific trace data */
tracestate: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
traceparent?: string | undefined;
tracestate?: string | undefined;
}, {
traceparent?: string | undefined;
tracestate?: string | undefined;
}>>;
}, "strip", z.ZodTypeAny, {
jsonrpc: "2.0";
factoryApiVersion: "1.0.0";
factoryProtocolVersion?: string | undefined;
_meta?: {
traceparent?: string | undefined;
tracestate?: string | undefined;
} | undefined;
}, {
jsonrpc: "2.0";
factoryApiVersion: "1.0.0";
factoryProtocolVersion?: string | undefined;
_meta?: {
traceparent?: string | undefined;
tracestate?: string | undefined;
} | undefined;
}>;
declare const JsonRpcProtocolVersionMismatchErrorDataSchema: z.ZodObject<{
localFactoryProtocolVersion: z.ZodString;
peerFactoryProtocolVersion: z.ZodString;
messageType: z.ZodOptional>;
method: z.ZodOptional;
requestId: z.ZodOptional>;
}, "strip", z.ZodTypeAny, {
localFactoryProtocolVersion: string;
peerFactoryProtocolVersion: string;
method?: string | undefined;
requestId?: string | null | undefined;
messageType?: JsonRpcMessageType | undefined;
}, {
localFactoryProtocolVersion: string;
peerFactoryProtocolVersion: string;
method?: string | undefined;
requestId?: string | null | undefined;
messageType?: JsonRpcMessageType | undefined;
}>;
declare const JsonRpcErrorSchema: z.ZodObject<{
code: z.ZodNativeEnum;
message: z.ZodString;
data: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
}, {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
}>;
declare const BaseRequestSchema: z.ZodObject<{
type: z.ZodLiteral<"request">;
id: z.ZodString;
method: z.ZodString;
params: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: "request";
id: string;
method: string;
params?: unknown;
}, {
type: "request";
id: string;
method: string;
params?: unknown;
}>;
declare const BaseResponseSuccessSchema: z.ZodObject<{
type: z.ZodLiteral<"response">;
error: z.ZodOptional;
message: z.ZodString;
data: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
}, {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
}>>;
} & {
id: z.ZodString;
result: z.ZodUnknown;
}, "strip", z.ZodTypeAny, {
type: "response";
id: string;
error?: {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
} | undefined;
result?: unknown;
}, {
type: "response";
id: string;
error?: {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
} | undefined;
result?: unknown;
}>;
declare const BaseResponseFailureSchema: z.ZodObject<{
type: z.ZodLiteral<"response">;
id: z.ZodNullable;
result: z.ZodOptional;
} & {
error: z.ZodObject<{
code: z.ZodNativeEnum;
message: z.ZodString;
data: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
}, {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
}>;
}, "strip", z.ZodTypeAny, {
error: {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
};
type: "response";
id: string | null;
result?: unknown;
}, {
error: {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
};
type: "response";
id: string | null;
result?: unknown;
}>;
declare const BaseNotificationSchema: z.ZodObject<{
type: z.ZodLiteral<"notification">;
method: z.ZodString;
params: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: "notification";
method: string;
params?: unknown;
}, {
type: "notification";
method: string;
params?: unknown;
}>;
declare const JsonRpcBaseRequestSchema: z.ZodObject<{
jsonrpc: z.ZodLiteral<"2.0">;
factoryApiVersion: z.ZodLiteral<"1.0.0">;
/** Optional runtime compatibility signal; tolerate absence while old peers roll forward. */
factoryProtocolVersion: z.ZodOptional;
/** Optional metadata for trace context propagation (MCP-style) */
_meta: z.ZodOptional;
/** W3C tracestate header value for vendor-specific trace data */
tracestate: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
traceparent?: string | undefined;
tracestate?: string | undefined;
}, {
traceparent?: string | undefined;
tracestate?: string | undefined;
}>>;
} & {
type: z.ZodLiteral<"request">;
id: z.ZodString;
method: z.ZodString;
params: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: "request";
jsonrpc: "2.0";
factoryApiVersion: "1.0.0";
id: string;
method: string;
params?: unknown;
factoryProtocolVersion?: string | undefined;
_meta?: {
traceparent?: string | undefined;
tracestate?: string | undefined;
} | undefined;
}, {
type: "request";
jsonrpc: "2.0";
factoryApiVersion: "1.0.0";
id: string;
method: string;
params?: unknown;
factoryProtocolVersion?: string | undefined;
_meta?: {
traceparent?: string | undefined;
tracestate?: string | undefined;
} | undefined;
}>;
declare const JsonRpcBaseResponseSuccessSchema: z.ZodObject<{
jsonrpc: z.ZodLiteral<"2.0">;
factoryApiVersion: z.ZodLiteral<"1.0.0">;
/** Optional runtime compatibility signal; tolerate absence while old peers roll forward. */
factoryProtocolVersion: z.ZodOptional;
/** Optional metadata for trace context propagation (MCP-style) */
_meta: z.ZodOptional;
/** W3C tracestate header value for vendor-specific trace data */
tracestate: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
traceparent?: string | undefined;
tracestate?: string | undefined;
}, {
traceparent?: string | undefined;
tracestate?: string | undefined;
}>>;
} & {
type: z.ZodLiteral<"response">;
error: z.ZodOptional;
message: z.ZodString;
data: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
}, {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
}>>;
} & {
id: z.ZodString;
result: z.ZodUnknown;
}, "strip", z.ZodTypeAny, {
type: "response";
jsonrpc: "2.0";
factoryApiVersion: "1.0.0";
id: string;
error?: {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
} | undefined;
factoryProtocolVersion?: string | undefined;
_meta?: {
traceparent?: string | undefined;
tracestate?: string | undefined;
} | undefined;
result?: unknown;
}, {
type: "response";
jsonrpc: "2.0";
factoryApiVersion: "1.0.0";
id: string;
error?: {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
} | undefined;
factoryProtocolVersion?: string | undefined;
_meta?: {
traceparent?: string | undefined;
tracestate?: string | undefined;
} | undefined;
result?: unknown;
}>;
declare const JsonRpcBaseResponseFailureSchema: z.ZodObject<{
jsonrpc: z.ZodLiteral<"2.0">;
factoryApiVersion: z.ZodLiteral<"1.0.0">;
/** Optional runtime compatibility signal; tolerate absence while old peers roll forward. */
factoryProtocolVersion: z.ZodOptional;
/** Optional metadata for trace context propagation (MCP-style) */
_meta: z.ZodOptional;
/** W3C tracestate header value for vendor-specific trace data */
tracestate: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
traceparent?: string | undefined;
tracestate?: string | undefined;
}, {
traceparent?: string | undefined;
tracestate?: string | undefined;
}>>;
} & {
type: z.ZodLiteral<"response">;
id: z.ZodNullable;
result: z.ZodOptional;
} & {
error: z.ZodObject<{
code: z.ZodNativeEnum;
message: z.ZodString;
data: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
}, {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
}>;
}, "strip", z.ZodTypeAny, {
error: {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
};
type: "response";
jsonrpc: "2.0";
factoryApiVersion: "1.0.0";
id: string | null;
factoryProtocolVersion?: string | undefined;
_meta?: {
traceparent?: string | undefined;
tracestate?: string | undefined;
} | undefined;
result?: unknown;
}, {
error: {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
};
type: "response";
jsonrpc: "2.0";
factoryApiVersion: "1.0.0";
id: string | null;
factoryProtocolVersion?: string | undefined;
_meta?: {
traceparent?: string | undefined;
tracestate?: string | undefined;
} | undefined;
result?: unknown;
}>;
declare const JsonRpcBaseResponseSchema: z.ZodUnion<[z.ZodObject<{
jsonrpc: z.ZodLiteral<"2.0">;
factoryApiVersion: z.ZodLiteral<"1.0.0">;
/** Optional runtime compatibility signal; tolerate absence while old peers roll forward. */
factoryProtocolVersion: z.ZodOptional;
/** Optional metadata for trace context propagation (MCP-style) */
_meta: z.ZodOptional;
/** W3C tracestate header value for vendor-specific trace data */
tracestate: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
traceparent?: string | undefined;
tracestate?: string | undefined;
}, {
traceparent?: string | undefined;
tracestate?: string | undefined;
}>>;
} & {
type: z.ZodLiteral<"response">;
id: z.ZodNullable;
result: z.ZodOptional;
} & {
error: z.ZodObject<{
code: z.ZodNativeEnum;
message: z.ZodString;
data: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
}, {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
}>;
}, "strip", z.ZodTypeAny, {
error: {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
};
type: "response";
jsonrpc: "2.0";
factoryApiVersion: "1.0.0";
id: string | null;
factoryProtocolVersion?: string | undefined;
_meta?: {
traceparent?: string | undefined;
tracestate?: string | undefined;
} | undefined;
result?: unknown;
}, {
error: {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
};
type: "response";
jsonrpc: "2.0";
factoryApiVersion: "1.0.0";
id: string | null;
factoryProtocolVersion?: string | undefined;
_meta?: {
traceparent?: string | undefined;
tracestate?: string | undefined;
} | undefined;
result?: unknown;
}>, z.ZodObject<{
jsonrpc: z.ZodLiteral<"2.0">;
factoryApiVersion: z.ZodLiteral<"1.0.0">;
/** Optional runtime compatibility signal; tolerate absence while old peers roll forward. */
factoryProtocolVersion: z.ZodOptional;
/** Optional metadata for trace context propagation (MCP-style) */
_meta: z.ZodOptional;
/** W3C tracestate header value for vendor-specific trace data */
tracestate: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
traceparent?: string | undefined;
tracestate?: string | undefined;
}, {
traceparent?: string | undefined;
tracestate?: string | undefined;
}>>;
} & {
type: z.ZodLiteral<"response">;
error: z.ZodOptional;
message: z.ZodString;
data: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
}, {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
}>>;
} & {
id: z.ZodString;
result: z.ZodUnknown;
}, "strip", z.ZodTypeAny, {
type: "response";
jsonrpc: "2.0";
factoryApiVersion: "1.0.0";
id: string;
error?: {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
} | undefined;
factoryProtocolVersion?: string | undefined;
_meta?: {
traceparent?: string | undefined;
tracestate?: string | undefined;
} | undefined;
result?: unknown;
}, {
type: "response";
jsonrpc: "2.0";
factoryApiVersion: "1.0.0";
id: string;
error?: {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
} | undefined;
factoryProtocolVersion?: string | undefined;
_meta?: {
traceparent?: string | undefined;
tracestate?: string | undefined;
} | undefined;
result?: unknown;
}>]>;
declare const JsonRpcBaseNotificationSchema: z.ZodObject<{
jsonrpc: z.ZodLiteral<"2.0">;
factoryApiVersion: z.ZodLiteral<"1.0.0">;
/** Optional runtime compatibility signal; tolerate absence while old peers roll forward. */
factoryProtocolVersion: z.ZodOptional;
/** Optional metadata for trace context propagation (MCP-style) */
_meta: z.ZodOptional;
/** W3C tracestate header value for vendor-specific trace data */
tracestate: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
traceparent?: string | undefined;
tracestate?: string | undefined;
}, {
traceparent?: string | undefined;
tracestate?: string | undefined;
}>>;
} & {
type: z.ZodLiteral<"notification">;
method: z.ZodString;
params: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: "notification";
jsonrpc: "2.0";
factoryApiVersion: "1.0.0";
method: string;
params?: unknown;
factoryProtocolVersion?: string | undefined;
_meta?: {
traceparent?: string | undefined;
tracestate?: string | undefined;
} | undefined;
}, {
type: "notification";
jsonrpc: "2.0";
factoryApiVersion: "1.0.0";
method: string;
params?: unknown;
factoryProtocolVersion?: string | undefined;
_meta?: {
traceparent?: string | undefined;
tracestate?: string | undefined;
} | undefined;
}>;
/**
* Generic acknowledgement payload for command-style RPCs.
*/
declare const CommandAckSchema: z.ZodObject<{
accepted: z.ZodLiteral;
}, "strip", z.ZodTypeAny, {
accepted: true;
}, {
accepted: true;
}>;
declare const JsonRpcMessageSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
jsonrpc: z.ZodLiteral<"2.0">;
factoryApiVersion: z.ZodLiteral<"1.0.0">;
/** Optional runtime compatibility signal; tolerate absence while old peers roll forward. */
factoryProtocolVersion: z.ZodOptional;
/** Optional metadata for trace context propagation (MCP-style) */
_meta: z.ZodOptional;
/** W3C tracestate header value for vendor-specific trace data */
tracestate: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
traceparent?: string | undefined;
tracestate?: string | undefined;
}, {
traceparent?: string | undefined;
tracestate?: string | undefined;
}>>;
} & {
type: z.ZodLiteral<"request">;
id: z.ZodString;
method: z.ZodString;
params: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: "request";
jsonrpc: "2.0";
factoryApiVersion: "1.0.0";
id: string;
method: string;
params?: unknown;
factoryProtocolVersion?: string | undefined;
_meta?: {
traceparent?: string | undefined;
tracestate?: string | undefined;
} | undefined;
}, {
type: "request";
jsonrpc: "2.0";
factoryApiVersion: "1.0.0";
id: string;
method: string;
params?: unknown;
factoryProtocolVersion?: string | undefined;
_meta?: {
traceparent?: string | undefined;
tracestate?: string | undefined;
} | undefined;
}>, z.ZodObject<{
jsonrpc: z.ZodLiteral<"2.0">;
factoryApiVersion: z.ZodLiteral<"1.0.0">;
/** Optional runtime compatibility signal; tolerate absence while old peers roll forward. */
factoryProtocolVersion: z.ZodOptional;
/** Optional metadata for trace context propagation (MCP-style) */
_meta: z.ZodOptional;
/** W3C tracestate header value for vendor-specific trace data */
tracestate: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
traceparent?: string | undefined;
tracestate?: string | undefined;
}, {
traceparent?: string | undefined;
tracestate?: string | undefined;
}>>;
} & {
type: z.ZodLiteral<"response">;
id: z.ZodNullable;
result: z.ZodOptional;
error: z.ZodOptional;
message: z.ZodString;
data: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
}, {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
}>>;
}, "strip", z.ZodTypeAny, {
type: "response";
jsonrpc: "2.0";
factoryApiVersion: "1.0.0";
id: string | null;
error?: {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
} | undefined;
factoryProtocolVersion?: string | undefined;
_meta?: {
traceparent?: string | undefined;
tracestate?: string | undefined;
} | undefined;
result?: unknown;
}, {
type: "response";
jsonrpc: "2.0";
factoryApiVersion: "1.0.0";
id: string | null;
error?: {
code: JsonRpcErrorCode;
message: string;
data?: unknown;
} | undefined;
factoryProtocolVersion?: string | undefined;
_meta?: {
traceparent?: string | undefined;
tracestate?: string | undefined;
} | undefined;
result?: unknown;
}>, z.ZodObject<{
jsonrpc: z.ZodLiteral<"2.0">;
factoryApiVersion: z.ZodLiteral<"1.0.0">;
/** Optional runtime compatibility signal; tolerate absence while old peers roll forward. */
factoryProtocolVersion: z.ZodOptional;
/** Optional metadata for trace context propagation (MCP-style) */
_meta: z.ZodOptional;
/** W3C tracestate header value for vendor-specific trace data */
tracestate: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
traceparent?: string | undefined;
tracestate?: string | undefined;
}, {
traceparent?: string | undefined;
tracestate?: string | undefined;
}>>;
} & {
type: z.ZodLiteral<"notification">;
method: z.ZodString;
params: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: "notification";
jsonrpc: "2.0";
factoryApiVersion: "1.0.0";
method: string;
params?: unknown;
factoryProtocolVersion?: string | undefined;
_meta?: {
traceparent?: string | undefined;
tracestate?: string | undefined;
} | undefined;
}, {
type: "notification";
jsonrpc: "2.0";
factoryApiVersion: "1.0.0";
method: string;
params?: unknown;
factoryProtocolVersion?: string | undefined;
_meta?: {
traceparent?: string | undefined;
tracestate?: string | undefined;
} | undefined;
}>]>;
type TraceContextMeta = z.infer;
type JsonRpcEnvelope = z.infer;
type JsonRpcError = z.infer;
type JsonRpcProtocolVersionMismatchErrorData = z.infer;
type JsonRpcBaseRequest = z.infer;
type JsonRpcBaseResponseSuccess = z.infer;
type JsonRpcBaseResponseFailure = z.infer;
type JsonRpcBaseResponse = z.infer;
type JsonRpcBaseNotification = z.infer;
type CommandAck = z.infer;
type JsonRpcMessage = z.infer;
declare const HostIdSchema: z.ZodString;
declare const ComputerRegistrationSchema: z.ZodObject<{
computerId: z.ZodString;
firestoreOrgId: z.ZodString;
userId: z.ZodString;
registeredAt: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
computerId: string;
firestoreOrgId: string;
userId: string;
registeredAt: number;
}, {
computerId: string;
firestoreOrgId: string;
userId: string;
registeredAt: number;
}>;
declare const HostConfigSchema: z.ZodObject<{
schemaVersion: z.ZodLiteral<1>;
hostId: z.ZodString;
createdAt: z.ZodNumber;
computerRegistration: z.ZodOptional>;
}, "strip", z.ZodTypeAny, {
createdAt: number;
schemaVersion: 1;
hostId: string;
computerRegistration?: {
computerId: string;
firestoreOrgId: string;
userId: string;
registeredAt: number;
} | undefined;
}, {
createdAt: number;
schemaVersion: 1;
hostId: string;
computerRegistration?: {
computerId: string;
firestoreOrgId: string;
userId: string;
registeredAt: number;
} | undefined;
}>;
declare const LegacyComputerConfigSchema: z.ZodObject<{
computerId: z.ZodString;
registeredAt: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
computerId: string;
registeredAt: number;
}, {
computerId: string;
registeredAt: number;
}>;
type ComputerRegistration = z.infer;
type HostConfig = z.infer;
type LegacyComputerConfig = z.infer;
type ResolvedComputerRegistration = Omit;
type ResolvedHostIdentity = {
hostId: string;
computerRegistration?: ResolvedComputerRegistration;
};
declare const SessionTagSchema: z.ZodObject<{
name: z.ZodString;
metadata: z.ZodOptional>;
}, "strip", z.ZodTypeAny, {
name: string;
metadata?: Record | undefined;
}, {
name: string;
metadata?: Record | undefined;
}>;
type SessionTag = z.infer;
interface MissionSessionTagMetadata {
role: DecompSessionType;
missionId: string;
}
/**
* Token usage schema for session settings.
* Tracks LLM token consumption for a session.
*/
declare const TokenUsageSchema$1: z.ZodObject<{
inputTokens: z.ZodNumber;
outputTokens: z.ZodNumber;
cacheCreationTokens: z.ZodNumber;
cacheReadTokens: z.ZodNumber;
thinkingTokens: z.ZodNumber;
factoryCredits: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
inputTokens: number;
outputTokens: number;
cacheCreationTokens: number;
cacheReadTokens: number;
thinkingTokens: number;
factoryCredits?: number | undefined;
}, {
inputTokens: number;
outputTokens: number;
cacheCreationTokens: number;
cacheReadTokens: number;
thinkingTokens: number;
factoryCredits?: number | undefined;
}>;
type TokenUsage = z.infer;
declare const SlackSourceSchema: z.ZodObject<{
platform: z.ZodLiteral;
teamId: z.ZodOptional>;
channel: z.ZodOptional>;
threadTs: z.ZodOptional>;
userId: z.ZodOptional>;
}, "strip", z.ZodTypeAny, {
platform: SessionPlatform.Slack;
userId?: string | null | undefined;
teamId?: string | null | undefined;
channel?: string | null | undefined;
threadTs?: string | null | undefined;
}, {
platform: SessionPlatform.Slack;
userId?: string | null | undefined;
teamId?: string | null | undefined;
channel?: string | null | undefined;
threadTs?: string | null | undefined;
}>;
declare const WebSourceSchema: z.ZodObject<{
platform: z.ZodLiteral;
}, "strip", z.ZodTypeAny, {
platform: SessionPlatform.Web;
}, {
platform: SessionPlatform.Web;
}>;
declare const ApiSourceSchema: z.ZodObject<{
platform: z.ZodLiteral;
}, "strip", z.ZodTypeAny, {
platform: SessionPlatform.Api;
}, {
platform: SessionPlatform.Api;
}>;
declare const SessionsApiSourceSchema: z.ZodObject<{
platform: z.ZodLiteral;
}, "strip", z.ZodTypeAny, {
platform: SessionPlatform.SessionsApi;
}, {
platform: SessionPlatform.SessionsApi;
}>;
declare const LinearSourceSchema: z.ZodObject<{
platform: z.ZodLiteral;
agentSessionId: z.ZodString;
issueId: z.ZodOptional>;
issueUrl: z.ZodOptional>;
issueIdentifier: z.ZodOptional>;
organizationId: z.ZodOptional>;
userId: z.ZodOptional>;
}, "strip", z.ZodTypeAny, {
platform: SessionPlatform.Linear;
agentSessionId: string;
userId?: string | null | undefined;
issueId?: string | null | undefined;
issueUrl?: string | null | undefined;
issueIdentifier?: string | null | undefined;
organizationId?: string | null | undefined;
}, {
platform: SessionPlatform.Linear;
agentSessionId: string;
userId?: string | null | undefined;
issueId?: string | null | undefined;
issueUrl?: string | null | undefined;
issueIdentifier?: string | null | undefined;
organizationId?: string | null | undefined;
}>;
declare const ReadinessRemediationSourceSchema: z.ZodObject<{
platform: z.ZodLiteral;
reportId: z.ZodString;
repoUrl: z.ZodString;
criterionId: z.ZodString;
}, "strip", z.ZodTypeAny, {
platform: SessionPlatform.ReadinessRemediation;
reportId: string;
repoUrl: string;
criterionId: string;
}, {
platform: SessionPlatform.ReadinessRemediation;
reportId: string;
repoUrl: string;
criterionId: string;
}>;
declare const ReadinessEvaluationSourceSchema: z.ZodObject<{
platform: z.ZodLiteral;
repoUrl: z.ZodString;
}, "strip", z.ZodTypeAny, {
platform: SessionPlatform.ReadinessEvaluation;
repoUrl: string;
}, {
platform: SessionPlatform.ReadinessEvaluation;
repoUrl: string;
}>;
declare const AutomationSourceSchema: z.ZodObject<{
platform: z.ZodLiteral;
automationId: z.ZodString;
computerId: z.ZodString;
}, "strip", z.ZodTypeAny, {
platform: SessionPlatform.Automation;
computerId: string;
automationId: string;
}, {
platform: SessionPlatform.Automation;
computerId: string;
automationId: string;
}>;
declare const WikiGenerationSourceSchema: z.ZodObject<{
platform: z.ZodLiteral;
repoUrl: z.ZodString;
}, "strip", z.ZodTypeAny, {
platform: SessionPlatform.WikiGeneration;
repoUrl: string;
}, {
platform: SessionPlatform.WikiGeneration;
repoUrl: string;
}>;
declare const WikiCISetupSourceSchema: z.ZodObject<{
platform: z.ZodLiteral;
repoUrl: z.ZodString;
}, "strip", z.ZodTypeAny, {
platform: SessionPlatform.WikiCISetup;
repoUrl: string;
}, {
platform: SessionPlatform.WikiCISetup;
repoUrl: string;
}>;
declare const SessionSourceSchema: z.ZodDiscriminatedUnion<"platform", [z.ZodObject<{
platform: z.ZodLiteral;
teamId: z.ZodOptional>;
channel: z.ZodOptional>;
threadTs: z.ZodOptional>;
userId: z.ZodOptional>;
} & {
delegationSessionId: z.ZodString;
}, "strip", z.ZodTypeAny, {
platform: SessionPlatform.Slack;
delegationSessionId: string;
userId?: string | null | undefined;
teamId?: string | null | undefined;
channel?: string | null | undefined;
threadTs?: string | null | undefined;
}, {
platform: SessionPlatform.Slack;
delegationSessionId: string;
userId?: string | null | undefined;
teamId?: string | null | undefined;
channel?: string | null | undefined;
threadTs?: string | null | undefined;
}>, z.ZodObject<{
platform: z.ZodLiteral;
} & {
delegationSessionId: z.ZodString;
}, "strip", z.ZodTypeAny, {
platform: SessionPlatform.Web;
delegationSessionId: string;
}, {
platform: SessionPlatform.Web;
delegationSessionId: string;
}>, z.ZodObject<{
platform: z.ZodLiteral;
} & {
delegationSessionId: z.ZodString;
}, "strip", z.ZodTypeAny, {
platform: SessionPlatform.Api;
delegationSessionId: string;
}, {
platform: SessionPlatform.Api;
delegationSessionId: string;
}>, z.ZodObject<{
platform: z.ZodLiteral;
} & {
delegationSessionId: z.ZodString;
}, "strip", z.ZodTypeAny, {
platform: SessionPlatform.SessionsApi;
delegationSessionId: string;
}, {
platform: SessionPlatform.SessionsApi;
delegationSessionId: string;
}>, z.ZodObject<{
platform: z.ZodLiteral;
agentSessionId: z.ZodString;
issueId: z.ZodOptional>;
issueUrl: z.ZodOptional>;
issueIdentifier: z.ZodOptional>;
organizationId: z.ZodOptional>;
userId: z.ZodOptional>;
} & {
delegationSessionId: z.ZodString;
}, "strip", z.ZodTypeAny, {
platform: SessionPlatform.Linear;
agentSessionId: string;
delegationSessionId: string;
userId?: string | null | undefined;
issueId?: string | null | undefined;
issueUrl?: string | null | undefined;
issueIdentifier?: string | null | undefined;
organizationId?: string | null | undefined;
}, {
platform: SessionPlatform.Linear;
agentSessionId: string;
delegationSessionId: string;
userId?: string | null | undefined;
issueId?: string | null | undefined;
issueUrl?: string | null | undefined;
issueIdentifier?: string | null | undefined;
organizationId?: string | null | undefined;
}>, z.ZodObject<{
platform: z.ZodLiteral;
reportId: z.ZodString;
repoUrl: z.ZodString;
criterionId: z.ZodString;
}, "strip", z.ZodTypeAny, {
platform: SessionPlatform.ReadinessRemediation;
reportId: string;
repoUrl: string;
criterionId: string;
}, {
platform: SessionPlatform.ReadinessRemediation;
reportId: string;
repoUrl: string;
criterionId: string;
}>, z.ZodObject<{
platform: z.ZodLiteral;
repoUrl: z.ZodString;
}, "strip", z.ZodTypeAny, {
platform: SessionPlatform.ReadinessEvaluation;
repoUrl: string;
}, {
platform: SessionPlatform.ReadinessEvaluation;
repoUrl: string;
}>, z.ZodObject<{
platform: z.ZodLiteral;
automationId: z.ZodString;
computerId: z.ZodString;
}, "strip", z.ZodTypeAny, {
platform: SessionPlatform.Automation;
computerId: string;
automationId: string;
}, {
platform: SessionPlatform.Automation;
computerId: string;
automationId: string;
}>, z.ZodObject<{
platform: z.ZodLiteral;
repoUrl: z.ZodString;
}, "strip", z.ZodTypeAny, {
platform: SessionPlatform.WikiGeneration;
repoUrl: string;
}, {
platform: SessionPlatform.WikiGeneration;
repoUrl: string;
}>, z.ZodObject<{
platform: z.ZodLiteral;
repoUrl: z.ZodString;
}, "strip", z.ZodTypeAny, {
platform: SessionPlatform.WikiCISetup;
repoUrl: string;
}, {
platform: SessionPlatform.WikiCISetup;
repoUrl: string;
}>]>;
type SlackSource = z.infer;
type WebSource = z.infer;
type ApiSource = z.infer;
type SessionsApiSource = z.infer;
type LinearSource = z.infer;
type ReadinessRemediationSource = z.infer;
type ReadinessEvaluationSource = z.infer;
type AutomationSource = z.infer;
type WikiGenerationSource = z.infer;
type WikiCISetupSource = z.infer;
type PlatformSource = SlackSource | WebSource | ApiSource | SessionsApiSource | LinearSource | ReadinessRemediationSource | ReadinessEvaluationSource | AutomationSource | WikiGenerationSource | WikiCISetupSource;
type SessionSource = z.infer;
declare const BaseContentBlockSchema: z.ZodObject<{
id: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
id?: string | undefined;
}, {
id?: string | undefined;
}>;
declare const TextBlockSchema: z.ZodObject<{
id: z.ZodOptional;
} & {
type: z.ZodLiteral;
text: z.ZodString;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.Text;
text: string;
id?: string | undefined;
}, {
type: MessageContentBlockType.Text;
text: string;
id?: string | undefined;
}>;
declare const Base64ImageSourceSchema: z.ZodObject<{
type: z.ZodLiteral<"base64">;
data: z.ZodString;
mediaType: z.ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
}, "strip", z.ZodTypeAny, {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
}, {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
}>;
declare const ImageBlockSchema: z.ZodObject<{
id: z.ZodOptional;
} & {
type: z.ZodLiteral;
source: z.ZodObject<{
type: z.ZodLiteral<"base64">;
data: z.ZodString;
mediaType: z.ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
}, "strip", z.ZodTypeAny, {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
}, {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
}>;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.Image;
source: {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
};
id?: string | undefined;
}, {
type: MessageContentBlockType.Image;
source: {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
};
id?: string | undefined;
}>;
declare const ThinkingBlockSchema: z.ZodObject<{
id: z.ZodOptional;
} & {
type: z.ZodLiteral;
signature: z.ZodString;
signatureProvider: z.ZodOptional, z.ZodLiteral<"unknown">]>>;
thinking: z.ZodString;
durationMs: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.Thinking;
thinking: string;
signature: string;
id?: string | undefined;
signatureProvider?: "unknown" | ModelProvider | undefined;
durationMs?: number | undefined;
}, {
type: MessageContentBlockType.Thinking;
thinking: string;
signature: string;
id?: string | undefined;
signatureProvider?: "unknown" | ModelProvider | undefined;
durationMs?: number | undefined;
}>;
declare const RedactedThinkingBlockSchema: z.ZodObject<{
id: z.ZodOptional;
} & {
type: z.ZodLiteral;
data: z.ZodString;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.RedactedThinking;
data: string;
id?: string | undefined;
}, {
type: MessageContentBlockType.RedactedThinking;
data: string;
id?: string | undefined;
}>;
declare const ToolUseSchema: z.ZodObject<{
type: z.ZodLiteral;
id: z.ZodString;
input: z.ZodRecord;
name: z.ZodString;
thoughtSignature: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.ToolUse;
id: string;
name: string;
input: Record;
thoughtSignature?: string | undefined;
}, {
type: MessageContentBlockType.ToolUse;
id: string;
name: string;
input: Record;
thoughtSignature?: string | undefined;
}>;
declare const Base64PDFSourceSchema: z.ZodObject<{
type: z.ZodLiteral;
mediaType: z.ZodLiteral<"application/pdf">;
data: z.ZodString;
parsedData: z.ZodOptional;
name: z.ZodOptional;
path: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
}, {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
}>;
declare const PlainTextSourceSchema: z.ZodObject<{
type: z.ZodLiteral;
mediaType: z.ZodLiteral<"text/plain">;
data: z.ZodString;
name: z.ZodOptional;
mime: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
}, {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
}>;
declare const DocumentSourceSchema: z.ZodUnion<[z.ZodObject<{
type: z.ZodLiteral;
mediaType: z.ZodLiteral<"application/pdf">;
data: z.ZodString;
parsedData: z.ZodOptional;
name: z.ZodOptional;
path: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
}, {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
}>, z.ZodObject<{
type: z.ZodLiteral;
mediaType: z.ZodLiteral<"text/plain">;
data: z.ZodString;
name: z.ZodOptional;
mime: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
}, {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
}>]>;
declare const DocumentBlockSchema: z.ZodObject<{
id: z.ZodOptional;
} & {
type: z.ZodLiteral;
source: z.ZodUnion<[z.ZodObject<{
type: z.ZodLiteral;
mediaType: z.ZodLiteral<"application/pdf">;
data: z.ZodString;
parsedData: z.ZodOptional;
name: z.ZodOptional;
path: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
}, {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
}>, z.ZodObject<{
type: z.ZodLiteral;
mediaType: z.ZodLiteral<"text/plain">;
data: z.ZodString;
name: z.ZodOptional;
mime: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
}, {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
}>]>;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.Document;
source: {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
} | {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
};
id?: string | undefined;
}, {
type: MessageContentBlockType.Document;
source: {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
} | {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
};
id?: string | undefined;
}>;
declare const ToolResultSchema: z.ZodObject<{
id: z.ZodOptional;
} & {
type: z.ZodLiteral;
toolUseId: z.ZodString;
content: z.ZodOptional;
} & {
type: z.ZodLiteral;
text: z.ZodString;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.Text;
text: string;
id?: string | undefined;
}, {
type: MessageContentBlockType.Text;
text: string;
id?: string | undefined;
}>, z.ZodObject<{
id: z.ZodOptional;
} & {
type: z.ZodLiteral;
source: z.ZodObject<{
type: z.ZodLiteral<"base64">;
data: z.ZodString;
mediaType: z.ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
}, "strip", z.ZodTypeAny, {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
}, {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
}>;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.Image;
source: {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
};
id?: string | undefined;
}, {
type: MessageContentBlockType.Image;
source: {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
};
id?: string | undefined;
}>, z.ZodObject<{
id: z.ZodOptional;
} & {
type: z.ZodLiteral;
source: z.ZodUnion<[z.ZodObject<{
type: z.ZodLiteral;
mediaType: z.ZodLiteral<"application/pdf">;
data: z.ZodString;
parsedData: z.ZodOptional;
name: z.ZodOptional;
path: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
}, {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
}>, z.ZodObject<{
type: z.ZodLiteral;
mediaType: z.ZodLiteral<"text/plain">;
data: z.ZodString;
name: z.ZodOptional;
mime: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
}, {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
}>]>;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.Document;
source: {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
} | {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
};
id?: string | undefined;
}, {
type: MessageContentBlockType.Document;
source: {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
} | {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
};
id?: string | undefined;
}>]>, "many">]>>;
isError: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.ToolResult;
toolUseId: string;
id?: string | undefined;
content?: string | ({
type: MessageContentBlockType.Text;
text: string;
id?: string | undefined;
} | {
type: MessageContentBlockType.Image;
source: {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
};
id?: string | undefined;
} | {
type: MessageContentBlockType.Document;
source: {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
} | {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
};
id?: string | undefined;
})[] | undefined;
isError?: boolean | undefined;
}, {
type: MessageContentBlockType.ToolResult;
toolUseId: string;
id?: string | undefined;
content?: string | ({
type: MessageContentBlockType.Text;
text: string;
id?: string | undefined;
} | {
type: MessageContentBlockType.Image;
source: {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
};
id?: string | undefined;
} | {
type: MessageContentBlockType.Document;
source: {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
} | {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
};
id?: string | undefined;
})[] | undefined;
isError?: boolean | undefined;
}>;
declare const ContentBlockSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
id: z.ZodOptional;
} & {
type: z.ZodLiteral;
text: z.ZodString;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.Text;
text: string;
id?: string | undefined;
}, {
type: MessageContentBlockType.Text;
text: string;
id?: string | undefined;
}>, z.ZodObject<{
id: z.ZodOptional;
} & {
type: z.ZodLiteral;
source: z.ZodObject<{
type: z.ZodLiteral<"base64">;
data: z.ZodString;
mediaType: z.ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
}, "strip", z.ZodTypeAny, {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
}, {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
}>;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.Image;
source: {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
};
id?: string | undefined;
}, {
type: MessageContentBlockType.Image;
source: {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
};
id?: string | undefined;
}>, z.ZodObject<{
id: z.ZodOptional;
} & {
type: z.ZodLiteral;
signature: z.ZodString;
signatureProvider: z.ZodOptional, z.ZodLiteral<"unknown">]>>;
thinking: z.ZodString;
durationMs: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.Thinking;
thinking: string;
signature: string;
id?: string | undefined;
signatureProvider?: "unknown" | ModelProvider | undefined;
durationMs?: number | undefined;
}, {
type: MessageContentBlockType.Thinking;
thinking: string;
signature: string;
id?: string | undefined;
signatureProvider?: "unknown" | ModelProvider | undefined;
durationMs?: number | undefined;
}>, z.ZodObject<{
id: z.ZodOptional;
} & {
type: z.ZodLiteral;
data: z.ZodString;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.RedactedThinking;
data: string;
id?: string | undefined;
}, {
type: MessageContentBlockType.RedactedThinking;
data: string;
id?: string | undefined;
}>, z.ZodObject<{
type: z.ZodLiteral;
id: z.ZodString;
input: z.ZodRecord;
name: z.ZodString;
thoughtSignature: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.ToolUse;
id: string;
name: string;
input: Record;
thoughtSignature?: string | undefined;
}, {
type: MessageContentBlockType.ToolUse;
id: string;
name: string;
input: Record;
thoughtSignature?: string | undefined;
}>, z.ZodObject<{
id: z.ZodOptional;
} & {
type: z.ZodLiteral;
toolUseId: z.ZodString;
content: z.ZodOptional;
} & {
type: z.ZodLiteral;
text: z.ZodString;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.Text;
text: string;
id?: string | undefined;
}, {
type: MessageContentBlockType.Text;
text: string;
id?: string | undefined;
}>, z.ZodObject<{
id: z.ZodOptional;
} & {
type: z.ZodLiteral;
source: z.ZodObject<{
type: z.ZodLiteral<"base64">;
data: z.ZodString;
mediaType: z.ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
}, "strip", z.ZodTypeAny, {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
}, {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
}>;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.Image;
source: {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
};
id?: string | undefined;
}, {
type: MessageContentBlockType.Image;
source: {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
};
id?: string | undefined;
}>, z.ZodObject<{
id: z.ZodOptional;
} & {
type: z.ZodLiteral;
source: z.ZodUnion<[z.ZodObject<{
type: z.ZodLiteral;
mediaType: z.ZodLiteral<"application/pdf">;
data: z.ZodString;
parsedData: z.ZodOptional;
name: z.ZodOptional;
path: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
}, {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
}>, z.ZodObject<{
type: z.ZodLiteral;
mediaType: z.ZodLiteral<"text/plain">;
data: z.ZodString;
name: z.ZodOptional;
mime: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
}, {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
}>]>;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.Document;
source: {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
} | {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
};
id?: string | undefined;
}, {
type: MessageContentBlockType.Document;
source: {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
} | {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
};
id?: string | undefined;
}>]>, "many">]>>;
isError: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.ToolResult;
toolUseId: string;
id?: string | undefined;
content?: string | ({
type: MessageContentBlockType.Text;
text: string;
id?: string | undefined;
} | {
type: MessageContentBlockType.Image;
source: {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
};
id?: string | undefined;
} | {
type: MessageContentBlockType.Document;
source: {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
} | {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
};
id?: string | undefined;
})[] | undefined;
isError?: boolean | undefined;
}, {
type: MessageContentBlockType.ToolResult;
toolUseId: string;
id?: string | undefined;
content?: string | ({
type: MessageContentBlockType.Text;
text: string;
id?: string | undefined;
} | {
type: MessageContentBlockType.Image;
source: {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
};
id?: string | undefined;
} | {
type: MessageContentBlockType.Document;
source: {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
} | {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
};
id?: string | undefined;
})[] | undefined;
isError?: boolean | undefined;
}>, z.ZodObject<{
id: z.ZodOptional;
} & {
type: z.ZodLiteral;
source: z.ZodUnion<[z.ZodObject<{
type: z.ZodLiteral;
mediaType: z.ZodLiteral<"application/pdf">;
data: z.ZodString;
parsedData: z.ZodOptional;
name: z.ZodOptional;
path: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
}, {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
}>, z.ZodObject<{
type: z.ZodLiteral;
mediaType: z.ZodLiteral<"text/plain">;
data: z.ZodString;
name: z.ZodOptional;
mime: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
}, {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
}>]>;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.Document;
source: {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
} | {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
};
id?: string | undefined;
}, {
type: MessageContentBlockType.Document;
source: {
type: DocumentSourceType.Base64;
data: string;
mediaType: "application/pdf";
path?: string | undefined;
name?: string | undefined;
parsedData?: string | undefined;
} | {
type: DocumentSourceType.Text;
data: string;
mediaType: "text/plain";
name?: string | undefined;
mime?: string | undefined;
};
id?: string | undefined;
}>]>;
declare const CacheLabelSchema: z.ZodObject<{
cache_control: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: "ephemeral";
}, {
type: "ephemeral";
}>>;
}, "strip", z.ZodTypeAny, {
cache_control?: {
type: "ephemeral";
} | undefined;
}, {
cache_control?: {
type: "ephemeral";
} | undefined;
}>;
declare const FactoryDroidMessageSchema: z.ZodObject<{
id: z.ZodString;
role: z.ZodNativeEnum;
content: z.ZodArray;
} & {
type: z.ZodLiteral;
text: z.ZodString;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.Text;
text: string;
id?: string | undefined;
}, {
type: MessageContentBlockType.Text;
text: string;
id?: string | undefined;
}>, z.ZodObject<{
id: z.ZodOptional;
} & {
type: z.ZodLiteral;
source: z.ZodObject<{
type: z.ZodLiteral<"base64">;
data: z.ZodString;
mediaType: z.ZodEnum<["image/jpeg", "image/png", "image/gif", "image/webp"]>;
}, "strip", z.ZodTypeAny, {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
}, {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
}>;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.Image;
source: {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
};
id?: string | undefined;
}, {
type: MessageContentBlockType.Image;
source: {
type: "base64";
data: string;
mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
};
id?: string | undefined;
}>, z.ZodObject<{
id: z.ZodOptional;
} & {
type: z.ZodLiteral;
signature: z.ZodString;
signatureProvider: z.ZodOptional, z.ZodLiteral<"unknown">]>>;
thinking: z.ZodString;
durationMs: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.Thinking;
thinking: string;
signature: string;
id?: string | undefined;
signatureProvider?: "unknown" | ModelProvider | undefined;
durationMs?: number | undefined;
}, {
type: MessageContentBlockType.Thinking;
thinking: string;
signature: string;
id?: string | undefined;
signatureProvider?: "unknown" | ModelProvider | undefined;
durationMs?: number | undefined;
}>, z.ZodObject<{
id: z.ZodOptional;
} & {
type: z.ZodLiteral;
data: z.ZodString;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.RedactedThinking;
data: string;
id?: string | undefined;
}, {
type: MessageContentBlockType.RedactedThinking;
data: string;
id?: string | undefined;
}>, z.ZodObject<{
type: z.ZodLiteral;
id: z.ZodString;
input: z.ZodRecord;
name: z.ZodString;
thoughtSignature: z.ZodOptional;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.ToolUse;
id: string;
name: string;
input: Record;
thoughtSignature?: string | undefined;
}, {
type: MessageContentBlockType.ToolUse;
id: string;
name: string;
input: Record;
thoughtSignature?: string | undefined;
}>, z.ZodObject<{
id: z.ZodOptional;
} & {
type: z.ZodLiteral;
toolUseId: z.ZodString;
content: z.ZodOptional;
} & {
type: z.ZodLiteral;
text: z.ZodString;
}, "strip", z.ZodTypeAny, {
type: MessageContentBlockType.Text;
text: string;
id?: string | undefined;
}, {
type: MessageContentBlockType.Text;
text: string;
id?: string | undefined;
}>, z.ZodObject<{
id: z.ZodOptional