npm - @cognidesk/core - Versions diffs - 0.0.3-dev.2 → 0.0.3-dev.4 - Mend

@cognidesk/core 0.0.3-dev.2 → 0.0.3-dev.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/index.d.ts CHANGED Viewed

@@ -133,6 +133,7 @@ declare const telemetrySpanNames: {
     readonly runtimeReplayConversation: "cognidesk.runtime.replay_conversation";
     readonly runtimeSubmitWidget: "cognidesk.runtime.submit_widget";
     readonly runtimeGetSnapshot: "cognidesk.runtime.get_snapshot";
+    readonly runtimeHandleChannelEvent: "cognidesk.runtime.handle_channel_event";
     readonly runtimeHandleUserMessage: "cognidesk.runtime.handle_user_message";
     readonly runtimeCloseConversation: "cognidesk.runtime.close_conversation";
     readonly runtimeRequestHandoff: "cognidesk.runtime.request_handoff";
@@ -195,6 +196,1062 @@ declare function addTelemetryContentEvent(options: TelemetryOptionsCarrier, name
 declare function activeRuntimeEventTelemetry(options: TelemetryOptionsCarrier): RuntimeEventTelemetry | undefined;
 declare function createTelemetryContext(options: TelemetryOptionsCarrier): TelemetryContext;
+declare const coreConversationChannels: readonly ["chat", "voice", "email", "ticketing", "contactCenter", "messaging", "sms", "workplace", "social", "form", "helpCenter", "community", "ecommerce", "marketplace", "review", "video", "cobrowsing", "rcs"];
+declare const coreProviderCategories: readonly ["model", "storage", "chat", "voice", "email", "ticketing", "contactCenter", "handoff", "studio", "messaging", "sms", "workplace", "social", "form", "helpCenter", "community", "ecommerce", "marketplace", "review", "video", "cobrowsing", "rcs"];
+declare const coreChannelCapabilities: readonly ["receive", "send", "draft", "thread", "attach", "media", "handoff", "schedule", "cleanup", "notify", "transfer", "artifact", "create-provider-object", "read-provider-object", "update-provider-object", "delete-provider-object", "search-provider-object", "link-provider-object"];
+declare const providerTrustLevels: readonly ["official", "verified", "community", "experimental"];
+declare const providerDirections: readonly ["receive-only", "send-only", "inbound-only", "outbound-only", "bidirectional"];
+declare const channelAudiences: readonly ["customer-facing", "internal-support", "mixed"];
+declare const capabilityAvailabilityStatuses: readonly ["registry-available", "installed", "configured", "enabled", "blocked"];
+declare const providerCredentialStatuses: readonly ["not-required", "required", "configured", "missing", "expired", "insufficient-scope", "permission-blocked", "unavailable"];
+declare const categoryOperationLevels: readonly ["required", "recommended", "optional", "extension"];
+declare const providerCapabilityCoverageLevels: readonly ["partial", "standard", "full"];
+declare const categoryEventDirections: readonly ["inbound", "outbound", "internal", "bidirectional"];
+type Extensible$1<T extends string> = T | (string & {});
+type CoreConversationChannel = typeof coreConversationChannels[number];
+type ConversationChannelKind = Extensible$1<CoreConversationChannel>;
+type CoreProviderCategory = typeof coreProviderCategories[number];
+type ProviderCategory = Extensible$1<CoreProviderCategory>;
+type CoreChannelCapability = typeof coreChannelCapabilities[number];
+type ChannelCapability = Extensible$1<CoreChannelCapability>;
+type ProviderTrustLevel = typeof providerTrustLevels[number];
+type ProviderDirection = typeof providerDirections[number];
+type ChannelAudience = typeof channelAudiences[number];
+type ActionAudience = ChannelAudience;
+type CapabilityAvailabilityStatus = typeof capabilityAvailabilityStatuses[number];
+type ProviderCredentialState = typeof providerCredentialStatuses[number];
+type CategoryOperationLevel = typeof categoryOperationLevels[number];
+type ProviderCapabilityCoverage = typeof providerCapabilityCoverageLevels[number];
+type CategoryEventDirection = typeof categoryEventDirections[number];
+declare const ConversationChannelKindSchema: z.ZodString;
+declare const ProviderCategorySchema: z.ZodString;
+declare const CoreChannelCapabilitySchema: z.ZodEnum<{
+    handoff: "handoff";
+    receive: "receive";
+    send: "send";
+    draft: "draft";
+    thread: "thread";
+    attach: "attach";
+    media: "media";
+    schedule: "schedule";
+    cleanup: "cleanup";
+    notify: "notify";
+    transfer: "transfer";
+    artifact: "artifact";
+    "create-provider-object": "create-provider-object";
+    "read-provider-object": "read-provider-object";
+    "update-provider-object": "update-provider-object";
+    "delete-provider-object": "delete-provider-object";
+    "search-provider-object": "search-provider-object";
+    "link-provider-object": "link-provider-object";
+}>;
+declare const ChannelCapabilitySchema: z.ZodString;
+declare const ProviderTrustLevelSchema: z.ZodEnum<{
+    community: "community";
+    official: "official";
+    verified: "verified";
+    experimental: "experimental";
+}>;
+declare const ProviderDirectionSchema: z.ZodEnum<{
+    "receive-only": "receive-only";
+    "send-only": "send-only";
+    "inbound-only": "inbound-only";
+    "outbound-only": "outbound-only";
+    bidirectional: "bidirectional";
+}>;
+declare const ChannelAudienceSchema: z.ZodEnum<{
+    "customer-facing": "customer-facing";
+    "internal-support": "internal-support";
+    mixed: "mixed";
+}>;
+declare const ActionAudienceSchema: z.ZodEnum<{
+    "customer-facing": "customer-facing";
+    "internal-support": "internal-support";
+    mixed: "mixed";
+}>;
+declare const CapabilityAvailabilityStatusSchema: z.ZodEnum<{
+    "registry-available": "registry-available";
+    installed: "installed";
+    configured: "configured";
+    enabled: "enabled";
+    blocked: "blocked";
+}>;
+declare const ProviderCredentialStateSchema: z.ZodEnum<{
+    required: "required";
+    configured: "configured";
+    "not-required": "not-required";
+    missing: "missing";
+    expired: "expired";
+    "insufficient-scope": "insufficient-scope";
+    "permission-blocked": "permission-blocked";
+    unavailable: "unavailable";
+}>;
+declare const CategoryOperationLevelSchema: z.ZodEnum<{
+    required: "required";
+    recommended: "recommended";
+    optional: "optional";
+    extension: "extension";
+}>;
+declare const ProviderCapabilityCoverageSchema: z.ZodEnum<{
+    full: "full";
+    partial: "partial";
+    standard: "standard";
+}>;
+declare const CategoryEventDirectionSchema: z.ZodEnum<{
+    bidirectional: "bidirectional";
+    inbound: "inbound";
+    outbound: "outbound";
+    internal: "internal";
+}>;
+declare const ChannelCapabilityFlagsSchema: z.ZodDefault<z.ZodObject<{
+    realtime: z.ZodDefault<z.ZodBoolean>;
+    async: z.ZodDefault<z.ZodBoolean>;
+    voice: z.ZodDefault<z.ZodBoolean>;
+    audioInput: z.ZodDefault<z.ZodBoolean>;
+    audioOutput: z.ZodDefault<z.ZodBoolean>;
+    richText: z.ZodDefault<z.ZodBoolean>;
+    markdown: z.ZodDefault<z.ZodBoolean>;
+    html: z.ZodDefault<z.ZodBoolean>;
+    attachments: z.ZodDefault<z.ZodBoolean>;
+    images: z.ZodDefault<z.ZodBoolean>;
+    files: z.ZodDefault<z.ZodBoolean>;
+    widgets: z.ZodDefault<z.ZodBoolean>;
+    buttons: z.ZodDefault<z.ZodBoolean>;
+    quickReplies: z.ZodDefault<z.ZodBoolean>;
+    templates: z.ZodDefault<z.ZodBoolean>;
+    publicReplies: z.ZodDefault<z.ZodBoolean>;
+    privateReplies: z.ZodDefault<z.ZodBoolean>;
+    typingIndicator: z.ZodDefault<z.ZodBoolean>;
+    readReceipts: z.ZodDefault<z.ZodBoolean>;
+    deliveryReceipts: z.ZodDefault<z.ZodBoolean>;
+    threaded: z.ZodDefault<z.ZodBoolean>;
+    supportsHumanTransfer: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>>;
+type ChannelCapabilityFlags = z.infer<typeof ChannelCapabilityFlagsSchema>;
+type ChannelCapabilityFlagsInput = z.input<typeof ChannelCapabilityFlagsSchema>;
+declare const ChannelContextSchema: z.ZodObject<{
+    channelId: z.ZodString;
+    kind: z.ZodString;
+    provider: z.ZodOptional<z.ZodString>;
+    externalThreadId: z.ZodOptional<z.ZodString>;
+    externalConversationId: z.ZodOptional<z.ZodString>;
+    externalMessageId: z.ZodOptional<z.ZodString>;
+    externalUserId: z.ZodOptional<z.ZodString>;
+    locale: z.ZodOptional<z.ZodString>;
+    timezone: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodDefault<z.ZodDefault<z.ZodObject<{
+        realtime: z.ZodDefault<z.ZodBoolean>;
+        async: z.ZodDefault<z.ZodBoolean>;
+        voice: z.ZodDefault<z.ZodBoolean>;
+        audioInput: z.ZodDefault<z.ZodBoolean>;
+        audioOutput: z.ZodDefault<z.ZodBoolean>;
+        richText: z.ZodDefault<z.ZodBoolean>;
+        markdown: z.ZodDefault<z.ZodBoolean>;
+        html: z.ZodDefault<z.ZodBoolean>;
+        attachments: z.ZodDefault<z.ZodBoolean>;
+        images: z.ZodDefault<z.ZodBoolean>;
+        files: z.ZodDefault<z.ZodBoolean>;
+        widgets: z.ZodDefault<z.ZodBoolean>;
+        buttons: z.ZodDefault<z.ZodBoolean>;
+        quickReplies: z.ZodDefault<z.ZodBoolean>;
+        templates: z.ZodDefault<z.ZodBoolean>;
+        publicReplies: z.ZodDefault<z.ZodBoolean>;
+        privateReplies: z.ZodDefault<z.ZodBoolean>;
+        typingIndicator: z.ZodDefault<z.ZodBoolean>;
+        readReceipts: z.ZodDefault<z.ZodBoolean>;
+        deliveryReceipts: z.ZodDefault<z.ZodBoolean>;
+        threaded: z.ZodDefault<z.ZodBoolean>;
+        supportsHumanTransfer: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type ChannelContext = z.infer<typeof ChannelContextSchema>;
+type ChannelContextInput = Omit<z.input<typeof ChannelContextSchema>, "capabilities"> & {
+    capabilities?: Partial<ChannelCapabilityFlagsInput>;
+};
+type ConversationChannel = ConversationChannelKind | ChannelContext;
+type ConversationChannelInput = ConversationChannelKind | ChannelContextInput;
+declare function defineChannelContext(input: ConversationChannelInput): ChannelContext;
+declare function channelKindOf(channel?: ConversationChannelInput): ConversationChannelKind | undefined;
+declare function defaultChannelCapabilityFlags(kind: ConversationChannelKind): ChannelCapabilityFlags;
+declare const ProviderObjectDescriptorSchema: z.ZodObject<{
+    kind: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    schemaName: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type ProviderObjectDescriptor = z.infer<typeof ProviderObjectDescriptorSchema>;
+declare const ChannelCapabilityDeclarationSchema: z.ZodObject<{
+    capability: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    audiences: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "customer-facing": "customer-facing";
+        "internal-support": "internal-support";
+        mixed: "mixed";
+    }>>>;
+    providerObjects: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        schemaName: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    requiresCredential: z.ZodOptional<z.ZodBoolean>;
+    sideEffect: z.ZodOptional<z.ZodBoolean>;
+    exposesSensitiveData: z.ZodOptional<z.ZodBoolean>;
+    changesWorkflow: z.ZodOptional<z.ZodBoolean>;
+    extension: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type ChannelCapabilityDeclaration = z.infer<typeof ChannelCapabilityDeclarationSchema>;
+declare const CategoryOperationDeclarationSchema: z.ZodObject<{
+    alias: z.ZodString;
+    capability: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    providerObject: z.ZodOptional<z.ZodString>;
+    providerObjects: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        schemaName: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    audience: z.ZodOptional<z.ZodEnum<{
+        "customer-facing": "customer-facing";
+        "internal-support": "internal-support";
+        mixed: "mixed";
+    }>>;
+    audiences: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "customer-facing": "customer-facing";
+        "internal-support": "internal-support";
+        mixed: "mixed";
+    }>>>;
+    requiresCredential: z.ZodOptional<z.ZodBoolean>;
+    requiresApproval: z.ZodOptional<z.ZodBoolean>;
+    sideEffect: z.ZodOptional<z.ZodBoolean>;
+    externallyVisible: z.ZodOptional<z.ZodBoolean>;
+    exposesSensitiveData: z.ZodOptional<z.ZodBoolean>;
+    changesWorkflow: z.ZodOptional<z.ZodBoolean>;
+    requiredPolicyIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    inputSchemaName: z.ZodOptional<z.ZodString>;
+    outputSchemaName: z.ZodOptional<z.ZodString>;
+    inputSchemaRef: z.ZodOptional<z.ZodString>;
+    outputSchemaRef: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodOptional<z.ZodUnknown>;
+    outputSchema: z.ZodOptional<z.ZodUnknown>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    level: z.ZodDefault<z.ZodEnum<{
+        required: "required";
+        recommended: "recommended";
+        optional: "optional";
+        extension: "extension";
+    }>>;
+}, z.core.$strip>;
+type CategoryOperationDeclaration = z.infer<typeof CategoryOperationDeclarationSchema>;
+type CategoryOperationDeclarationInput = z.input<typeof CategoryOperationDeclarationSchema>;
+declare const CategoryOperationCatalogEntrySchema: z.ZodObject<{
+    alias: z.ZodString;
+    capability: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    providerObject: z.ZodOptional<z.ZodString>;
+    providerObjects: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        schemaName: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    audience: z.ZodOptional<z.ZodEnum<{
+        "customer-facing": "customer-facing";
+        "internal-support": "internal-support";
+        mixed: "mixed";
+    }>>;
+    audiences: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "customer-facing": "customer-facing";
+        "internal-support": "internal-support";
+        mixed: "mixed";
+    }>>>;
+    requiresCredential: z.ZodOptional<z.ZodBoolean>;
+    requiresApproval: z.ZodOptional<z.ZodBoolean>;
+    sideEffect: z.ZodOptional<z.ZodBoolean>;
+    externallyVisible: z.ZodOptional<z.ZodBoolean>;
+    exposesSensitiveData: z.ZodOptional<z.ZodBoolean>;
+    changesWorkflow: z.ZodOptional<z.ZodBoolean>;
+    requiredPolicyIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    inputSchemaName: z.ZodOptional<z.ZodString>;
+    outputSchemaName: z.ZodOptional<z.ZodString>;
+    inputSchemaRef: z.ZodOptional<z.ZodString>;
+    outputSchemaRef: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodOptional<z.ZodUnknown>;
+    outputSchema: z.ZodOptional<z.ZodUnknown>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    level: z.ZodDefault<z.ZodEnum<{
+        required: "required";
+        recommended: "recommended";
+        optional: "optional";
+        extension: "extension";
+    }>>;
+}, z.core.$strip>;
+type CategoryOperationCatalogEntry = CategoryOperationDeclaration;
+type CategoryOperationCatalogEntryInput = CategoryOperationDeclarationInput;
+declare const CategoryOperationCatalogSchema: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    alias: z.ZodString;
+    capability: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    providerObject: z.ZodOptional<z.ZodString>;
+    providerObjects: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        schemaName: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    audience: z.ZodOptional<z.ZodEnum<{
+        "customer-facing": "customer-facing";
+        "internal-support": "internal-support";
+        mixed: "mixed";
+    }>>;
+    audiences: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "customer-facing": "customer-facing";
+        "internal-support": "internal-support";
+        mixed: "mixed";
+    }>>>;
+    requiresCredential: z.ZodOptional<z.ZodBoolean>;
+    requiresApproval: z.ZodOptional<z.ZodBoolean>;
+    sideEffect: z.ZodOptional<z.ZodBoolean>;
+    externallyVisible: z.ZodOptional<z.ZodBoolean>;
+    exposesSensitiveData: z.ZodOptional<z.ZodBoolean>;
+    changesWorkflow: z.ZodOptional<z.ZodBoolean>;
+    requiredPolicyIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    inputSchemaName: z.ZodOptional<z.ZodString>;
+    outputSchemaName: z.ZodOptional<z.ZodString>;
+    inputSchemaRef: z.ZodOptional<z.ZodString>;
+    outputSchemaRef: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodOptional<z.ZodUnknown>;
+    outputSchema: z.ZodOptional<z.ZodUnknown>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    level: z.ZodDefault<z.ZodEnum<{
+        required: "required";
+        recommended: "recommended";
+        optional: "optional";
+        extension: "extension";
+    }>>;
+}, z.core.$strip>>>;
+type CategoryOperationCatalog = z.infer<typeof CategoryOperationCatalogSchema>;
+type CategoryOperationCatalogInput = z.input<typeof CategoryOperationCatalogSchema>;
+declare const ProviderOperationDeclarationSchema: z.ZodObject<{
+    alias: z.ZodString;
+    capability: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    providerObject: z.ZodOptional<z.ZodString>;
+    providerObjects: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        schemaName: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    audience: z.ZodOptional<z.ZodEnum<{
+        "customer-facing": "customer-facing";
+        "internal-support": "internal-support";
+        mixed: "mixed";
+    }>>;
+    audiences: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "customer-facing": "customer-facing";
+        "internal-support": "internal-support";
+        mixed: "mixed";
+    }>>>;
+    requiresCredential: z.ZodOptional<z.ZodBoolean>;
+    requiresApproval: z.ZodOptional<z.ZodBoolean>;
+    sideEffect: z.ZodOptional<z.ZodBoolean>;
+    externallyVisible: z.ZodOptional<z.ZodBoolean>;
+    exposesSensitiveData: z.ZodOptional<z.ZodBoolean>;
+    changesWorkflow: z.ZodOptional<z.ZodBoolean>;
+    requiredPolicyIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    inputSchemaName: z.ZodOptional<z.ZodString>;
+    outputSchemaName: z.ZodOptional<z.ZodString>;
+    inputSchemaRef: z.ZodOptional<z.ZodString>;
+    outputSchemaRef: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodOptional<z.ZodUnknown>;
+    outputSchema: z.ZodOptional<z.ZodUnknown>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    providerOperation: z.ZodOptional<z.ZodString>;
+    extension: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type ProviderOperationDeclaration = z.infer<typeof ProviderOperationDeclarationSchema>;
+type ProviderOperationDeclarationInput = z.input<typeof ProviderOperationDeclarationSchema>;
+declare const CategoryEventDeclarationSchema: z.ZodObject<{
+    kind: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    direction: z.ZodEnum<{
+        bidirectional: "bidirectional";
+        inbound: "inbound";
+        outbound: "outbound";
+        internal: "internal";
+    }>;
+    capability: z.ZodOptional<z.ZodString>;
+    providerObject: z.ZodOptional<z.ZodString>;
+    operationAlias: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type CategoryEventDeclaration = z.infer<typeof CategoryEventDeclarationSchema>;
+type CategoryEventDeclarationInput = z.input<typeof CategoryEventDeclarationSchema>;
+declare const CategoryOutputDeclarationSchema: z.ZodObject<{
+    intent: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    capability: z.ZodString;
+    operationAlias: z.ZodOptional<z.ZodString>;
+    providerObject: z.ZodOptional<z.ZodString>;
+    externallyVisible: z.ZodOptional<z.ZodBoolean>;
+    requiresApproval: z.ZodOptional<z.ZodBoolean>;
+    sideEffect: z.ZodOptional<z.ZodBoolean>;
+    exposesSensitiveData: z.ZodOptional<z.ZodBoolean>;
+    changesWorkflow: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type CategoryOutputDeclaration = z.infer<typeof CategoryOutputDeclarationSchema>;
+type CategoryOutputDeclarationInput = z.input<typeof CategoryOutputDeclarationSchema>;
+declare const CategoryDataSourceDeclarationSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    capability: z.ZodString;
+    operationAlias: z.ZodOptional<z.ZodString>;
+    providerObjects: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    exposesSensitiveData: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type CategoryDataSourceDeclaration = z.infer<typeof CategoryDataSourceDeclarationSchema>;
+type CategoryDataSourceDeclarationInput = z.input<typeof CategoryDataSourceDeclarationSchema>;
+declare const IntegrationCategoryProfileSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    category: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    providerObjects: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        schemaName: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    capabilities: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        capability: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        audiences: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            "customer-facing": "customer-facing";
+            "internal-support": "internal-support";
+            mixed: "mixed";
+        }>>>;
+        providerObjects: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            schemaName: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>;
+        requiresCredential: z.ZodOptional<z.ZodBoolean>;
+        sideEffect: z.ZodOptional<z.ZodBoolean>;
+        exposesSensitiveData: z.ZodOptional<z.ZodBoolean>;
+        changesWorkflow: z.ZodOptional<z.ZodBoolean>;
+        extension: z.ZodOptional<z.ZodBoolean>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    operations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        alias: z.ZodString;
+        capability: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        providerObject: z.ZodOptional<z.ZodString>;
+        providerObjects: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            schemaName: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>;
+        audience: z.ZodOptional<z.ZodEnum<{
+            "customer-facing": "customer-facing";
+            "internal-support": "internal-support";
+            mixed: "mixed";
+        }>>;
+        audiences: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            "customer-facing": "customer-facing";
+            "internal-support": "internal-support";
+            mixed: "mixed";
+        }>>>;
+        requiresCredential: z.ZodOptional<z.ZodBoolean>;
+        requiresApproval: z.ZodOptional<z.ZodBoolean>;
+        sideEffect: z.ZodOptional<z.ZodBoolean>;
+        externallyVisible: z.ZodOptional<z.ZodBoolean>;
+        exposesSensitiveData: z.ZodOptional<z.ZodBoolean>;
+        changesWorkflow: z.ZodOptional<z.ZodBoolean>;
+        requiredPolicyIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        inputSchemaName: z.ZodOptional<z.ZodString>;
+        outputSchemaName: z.ZodOptional<z.ZodString>;
+        inputSchemaRef: z.ZodOptional<z.ZodString>;
+        outputSchemaRef: z.ZodOptional<z.ZodString>;
+        inputSchema: z.ZodOptional<z.ZodUnknown>;
+        outputSchema: z.ZodOptional<z.ZodUnknown>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        level: z.ZodDefault<z.ZodEnum<{
+            required: "required";
+            recommended: "recommended";
+            optional: "optional";
+            extension: "extension";
+        }>>;
+    }, z.core.$strip>>>;
+    events: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        direction: z.ZodEnum<{
+            bidirectional: "bidirectional";
+            inbound: "inbound";
+            outbound: "outbound";
+            internal: "internal";
+        }>;
+        capability: z.ZodOptional<z.ZodString>;
+        providerObject: z.ZodOptional<z.ZodString>;
+        operationAlias: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    outputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        intent: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        capability: z.ZodString;
+        operationAlias: z.ZodOptional<z.ZodString>;
+        providerObject: z.ZodOptional<z.ZodString>;
+        externallyVisible: z.ZodOptional<z.ZodBoolean>;
+        requiresApproval: z.ZodOptional<z.ZodBoolean>;
+        sideEffect: z.ZodOptional<z.ZodBoolean>;
+        exposesSensitiveData: z.ZodOptional<z.ZodBoolean>;
+        changesWorkflow: z.ZodOptional<z.ZodBoolean>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    dataSources: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        capability: z.ZodString;
+        operationAlias: z.ZodOptional<z.ZodString>;
+        providerObjects: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        exposesSensitiveData: z.ZodOptional<z.ZodBoolean>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    notes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type IntegrationCategoryProfile = z.infer<typeof IntegrationCategoryProfileSchema>;
+type IntegrationCategoryProfileInput = z.input<typeof IntegrationCategoryProfileSchema>;
+declare const ProviderOperationCoverageMismatchSchema: z.ZodObject<{
+    alias: z.ZodString;
+    reason: z.ZodEnum<{
+        missing: "missing";
+        "capability-mismatch": "capability-mismatch";
+        "provider-object-mismatch": "provider-object-mismatch";
+    }>;
+    expectedCapability: z.ZodOptional<z.ZodString>;
+    actualCapability: z.ZodOptional<z.ZodString>;
+    expectedProviderObject: z.ZodOptional<z.ZodString>;
+    actualProviderObject: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ProviderOperationCoverageMismatch = z.infer<typeof ProviderOperationCoverageMismatchSchema>;
+declare const ProviderCapabilityCoverageReportSchema: z.ZodObject<{
+    providerPackageId: z.ZodString;
+    category: z.ZodString;
+    expectedCategory: z.ZodString;
+    categoryMatches: z.ZodBoolean;
+    coverage: z.ZodEnum<{
+        full: "full";
+        partial: "partial";
+        standard: "standard";
+    }>;
+    conformant: z.ZodBoolean;
+    matchedOperations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    missingRequiredOperations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    missingRecommendedOperations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    missingOptionalOperations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    extensionOperations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    mismatchedOperations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        alias: z.ZodString;
+        reason: z.ZodEnum<{
+            missing: "missing";
+            "capability-mismatch": "capability-mismatch";
+            "provider-object-mismatch": "provider-object-mismatch";
+        }>;
+        expectedCapability: z.ZodOptional<z.ZodString>;
+        actualCapability: z.ZodOptional<z.ZodString>;
+        expectedProviderObject: z.ZodOptional<z.ZodString>;
+        actualProviderObject: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type ProviderCapabilityCoverageReport = z.infer<typeof ProviderCapabilityCoverageReportSchema>;
+declare const ProviderCredentialRequirementSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type ProviderCredentialRequirement = z.infer<typeof ProviderCredentialRequirementSchema>;
+declare const ProviderCoverageScopeSchema: z.ZodEnum<{
+    "support-workflow-subset": "support-workflow-subset";
+    "provider-api-subset": "provider-api-subset";
+    "connector-required": "connector-required";
+    "local-protocol": "local-protocol";
+    "full-provider-api": "full-provider-api";
+}>;
+type ProviderCoverageScope = z.infer<typeof ProviderCoverageScopeSchema>;
+declare const ProviderCoverageSchema: z.ZodObject<{
+    scope: z.ZodDefault<z.ZodEnum<{
+        "support-workflow-subset": "support-workflow-subset";
+        "provider-api-subset": "provider-api-subset";
+        "connector-required": "connector-required";
+        "local-protocol": "local-protocol";
+        "full-provider-api": "full-provider-api";
+    }>>;
+    notes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type ProviderCoverage = z.infer<typeof ProviderCoverageSchema>;
+type ProviderCoverageInput = z.input<typeof ProviderCoverageSchema>;
+declare const ProviderManifestSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    packageName: z.ZodString;
+    provider: z.ZodString;
+    category: z.ZodString;
+    trustLevel: z.ZodDefault<z.ZodEnum<{
+        community: "community";
+        official: "official";
+        verified: "verified";
+        experimental: "experimental";
+    }>>;
+    directions: z.ZodArray<z.ZodEnum<{
+        "receive-only": "receive-only";
+        "send-only": "send-only";
+        "inbound-only": "inbound-only";
+        "outbound-only": "outbound-only";
+        bidirectional: "bidirectional";
+    }>>;
+    capabilities: z.ZodArray<z.ZodObject<{
+        capability: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        audiences: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            "customer-facing": "customer-facing";
+            "internal-support": "internal-support";
+            mixed: "mixed";
+        }>>>;
+        providerObjects: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            schemaName: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>;
+        requiresCredential: z.ZodOptional<z.ZodBoolean>;
+        sideEffect: z.ZodOptional<z.ZodBoolean>;
+        exposesSensitiveData: z.ZodOptional<z.ZodBoolean>;
+        changesWorkflow: z.ZodOptional<z.ZodBoolean>;
+        extension: z.ZodOptional<z.ZodBoolean>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    operations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        alias: z.ZodString;
+        capability: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        providerObject: z.ZodOptional<z.ZodString>;
+        providerObjects: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            schemaName: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>;
+        audience: z.ZodOptional<z.ZodEnum<{
+            "customer-facing": "customer-facing";
+            "internal-support": "internal-support";
+            mixed: "mixed";
+        }>>;
+        audiences: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            "customer-facing": "customer-facing";
+            "internal-support": "internal-support";
+            mixed: "mixed";
+        }>>>;
+        requiresCredential: z.ZodOptional<z.ZodBoolean>;
+        requiresApproval: z.ZodOptional<z.ZodBoolean>;
+        sideEffect: z.ZodOptional<z.ZodBoolean>;
+        externallyVisible: z.ZodOptional<z.ZodBoolean>;
+        exposesSensitiveData: z.ZodOptional<z.ZodBoolean>;
+        changesWorkflow: z.ZodOptional<z.ZodBoolean>;
+        requiredPolicyIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        inputSchemaName: z.ZodOptional<z.ZodString>;
+        outputSchemaName: z.ZodOptional<z.ZodString>;
+        inputSchemaRef: z.ZodOptional<z.ZodString>;
+        outputSchemaRef: z.ZodOptional<z.ZodString>;
+        inputSchema: z.ZodOptional<z.ZodUnknown>;
+        outputSchema: z.ZodOptional<z.ZodUnknown>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        providerOperation: z.ZodOptional<z.ZodString>;
+        extension: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    channelAudiences: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        "customer-facing": "customer-facing";
+        "internal-support": "internal-support";
+        mixed: "mixed";
+    }>>>;
+    credentialRequirements: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    coverage: z.ZodDefault<z.ZodObject<{
+        scope: z.ZodDefault<z.ZodEnum<{
+            "support-workflow-subset": "support-workflow-subset";
+            "provider-api-subset": "provider-api-subset";
+            "connector-required": "connector-required";
+            "local-protocol": "local-protocol";
+            "full-provider-api": "full-provider-api";
+        }>>;
+        notes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    privacyNotes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    limitations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    maintainers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodDefault<z.ZodEnum<{
+            community: "community";
+            official: "official";
+            unknown: "unknown";
+            partner: "partner";
+        }>>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type ProviderManifest = z.infer<typeof ProviderManifestSchema>;
+type ProviderManifestInput = z.input<typeof ProviderManifestSchema>;
+declare const ProviderRegistryQuerySchema: z.ZodObject<{
+    category: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
+    trustLevels: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        community: "community";
+        official: "official";
+        verified: "verified";
+        experimental: "experimental";
+    }>>>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    directions: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "receive-only": "receive-only";
+        "send-only": "send-only";
+        "inbound-only": "inbound-only";
+        "outbound-only": "outbound-only";
+        bidirectional: "bidirectional";
+    }>>>;
+    channelAudiences: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "customer-facing": "customer-facing";
+        "internal-support": "internal-support";
+        mixed: "mixed";
+    }>>>;
+    packageNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type ProviderRegistryQuery = z.infer<typeof ProviderRegistryQuerySchema>;
+type ProviderRegistryQueryInput = z.input<typeof ProviderRegistryQuerySchema>;
+interface ProviderRegistry {
+    register(manifest: ProviderManifestInput): ProviderManifest;
+    list(query?: ProviderRegistryQueryInput): ProviderManifest[];
+    get(id: string): ProviderManifest | undefined;
+    require(id: string): ProviderManifest;
+}
+declare function defineProviderPackage(manifest: ProviderManifestInput): ProviderManifest;
+declare function defineIntegrationCategoryProfile(profile: IntegrationCategoryProfileInput): IntegrationCategoryProfile;
+declare function deriveProviderCapabilityCoverage(input: {
+    profile: IntegrationCategoryProfileInput;
+    manifest: ProviderManifestInput;
+}): ProviderCapabilityCoverageReport;
+declare function checkProviderCapabilityCoverage(input: {
+    profile: IntegrationCategoryProfileInput;
+    manifest: ProviderManifestInput;
+}): boolean;
+declare function createProviderRegistry(manifests?: ProviderManifestInput[]): ProviderRegistry;
+declare function isCoreChannelCapability(capability: string): capability is CoreChannelCapability;
+declare const CapabilityAvailabilitySchema: z.ZodObject<{
+    providerPackageId: z.ZodOptional<z.ZodString>;
+    capability: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        "registry-available": "registry-available";
+        installed: "installed";
+        configured: "configured";
+        enabled: "enabled";
+        blocked: "blocked";
+    }>;
+    enabledForChannels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    enabledForAgents: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    enabledForJourneys: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    enabledForTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    blockers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        kind: z.ZodDefault<z.ZodEnum<{
+            "permission-blocked": "permission-blocked";
+            unknown: "unknown";
+            "missing-policy": "missing-policy";
+            "missing-configuration": "missing-configuration";
+            "missing-credentials": "missing-credentials";
+            "provider-unsupported": "provider-unsupported";
+        }>>;
+    }, z.core.$strip>>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type CapabilityAvailability = z.infer<typeof CapabilityAvailabilitySchema>;
+type CapabilityAvailabilityInput = z.input<typeof CapabilityAvailabilitySchema>;
+declare const ProviderCredentialStatusSchema: z.ZodObject<{
+    providerPackageId: z.ZodOptional<z.ZodString>;
+    requirementId: z.ZodString;
+    state: z.ZodEnum<{
+        required: "required";
+        configured: "configured";
+        "not-required": "not-required";
+        missing: "missing";
+        expired: "expired";
+        "insufficient-scope": "insufficient-scope";
+        "permission-blocked": "permission-blocked";
+        unavailable: "unavailable";
+    }>;
+    scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    expiresAt: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ProviderCredentialStatus = z.infer<typeof ProviderCredentialStatusSchema>;
+type ProviderCredentialStatusInput = z.input<typeof ProviderCredentialStatusSchema>;
+declare const ChannelFlowActivationSchema: z.ZodObject<{
+    journeyId: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    reason: z.ZodOptional<z.ZodString>;
+    providerPackageIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    policyIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type ChannelFlowActivation = z.infer<typeof ChannelFlowActivationSchema>;
+type ChannelFlowActivationInput = z.input<typeof ChannelFlowActivationSchema>;
+declare const ChannelOutboundPolicySchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    providerPackageIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    requiresProviderOutboundSupport: z.ZodDefault<z.ZodBoolean>;
+    policyIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type ChannelOutboundPolicy = z.infer<typeof ChannelOutboundPolicySchema>;
+type ChannelOutboundPolicyInput = z.input<typeof ChannelOutboundPolicySchema>;
+declare const ChannelBehaviorPolicySchema: z.ZodObject<{
+    tone: z.ZodOptional<z.ZodString>;
+    maxWords: z.ZodOptional<z.ZodNumber>;
+    maxCharacters: z.ZodOptional<z.ZodNumber>;
+    allowMarkdown: z.ZodOptional<z.ZodBoolean>;
+    allowWidgets: z.ZodOptional<z.ZodBoolean>;
+    draftFirst: z.ZodOptional<z.ZodBoolean>;
+    approval: z.ZodOptional<z.ZodUnknown>;
+    sensitiveData: z.ZodOptional<z.ZodUnknown>;
+    media: z.ZodOptional<z.ZodUnknown>;
+    handoff: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>;
+type ChannelBehaviorPolicy = z.infer<typeof ChannelBehaviorPolicySchema>;
+type ChannelBehaviorPolicyInput = z.input<typeof ChannelBehaviorPolicySchema>;
+declare const ChannelHandoffPolicySchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    providerPackageIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    destinations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    sdkControlled: z.ZodOptional<z.ZodBoolean>;
+    policyIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type ChannelHandoffPolicy = z.infer<typeof ChannelHandoffPolicySchema>;
+type ChannelHandoffPolicyInput = z.input<typeof ChannelHandoffPolicySchema>;
+declare const ChannelSetConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    channelIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    channels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    conversationContinuity: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            "new-conversation": "new-conversation";
+            "link-existing": "link-existing";
+            "sdk-decides": "sdk-decides";
+        }>>;
+        crossChannel: z.ZodDefault<z.ZodBoolean>;
+        policy: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type ChannelSetConfig = z.infer<typeof ChannelSetConfigSchema>;
+type ChannelSetConfigInput = z.input<typeof ChannelSetConfigSchema>;
+declare const ProviderReadinessSchema: z.ZodObject<{
+    providerPackageId: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<{
+        configured: "configured";
+        blocked: "blocked";
+        unknown: "unknown";
+        "not-configured": "not-configured";
+        ready: "ready";
+        "live-verified": "live-verified";
+        "sandbox-verified": "sandbox-verified";
+        "scoped-verified": "scoped-verified";
+        "full-api-verified": "full-api-verified";
+    }>>;
+    checkedAt: z.ZodOptional<z.ZodString>;
+    checkSource: z.ZodOptional<z.ZodString>;
+    live: z.ZodOptional<z.ZodBoolean>;
+    sandbox: z.ZodOptional<z.ZodBoolean>;
+    blockers: z.ZodDefault<z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        kind: z.ZodDefault<z.ZodEnum<{
+            "permission-blocked": "permission-blocked";
+            unknown: "unknown";
+            "missing-policy": "missing-policy";
+            "missing-configuration": "missing-configuration";
+            "missing-credentials": "missing-credentials";
+            "provider-unsupported": "provider-unsupported";
+        }>>;
+    }, z.core.$strip>>>>;
+    remediationActions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        kind: z.ZodDefault<z.ZodEnum<{
+            custom: "custom";
+            configure: "configure";
+            authorize: "authorize";
+            verify: "verify";
+            "read-docs": "read-docs";
+            "contact-provider": "contact-provider";
+        }>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type ProviderReadiness = z.infer<typeof ProviderReadinessSchema>;
+type ProviderReadinessInput = z.input<typeof ProviderReadinessSchema>;
+declare const ChannelPolicyConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    channel: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    audience: z.ZodOptional<z.ZodEnum<{
+        "customer-facing": "customer-facing";
+        "internal-support": "internal-support";
+        mixed: "mixed";
+    }>>;
+    channelSetIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    providerPackageIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    enabledCapabilities: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    flowActivations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        journeyId: z.ZodString;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        reason: z.ZodOptional<z.ZodString>;
+        providerPackageIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        policyIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    behavior: z.ZodOptional<z.ZodObject<{
+        tone: z.ZodOptional<z.ZodString>;
+        maxWords: z.ZodOptional<z.ZodNumber>;
+        maxCharacters: z.ZodOptional<z.ZodNumber>;
+        allowMarkdown: z.ZodOptional<z.ZodBoolean>;
+        allowWidgets: z.ZodOptional<z.ZodBoolean>;
+        draftFirst: z.ZodOptional<z.ZodBoolean>;
+        approval: z.ZodOptional<z.ZodUnknown>;
+        sensitiveData: z.ZodOptional<z.ZodUnknown>;
+        media: z.ZodOptional<z.ZodUnknown>;
+        handoff: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>;
+    outbound: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        providerPackageIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        requiresProviderOutboundSupport: z.ZodDefault<z.ZodBoolean>;
+        policyIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    handoff: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        providerPackageIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        destinations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        sdkControlled: z.ZodOptional<z.ZodBoolean>;
+        policyIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    policies: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type ChannelPolicyConfig = z.infer<typeof ChannelPolicyConfigSchema>;
+type ChannelPolicyConfigInput = z.input<typeof ChannelPolicyConfigSchema>;
+declare const CapabilityUseRequestSchema: z.ZodObject<{
+    channel: z.ZodString;
+    channelId: z.ZodOptional<z.ZodString>;
+    capability: z.ZodString;
+    providerPackageId: z.ZodOptional<z.ZodString>;
+    actionAudience: z.ZodOptional<z.ZodEnum<{
+        "customer-facing": "customer-facing";
+        "internal-support": "internal-support";
+        mixed: "mixed";
+    }>>;
+    outbound: z.ZodOptional<z.ZodBoolean>;
+    sideEffect: z.ZodOptional<z.ZodBoolean>;
+    externallyVisible: z.ZodOptional<z.ZodBoolean>;
+    exposesSensitiveData: z.ZodOptional<z.ZodBoolean>;
+    changesWorkflow: z.ZodOptional<z.ZodBoolean>;
+    requiredPolicyIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type CapabilityUseRequest = z.infer<typeof CapabilityUseRequestSchema>;
+type CapabilityUseRequestInput = z.input<typeof CapabilityUseRequestSchema>;
+type CapabilityUseDecision = {
+    allowed: true;
+    policy: ChannelPolicyConfig;
+} | {
+    allowed: false;
+    code: "missing-channel-configuration" | "capability-not-enabled" | "capability-blocked" | "outbound-disabled" | "provider-direction-not-supported" | "missing-policy";
+    message: string;
+    blockers: Array<{
+        code: string;
+        message: string;
+        kind?: string;
+    }>;
+};
+declare function defineChannelPolicy(config: z.input<typeof ChannelPolicyConfigSchema>): ChannelPolicyConfig;
+declare function defineCapabilityAvailability(input: CapabilityAvailabilityInput): CapabilityAvailability;
+declare function evaluateCapabilityUse(input: {
+    request: CapabilityUseRequestInput;
+    channels: ChannelPolicyConfigInput[];
+    availability?: CapabilityAvailabilityInput[];
+    providerPackages?: ProviderManifestInput[];
+}): CapabilityUseDecision;
 type Primitive = string | number | boolean | bigint | symbol | null | undefined | Date;
 type StringKey<T> = Extract<keyof T, string>;
 type ContextPath<T> = T extends Primitive ? never : T extends readonly unknown[] ? never : {
@@ -227,6 +1284,38 @@ interface ToolExecutionContext<TInput, TApp = unknown> {
     idempotencyKey?: string;
     signal?: AbortSignal;
 }
+type ApprovalRequirement = "never" | "policy" | "required";
+type ApprovalResolutionMode = "approve" | "deny" | "edit" | "expire" | "cancel" | "return-to-agent";
+interface ToolApprovalOptions {
+    requirement?: ApprovalRequirement;
+    supportedResolutions?: ApprovalResolutionMode[];
+    editableFields?: string[];
+    reason?: string;
+    expiresAt?: string;
+    metadata?: Record<string, unknown>;
+}
+type RuntimeApprovalOutcome = "allow" | "require-approval" | "draft" | "deny" | "defer" | "handoff";
+interface RuntimeApprovalDecision {
+    outcome: RuntimeApprovalOutcome;
+    reason?: string;
+    supportedResolutions?: ApprovalResolutionMode[];
+    editableFields?: string[];
+    expiresAt?: string;
+    metadata?: Record<string, unknown>;
+}
+interface ToolPolicyOptions {
+    capability?: ChannelCapability;
+    providerPackageId?: string;
+    operationAlias?: string;
+    providerOperation?: string;
+    actionAudience?: ActionAudience;
+    outbound?: boolean;
+    externallyVisible?: boolean;
+    exposesSensitiveData?: boolean;
+    changesWorkflow?: boolean;
+    requiredPolicyIds?: string[];
+    approval?: ToolApprovalOptions;
+}
 interface ToolDefinition<TName extends string = string, TInputSchema extends z.ZodType = z.ZodType, TOutputSchema extends z.ZodType = z.ZodType, TSideEffect extends boolean = boolean> {
     kind: "tool";
     name: TName;
@@ -234,6 +1323,7 @@ interface ToolDefinition<TName extends string = string, TInputSchema extends z.Z
     input: TInputSchema;
     output: TOutputSchema;
     sideEffect: TSideEffect;
+    policy?: ToolPolicyOptions;
     idempotencyKey?: (args: {
         input: z.infer<TInputSchema>;
         conversationId: string;
@@ -278,380 +1368,793 @@ interface CustomRuntimeEventDefinition<TName extends string = string, TPayloadSc
 }
 type AnyCustomRuntimeEvent = CustomRuntimeEventDefinition<string, z.ZodType>;
-interface RuntimeEventBase<TType extends string, TData> {
-    id: string;
-    conversationId: string;
-    offset: number;
-    type: TType;
-    createdAt: string;
-    telemetry?: RuntimeEventTelemetry;
-    data: TData;
+interface EmailQuoteTrimOptions {
+    includeQuotedText?: boolean;
 }
-type ConversationLifecycle = "active" | "handoff" | "closed";
-interface MessageSegment {
-    id: string;
+interface EmailQuoteTrimResult {
     text: string;
-    references?: SupportReference[];
+    removedQuote: boolean;
+    quotedText?: string;
+    reason?: "reply-header" | "original-message" | "forwarded-message" | "quoted-block" | "metadata-header";
 }
-type SupportReference = {
-    type: "knowledge";
-    id: string;
-    sourceName?: string;
-    title?: string;
-    metadata?: unknown;
-} | {
-    type: "toolResult";
-    id: string;
-};
-type RuntimeEvent = RuntimeEventBase<"message.started", {
-    role: "assistant" | "user";
-}> | RuntimeEventBase<"message.delta", {
-    textDelta: string;
-}> | RuntimeEventBase<"message.completed", {
+interface EmailAttachmentMetadataInput {
+    id?: string;
+    providerObjectId?: string;
+    filename?: string | null;
+    name?: string | null;
+    contentType?: string | null;
+    mimeType?: string | null;
+    sizeBytes?: number | null;
+    size?: number | null;
+    inline?: boolean | null;
+    disposition?: string | null;
+    contentId?: string | null;
+    checksum?: string | null;
+    metadata?: Record<string, unknown>;
+}
+interface EmailAttachmentMetadata {
+    id?: string;
+    providerObjectId?: string;
+    filename: string;
+    contentType: string;
+    sizeBytes?: number;
+    disposition: "attachment" | "inline";
+    contentId?: string;
+    checksum?: string;
+    metadata?: Record<string, unknown>;
+}
+interface EmailThreadMessageInput {
+    id?: string;
+    providerObjectId?: string;
+    messageId?: string;
+    inReplyTo?: string;
+    references?: string[];
+    from?: string;
+    to?: string[];
+    cc?: string[];
+    bcc?: string[];
+    subject?: string;
+    sentAt?: string | Date;
+    text?: string;
+    html?: string;
+    attachments?: EmailAttachmentMetadataInput[];
+    metadata?: Record<string, unknown>;
+}
+interface EmailThreadContextOptions {
+    trimQuotes?: boolean;
+    maxMessages?: number;
+}
+interface EmailThreadContextMessage {
+    id?: string;
+    providerObjectId?: string;
+    messageId?: string;
+    inReplyTo?: string;
+    references: string[];
+    from?: string;
+    to: string[];
+    cc: string[];
+    bcc: string[];
+    subject?: string;
+    sentAt?: string;
     text: string;
-    segments?: MessageSegment[];
-    usage?: UsageRecord;
-    intermediate?: boolean;
-    visibleToModel?: boolean;
-}> | RuntimeEventBase<"message.aborted", {
-    reason: string;
-    partialText?: string;
-}> | RuntimeEventBase<"voice.segment.started", {
-    channelSegmentId: string;
-    connectionId: string;
-    adapter: string;
+    quotedTextRemoved: boolean;
+    attachments: EmailAttachmentMetadata[];
+    metadata?: Record<string, unknown>;
+}
+interface EmailThreadContext {
+    subject?: string;
+    participants: string[];
+    messageIds: string[];
+    references: string[];
+    attachmentCount: number;
+    messages: EmailThreadContextMessage[];
+}
+declare function trimEmailQuote(input: string, options?: EmailQuoteTrimOptions): EmailQuoteTrimResult;
+declare function normalizeEmailAttachmentMetadata(input: EmailAttachmentMetadataInput): EmailAttachmentMetadata;
+declare function collectEmailAttachmentMetadata(attachments?: EmailAttachmentMetadataInput[]): EmailAttachmentMetadata[];
+declare function createEmailThreadContext(messages: EmailThreadMessageInput[], options?: EmailThreadContextOptions): EmailThreadContext;
+type Extensible<T extends string> = T | (string & {});
+declare const coreChannelEventNatures: readonly ["message", "voice.session.started", "voice.turn.finalized", "provider.object.updated", "operator.resume", "outbound.contact.requested", "channel.handoff.requested", "schedule.due", "output.resolution", "delivery.updated", "custom"];
+declare const channelEventDirections: readonly ["inbound", "outbound", "internal"];
+declare const channelEventActorTypes: readonly ["customer", "agent", "operator", "provider", "system", "scheduler", "application"];
+declare const coreChannelEventIntents: readonly ["customer-message", "agent-message", "customer-voice-turn", "provider-update", "operator-resume", "outbound-contact", "channel-handoff", "scheduled-support-action", "output-resolution", "delivery-update", "handoff-review", "record-only"];
+declare const channelEventSourceTypes: readonly ["provider-adapter", "application", "schedule-adapter", "operator-surface"];
+declare const channelEventIntakeStatuses: readonly ["accepted", "ignored", "deferred", "handoff-review", "blocked"];
+declare const channelEventBindingStatuses: readonly ["bound", "created", "unbound", "not-required", "blocked"];
+declare const channelEventBindingOutcomes: readonly ["start-new", "resume-existing", "link-and-start-new", "ignore", "defer", "handoff-review", "blocked"];
+declare const channelEventHandlingDispositionKinds: readonly ["no-op", "record-only", "deterministic-journey-event", "model-turn", "output-resolution", "provider-operation", "handoff-review"];
+declare const coreChannelOutputIntentKinds: readonly ["message.reply", "message.draft", "internal.note", "voice.reply", "provider.operation", "provider.object.update", "approval.request", "artifact.create", "notification.send", "handoff.review", "custom"];
+declare const channelOutputProducerTypes: readonly ["agent", "journey", "tool", "operator", "policy", "schedule", "application", "provider-adapter"];
+declare const channelOutputDeliveryModes: readonly ["send", "draft", "provider-operation", "approval", "artifact", "notify", "handoff-review", "none"];
+declare const channelOutputResolutionOutcomes: readonly ["send", "draft", "approval-required", "provider-operation", "artifact", "notify", "handoff-review", "defer", "block", "drop", "no-op"];
+declare const channelOutputResolutionStatuses: readonly ["resolved", "pending", "deferred", "blocked", "no-op"];
+declare const coreChannelEventKinds: readonly ["message", "voice.session.started", "voice.turn.finalized", "provider.object.updated", "operator.resume", "outbound.contact.requested", "channel.handoff.requested", "schedule.due", "output.resolution", "delivery.updated", "custom"];
+declare const coreChannelEventDirections: readonly ["inbound", "outbound", "internal"];
+declare const coreChannelEventActors: readonly ["customer", "agent", "operator", "provider", "system", "scheduler", "application"];
+type CoreChannelEventNature = typeof coreChannelEventNatures[number];
+type ChannelEventNature = Extensible<CoreChannelEventNature>;
+type CoreChannelEventKind = CoreChannelEventNature;
+type ChannelEventKind = ChannelEventNature;
+type ChannelEventDirection = typeof channelEventDirections[number];
+type ChannelEventActorType = typeof channelEventActorTypes[number];
+type CoreChannelEventDirection = ChannelEventDirection;
+type CoreChannelEventActor = ChannelEventActorType;
+type CoreChannelEventIntent = typeof coreChannelEventIntents[number];
+type ChannelEventIntent = Extensible<CoreChannelEventIntent>;
+type ChannelEventSourceType = typeof channelEventSourceTypes[number];
+type ChannelEventIntakeStatus = typeof channelEventIntakeStatuses[number];
+type ChannelEventBindingStatus = typeof channelEventBindingStatuses[number];
+type ChannelEventBindingOutcome = typeof channelEventBindingOutcomes[number];
+type ChannelEventHandlingDispositionKind = typeof channelEventHandlingDispositionKinds[number];
+type ChannelEventHandlingDisposition = ChannelEventHandlingDispositionKind;
+type CoreChannelOutputIntentKind = typeof coreChannelOutputIntentKinds[number];
+type ChannelOutputIntentKind = Extensible<CoreChannelOutputIntentKind>;
+type ChannelOutputProducerType = typeof channelOutputProducerTypes[number];
+type ChannelOutputDeliveryMode = typeof channelOutputDeliveryModes[number];
+type ChannelOutputResolutionOutcome = typeof channelOutputResolutionOutcomes[number];
+type ChannelOutputResolutionStatus = typeof channelOutputResolutionStatuses[number];
+interface ChannelEventActor {
+    type: ChannelEventActorType;
+    id?: string;
+    displayName?: string;
+    metadata?: Record<string, unknown>;
+}
+interface NormalizedChannelPayload {
+    text?: string;
+    subject?: string;
+    body?: string;
+    summary?: string;
+    attachments?: unknown[];
+    providerObject?: unknown;
+    status?: string;
+    metadata?: Record<string, unknown>;
+}
+type NormalizedChannelPayloadInput = NormalizedChannelPayload & Record<string, unknown>;
+interface ChannelEventSourceEvidence<TRawPayload = unknown> {
+    sourceType?: ChannelEventSourceType;
+    sourceId?: string;
     provider?: string;
-}> | RuntimeEventBase<"voice.segment.ended", {
-    channelSegmentId: string;
-    connectionId?: string;
+    providerPackageId?: string;
+    eventId?: string;
+    streamId?: string;
+    deliveryId?: string;
+    receivedAt?: string;
+    verified?: boolean;
+    externalObjectIds?: Record<string, string>;
+    raw?: TRawPayload;
+    metadata?: Record<string, unknown>;
+}
+interface ChannelEventIdentity {
+    key?: string;
+    dedupeKey?: string;
+    streamId?: string;
+    sequence?: string | number;
+    idempotencyKey?: string;
+    metadata?: Record<string, unknown>;
+}
+interface ChannelEventEnvelope<TPayload = NormalizedChannelPayload, TRawPayload = unknown> {
+    id?: string;
+    kind: ChannelEventKind;
+    nature: ChannelEventNature;
+    direction: ChannelEventDirection;
+    intent?: ChannelEventIntent;
+    actor?: ChannelEventActor;
+    channel: ChannelContext;
+    occurredAt?: string;
+    payload?: TPayload;
+    identity?: ChannelEventIdentity;
+    source?: ChannelEventSourceEvidence<TRawPayload>;
+    metadata?: Record<string, unknown>;
+}
+type ChannelEvent<TPayload = NormalizedChannelPayload, TRawPayload = unknown> = ChannelEventEnvelope<TPayload, TRawPayload>;
+type ChannelSourceEvidence<TRawPayload = unknown> = ChannelEventSourceEvidence<TRawPayload>;
+interface ChannelEventEnvelopeInput<TPayload = NormalizedChannelPayloadInput, TRawPayload = unknown> {
+    id?: string;
+    kind?: ChannelEventKind;
+    nature?: ChannelEventNature;
+    direction?: ChannelEventDirection;
+    intent?: ChannelEventIntent;
+    actor?: ChannelEventActor;
+    channel: ConversationChannelInput;
+    occurredAt?: string;
+    payload?: TPayload;
+    identity?: ChannelEventIdentity;
+    source?: ChannelEventSourceEvidence<TRawPayload>;
+    metadata?: Record<string, unknown>;
+}
+interface ChannelEventBindingResult {
+    outcome: ChannelEventBindingOutcome;
+    status?: ChannelEventBindingStatus;
+    channel?: ChannelContext;
+    conversationId?: string;
     reason?: string;
-}> | RuntimeEventBase<"voice.connection.failed", {
-    channelSegmentId: string;
-    connectionId?: string;
-    code: string;
-    message: string;
-    retryable?: boolean;
-}> | RuntimeEventBase<"voice.interrupted", {
-    channelSegmentId: string;
-    connectionId?: string;
-    interruptedMessageId?: string;
-    source?: "userSpeech" | "adapter" | "provider";
+}
+interface ChannelEventIntakeResult {
+    outcome: ChannelEventIntakeStatus;
+    bindingOutcome: ChannelEventBindingOutcome;
+    conversationId?: string;
+    handling: "started" | "queued" | "not-required";
     reason?: string;
-    recordingReferenceId?: string;
-    offsetMs?: number;
-}> | RuntimeEventBase<"voice.recording.started", {
-    channelSegmentId: string;
-    recordingReferenceId: string;
-    policy?: unknown;
-}> | RuntimeEventBase<"voice.recording.completed", {
-    channelSegmentId: string;
-    recordingReferenceId: string;
-    uri?: string;
-    startedAt?: string;
-    endedAt?: string;
-    metadata?: unknown;
-}> | RuntimeEventBase<"voice.transcript.committed", {
-    channelSegmentId: string;
-    speaker: "user" | "assistant";
-    messageEventId: string;
-    recordingReferenceId?: string;
-    startedAtMs?: number;
-    endedAtMs?: number;
-    transcriptionSource?: string;
-    metadata?: unknown;
-}> | RuntimeEventBase<"journey.candidates.retrieved", {
-    journeyIds: string[];
-}> | RuntimeEventBase<"journey.matched", {
-    candidates: Array<{
-        journeyId: string;
-        confidence: number;
-        reason?: string;
+    reasonCode?: string;
+    reasonLabel?: string;
+    blockers?: Array<{
+        code: string;
+        message: string;
+        kind?: string;
     }>;
-}> | RuntimeEventBase<"journey.activated", {
-    journeyId: string;
-    previousJourneyId?: string;
-}> | RuntimeEventBase<"journey.completed", {
-    journeyId: string;
-    stateId?: string;
+    metadata?: Record<string, unknown>;
+}
+interface ChannelOutputIntentProducer {
+    type: ChannelOutputProducerType;
+    id?: string;
+    name?: string;
+    metadata?: Record<string, unknown>;
+}
+interface ChannelOutputPolicyReason {
     reason?: string;
-}> | RuntimeEventBase<"journey.guard.denied", {
-    journeyId: string;
-    stateId?: string;
-    code: string;
-    message?: string;
+    reasonCode?: string;
+    reasonLabel?: string;
+    policyId?: string;
+    policyIds?: string[];
+    blockers?: Array<{
+        code: string;
+        message: string;
+        kind?: string;
+    }>;
     metadata?: Record<string, unknown>;
-}> | RuntimeEventBase<"journey.event.emitted", {
-    name: string;
-    payload: unknown;
-    routing: "none" | "activeJourneyOnly" | "full" | "targeted";
-    target?: {
-        journeyId?: string;
-        stateId?: string;
-    };
-}> | RuntimeEventBase<"journey.state.entered", {
-    journeyId: string;
-    stateId: string;
-}> | RuntimeEventBase<"journey.extraction.proposed", {
-    journeyId: string;
-    stateId: string;
-    fields: string[];
-}> | RuntimeEventBase<"journey.extraction.accepted", {
-    journeyId: string;
-    stateId: string;
-    fields: string[];
-}> | RuntimeEventBase<"action.started", {
-    actionName: string;
-    journeyId?: string;
-    stateId?: string;
-}> | RuntimeEventBase<"action.completed", {
-    actionName: string;
-    success: boolean;
-    journeyId?: string;
-    stateId?: string;
-    error?: string;
-}> | RuntimeEventBase<"tool.started", {
-    toolName: string;
-    journeyId?: string;
-    stateId?: string;
-}> | RuntimeEventBase<"tool.completed", {
-    toolName: string;
-    success: boolean;
-    journeyId?: string;
-    stateId?: string;
-    result?: unknown;
-    error?: string;
-}> | RuntimeEventBase<"knowledge.retrieved", {
-    sourceName: string;
-    itemIds: string[];
-}> | RuntimeEventBase<"ui.prompted", {
-    promptId: string;
-    widgetKind: string;
-    input: unknown;
-}> | RuntimeEventBase<"ui.submitted", {
-    promptId: string;
-    widgetKind: string;
-    output: unknown;
-}> | RuntimeEventBase<"conversation.compaction.started", {
-    fromOffset: number;
-    toOffset: number;
-}> | RuntimeEventBase<"conversation.compaction.completed", {
-    fromOffset: number;
-    toOffset: number;
-    schemaVersion: string;
-}> | RuntimeEventBase<"handoff.requested", {
-    reason: string;
-    summary?: string;
-    payload?: unknown;
-}> | RuntimeEventBase<"handoff.resumed", {
-    reason?: string;
-    payload?: unknown;
-}> | RuntimeEventBase<"conversation.closed", {
-    reason?: string;
-}> | RuntimeEventBase<"error", {
-    code: string;
-    message: string;
-    details?: unknown;
-}> | RuntimeEventBase<`custom.${string}`, unknown>;
-interface ConversationRecord<TConversationContext = unknown> {
-    id: string;
-    agentId: string;
-    lifecycle: ConversationLifecycle;
-    context: TConversationContext;
-    createdAt: string;
-    updatedAt: string;
-}
-type RuntimeEventInput<TType extends RuntimeEvent["type"] = RuntimeEvent["type"]> = Omit<Extract<RuntimeEvent, {
-    type: TType;
-}>, "id" | "offset" | "createdAt" | "telemetry"> & {
-    id?: string;
-    createdAt?: string;
-    telemetry?: RuntimeEvent["telemetry"];
-};
-interface ListEventsOptions {
-    conversationId: string;
-    afterOffset?: number;
-    limit?: number;
 }
-interface CreateConversationInput<TConversationContext = unknown> {
+interface ChannelOutputIntent<TPayload = NormalizedChannelPayload, TRawPayload = unknown> extends ChannelOutputPolicyReason {
     id?: string;
-    agentId: string;
-    context: TConversationContext;
-}
-interface StorageAdapter {
-    initialize?(): Promise<void> | void;
-    createConversation<TConversationContext = unknown>(input: CreateConversationInput<TConversationContext>): Promise<ConversationRecord<TConversationContext>>;
-    getConversation<TConversationContext = unknown>(conversationId: string): Promise<ConversationRecord<TConversationContext> | null>;
-    updateConversationLifecycle(conversationId: string, lifecycle: ConversationLifecycle): Promise<ConversationRecord | null>;
-    appendEvent<TEvent extends RuntimeEventInput>(event: TEvent): Promise<RuntimeEvent>;
-    listEvents(options: ListEventsOptions): Promise<RuntimeEvent[]>;
-    saveSnapshot(snapshot: RuntimeSnapshot): Promise<void>;
-    getSnapshot(conversationId: string): Promise<RuntimeSnapshot | null>;
-}
-type ConversationChannel = "chat" | "voice";
-type VoiceConnectionStatus = "starting" | "connected" | "ended" | "failed";
-type VoiceSpeaker = "user" | "assistant";
-interface VoiceIceServer {
-    urls: string | string[];
-    username?: string;
-    credential?: string;
-}
-interface VoiceRecordingPolicy {
-    enabled?: boolean;
-    requireConsent?: boolean;
-    mode?: "input" | "both";
-    metadata?: Record<string, unknown>;
-}
-interface VoiceSelection {
-    provider: string;
-    voice: string;
-}
-interface VoiceModelSet {
-    provider: string;
-    model: string;
-    voice?: string;
-    settings?: Record<string, unknown>;
-}
-interface VoiceProfile {
-    instructions?: string;
-    modelSet?: VoiceModelSet;
-    recording?: VoiceRecordingPolicy;
-    metadata?: Record<string, unknown>;
+    kind: ChannelOutputIntentKind;
+    producer?: ChannelOutputIntentProducer;
+    channel?: ChannelContext;
+    deliveryMode?: ChannelOutputDeliveryMode;
+    capability?: ChannelCapability;
+    providerPackageId?: string;
+    operationAlias?: string;
+    providerOperation?: string;
+    actionAudience?: ActionAudience;
+    outbound?: boolean;
+    sideEffect?: boolean;
+    externallyVisible?: boolean;
+    exposesSensitiveData?: boolean;
+    changesWorkflow?: boolean;
+    requiredPolicyIds?: string[];
+    text?: string;
+    subject?: string;
+    body?: string;
+    attachments?: unknown[];
+    payload?: TPayload;
+    source?: ChannelEventSourceEvidence<TRawPayload>;
 }
-interface VoiceChannelSegment {
-    id: string;
-    conversationId: string;
-    channel: "voice";
-    startedAt: string;
-    endedAt?: string;
+interface ChannelOutputIntentInput<TPayload = NormalizedChannelPayloadInput, TRawPayload = unknown> extends Omit<ChannelOutputIntent<TPayload, TRawPayload>, "kind" | "channel"> {
+    kind?: ChannelOutputIntentKind;
+    channel?: ConversationChannelInput;
 }
-interface VoiceConnection {
-    id: string;
-    channelSegmentId: string;
-    status: VoiceConnectionStatus;
-    adapter: string;
-    provider?: string;
-    providerSessionId?: string;
+interface ChannelOutputResolutionDecision<TPayload = unknown> extends ChannelOutputPolicyReason {
+    outcome: ChannelOutputResolutionOutcome;
+    status?: ChannelOutputResolutionStatus;
+    deliveryMode?: ChannelOutputDeliveryMode;
+    capability?: ChannelCapability;
+    providerPackageId?: string;
+    operationAlias?: string;
+    providerOperation?: string;
+    actionAudience?: ActionAudience;
+    supportedApprovalResolutions?: string[];
+    editableFields?: string[];
     expiresAt?: string;
+    payload?: TPayload;
 }
-interface VoiceSocketMetadata {
-    url: string;
-    token: string;
-    expiresAt: string;
-    protocol: "cognidesk.voice.v1";
-}
-interface VoiceStartClientHints {
-    userAgent?: string;
-    locale?: string;
-    metadata?: Record<string, unknown>;
+interface ChannelOutputResolution<TPayload = unknown> extends ChannelOutputResolutionDecision<TPayload> {
+    id: string;
+    intentId?: string;
+    status: ChannelOutputResolutionStatus;
+    channel?: ChannelContext;
+    resolvedAt: string;
+    externalMessageId?: string;
+    deliveryStatus?: string;
+    providerResult?: unknown;
 }
-interface StartVoiceConversationInput<TConversationContext = unknown> {
-    id?: string;
-    agentId: string;
-    context: TConversationContext;
-    client?: VoiceStartClientHints;
-    app?: unknown;
+interface ChannelOutputResolutionPayload<TPayload = unknown> {
+    outputIntent: ChannelOutputIntent<TPayload>;
+    resolution: ChannelOutputResolution;
 }
-interface StartVoiceSegmentInput {
+interface ChannelOutputResolverInput<TPayload = unknown> {
     conversationId: string;
-    client?: VoiceStartClientHints;
-    app?: unknown;
+    channel: ChannelContext;
+    outputIntent: ChannelOutputIntent<TPayload>;
+    app: unknown;
+    signal?: AbortSignal;
 }
-interface StartVoiceResult {
-    conversation: ConversationRecord;
-    channelSegment: VoiceChannelSegment;
-    connection: VoiceConnection;
-    socket?: VoiceSocketMetadata;
-    events: RuntimeEvent[];
+interface ChannelOutputResolverResult<TPayload = unknown> extends ChannelOutputResolutionDecision<TPayload> {
+    externalMessageId?: string;
+    deliveryStatus?: string;
+    providerResult?: unknown;
 }
-interface CommitVoiceTranscriptInput {
-    conversationId: string;
-    channelSegmentId: string;
-    speaker: VoiceSpeaker;
+declare const ChannelEventNatureSchema: z.ZodString;
+declare const ChannelEventDirectionSchema: z.ZodEnum<{
+    inbound: "inbound";
+    outbound: "outbound";
+    internal: "internal";
+}>;
+declare const ChannelEventActorTypeSchema: z.ZodEnum<{
+    system: "system";
+    provider: "provider";
+    customer: "customer";
+    agent: "agent";
+    operator: "operator";
+    scheduler: "scheduler";
+    application: "application";
+}>;
+declare const ChannelEventIntentSchema: z.ZodString;
+declare const ChannelEventSourceTypeSchema: z.ZodEnum<{
+    application: "application";
+    "provider-adapter": "provider-adapter";
+    "schedule-adapter": "schedule-adapter";
+    "operator-surface": "operator-surface";
+}>;
+declare const ChannelEventIntakeStatusSchema: z.ZodEnum<{
+    blocked: "blocked";
+    "handoff-review": "handoff-review";
+    accepted: "accepted";
+    ignored: "ignored";
+    deferred: "deferred";
+}>;
+declare const ChannelEventBindingStatusSchema: z.ZodEnum<{
+    blocked: "blocked";
+    "not-required": "not-required";
+    bound: "bound";
+    created: "created";
+    unbound: "unbound";
+}>;
+declare const ChannelEventBindingOutcomeSchema: z.ZodEnum<{
+    blocked: "blocked";
+    defer: "defer";
+    "handoff-review": "handoff-review";
+    "start-new": "start-new";
+    "resume-existing": "resume-existing";
+    "link-and-start-new": "link-and-start-new";
+    ignore: "ignore";
+}>;
+declare const ChannelEventHandlingDispositionKindSchema: z.ZodEnum<{
+    "output-resolution": "output-resolution";
+    "handoff-review": "handoff-review";
+    "record-only": "record-only";
+    "no-op": "no-op";
+    "deterministic-journey-event": "deterministic-journey-event";
+    "model-turn": "model-turn";
+    "provider-operation": "provider-operation";
+}>;
+declare const ChannelOutputIntentKindSchema: z.ZodString;
+declare const ChannelOutputProducerTypeSchema: z.ZodEnum<{
+    tool: "tool";
+    schedule: "schedule";
+    policy: "policy";
+    agent: "agent";
+    operator: "operator";
+    application: "application";
+    "provider-adapter": "provider-adapter";
+    journey: "journey";
+}>;
+declare const ChannelOutputDeliveryModeSchema: z.ZodEnum<{
+    none: "none";
+    send: "send";
+    draft: "draft";
+    notify: "notify";
+    artifact: "artifact";
+    approval: "approval";
+    "handoff-review": "handoff-review";
+    "provider-operation": "provider-operation";
+}>;
+declare const ChannelOutputResolutionOutcomeSchema: z.ZodEnum<{
+    send: "send";
+    draft: "draft";
+    notify: "notify";
+    artifact: "artifact";
+    defer: "defer";
+    "handoff-review": "handoff-review";
+    "no-op": "no-op";
+    "provider-operation": "provider-operation";
+    "approval-required": "approval-required";
+    block: "block";
+    drop: "drop";
+}>;
+declare const ChannelOutputResolutionStatusSchema: z.ZodEnum<{
+    blocked: "blocked";
+    deferred: "deferred";
+    "no-op": "no-op";
+    resolved: "resolved";
+    pending: "pending";
+}>;
+declare const ChannelEventActorSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        system: "system";
+        provider: "provider";
+        customer: "customer";
+        agent: "agent";
+        operator: "operator";
+        scheduler: "scheduler";
+        application: "application";
+    }>;
+    id: z.ZodOptional<z.ZodString>;
+    displayName: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const NormalizedChannelPayloadSchema: z.ZodObject<{
+    text: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+    body: z.ZodOptional<z.ZodString>;
+    summary: z.ZodOptional<z.ZodString>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    providerObject: z.ZodOptional<z.ZodUnknown>;
+    status: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$loose>;
+declare const ChannelEventSourceEvidenceSchema: z.ZodObject<{
+    sourceType: z.ZodOptional<z.ZodEnum<{
+        application: "application";
+        "provider-adapter": "provider-adapter";
+        "schedule-adapter": "schedule-adapter";
+        "operator-surface": "operator-surface";
+    }>>;
+    sourceId: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
+    providerPackageId: z.ZodOptional<z.ZodString>;
+    eventId: z.ZodOptional<z.ZodString>;
+    streamId: z.ZodOptional<z.ZodString>;
+    deliveryId: z.ZodOptional<z.ZodString>;
+    receivedAt: z.ZodOptional<z.ZodString>;
+    verified: z.ZodOptional<z.ZodBoolean>;
+    externalObjectIds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    raw: z.ZodOptional<z.ZodUnknown>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const ChannelEventIdentitySchema: z.ZodObject<{
+    key: z.ZodOptional<z.ZodString>;
+    dedupeKey: z.ZodOptional<z.ZodString>;
+    streamId: z.ZodOptional<z.ZodString>;
+    sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const ChannelEventEnvelopeInputSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodString>;
+    nature: z.ZodOptional<z.ZodString>;
+    direction: z.ZodDefault<z.ZodEnum<{
+        inbound: "inbound";
+        outbound: "outbound";
+        internal: "internal";
+    }>>;
+    intent: z.ZodOptional<z.ZodString>;
+    actor: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            system: "system";
+            provider: "provider";
+            customer: "customer";
+            agent: "agent";
+            operator: "operator";
+            scheduler: "scheduler";
+            application: "application";
+        }>;
+        id: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    channel: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        channelId: z.ZodString;
+        kind: z.ZodString;
+        provider: z.ZodOptional<z.ZodString>;
+        externalThreadId: z.ZodOptional<z.ZodString>;
+        externalConversationId: z.ZodOptional<z.ZodString>;
+        externalMessageId: z.ZodOptional<z.ZodString>;
+        externalUserId: z.ZodOptional<z.ZodString>;
+        locale: z.ZodOptional<z.ZodString>;
+        timezone: z.ZodOptional<z.ZodString>;
+        capabilities: z.ZodDefault<z.ZodDefault<z.ZodObject<{
+            realtime: z.ZodDefault<z.ZodBoolean>;
+            async: z.ZodDefault<z.ZodBoolean>;
+            voice: z.ZodDefault<z.ZodBoolean>;
+            audioInput: z.ZodDefault<z.ZodBoolean>;
+            audioOutput: z.ZodDefault<z.ZodBoolean>;
+            richText: z.ZodDefault<z.ZodBoolean>;
+            markdown: z.ZodDefault<z.ZodBoolean>;
+            html: z.ZodDefault<z.ZodBoolean>;
+            attachments: z.ZodDefault<z.ZodBoolean>;
+            images: z.ZodDefault<z.ZodBoolean>;
+            files: z.ZodDefault<z.ZodBoolean>;
+            widgets: z.ZodDefault<z.ZodBoolean>;
+            buttons: z.ZodDefault<z.ZodBoolean>;
+            quickReplies: z.ZodDefault<z.ZodBoolean>;
+            templates: z.ZodDefault<z.ZodBoolean>;
+            publicReplies: z.ZodDefault<z.ZodBoolean>;
+            privateReplies: z.ZodDefault<z.ZodBoolean>;
+            typingIndicator: z.ZodDefault<z.ZodBoolean>;
+            readReceipts: z.ZodDefault<z.ZodBoolean>;
+            deliveryReceipts: z.ZodDefault<z.ZodBoolean>;
+            threaded: z.ZodDefault<z.ZodBoolean>;
+            supportsHumanTransfer: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>]>;
+    occurredAt: z.ZodOptional<z.ZodString>;
+    payload: z.ZodOptional<z.ZodUnknown>;
+    identity: z.ZodOptional<z.ZodObject<{
+        key: z.ZodOptional<z.ZodString>;
+        dedupeKey: z.ZodOptional<z.ZodString>;
+        streamId: z.ZodOptional<z.ZodString>;
+        sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        idempotencyKey: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    source: z.ZodOptional<z.ZodObject<{
+        sourceType: z.ZodOptional<z.ZodEnum<{
+            application: "application";
+            "provider-adapter": "provider-adapter";
+            "schedule-adapter": "schedule-adapter";
+            "operator-surface": "operator-surface";
+        }>>;
+        sourceId: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+        providerPackageId: z.ZodOptional<z.ZodString>;
+        eventId: z.ZodOptional<z.ZodString>;
+        streamId: z.ZodOptional<z.ZodString>;
+        deliveryId: z.ZodOptional<z.ZodString>;
+        receivedAt: z.ZodOptional<z.ZodString>;
+        verified: z.ZodOptional<z.ZodBoolean>;
+        externalObjectIds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        raw: z.ZodOptional<z.ZodUnknown>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$loose>;
+declare const ChannelOutputIntentProducerSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        tool: "tool";
+        schedule: "schedule";
+        policy: "policy";
+        agent: "agent";
+        operator: "operator";
+        application: "application";
+        "provider-adapter": "provider-adapter";
+        journey: "journey";
+    }>;
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const ChannelOutputPolicyReasonSchema: z.ZodObject<{
+    reason: z.ZodOptional<z.ZodString>;
+    reasonCode: z.ZodOptional<z.ZodString>;
+    reasonLabel: z.ZodOptional<z.ZodString>;
+    policyId: z.ZodOptional<z.ZodString>;
+    policyIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    blockers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        kind: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const ChannelOutputIntentInputSchema: z.ZodObject<{
+    reason: z.ZodOptional<z.ZodString>;
+    reasonCode: z.ZodOptional<z.ZodString>;
+    reasonLabel: z.ZodOptional<z.ZodString>;
+    policyId: z.ZodOptional<z.ZodString>;
+    policyIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    blockers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        kind: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodDefault<z.ZodString>;
+    producer: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            tool: "tool";
+            schedule: "schedule";
+            policy: "policy";
+            agent: "agent";
+            operator: "operator";
+            application: "application";
+            "provider-adapter": "provider-adapter";
+            journey: "journey";
+        }>;
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    channel: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        channelId: z.ZodString;
+        kind: z.ZodString;
+        provider: z.ZodOptional<z.ZodString>;
+        externalThreadId: z.ZodOptional<z.ZodString>;
+        externalConversationId: z.ZodOptional<z.ZodString>;
+        externalMessageId: z.ZodOptional<z.ZodString>;
+        externalUserId: z.ZodOptional<z.ZodString>;
+        locale: z.ZodOptional<z.ZodString>;
+        timezone: z.ZodOptional<z.ZodString>;
+        capabilities: z.ZodDefault<z.ZodDefault<z.ZodObject<{
+            realtime: z.ZodDefault<z.ZodBoolean>;
+            async: z.ZodDefault<z.ZodBoolean>;
+            voice: z.ZodDefault<z.ZodBoolean>;
+            audioInput: z.ZodDefault<z.ZodBoolean>;
+            audioOutput: z.ZodDefault<z.ZodBoolean>;
+            richText: z.ZodDefault<z.ZodBoolean>;
+            markdown: z.ZodDefault<z.ZodBoolean>;
+            html: z.ZodDefault<z.ZodBoolean>;
+            attachments: z.ZodDefault<z.ZodBoolean>;
+            images: z.ZodDefault<z.ZodBoolean>;
+            files: z.ZodDefault<z.ZodBoolean>;
+            widgets: z.ZodDefault<z.ZodBoolean>;
+            buttons: z.ZodDefault<z.ZodBoolean>;
+            quickReplies: z.ZodDefault<z.ZodBoolean>;
+            templates: z.ZodDefault<z.ZodBoolean>;
+            publicReplies: z.ZodDefault<z.ZodBoolean>;
+            privateReplies: z.ZodDefault<z.ZodBoolean>;
+            typingIndicator: z.ZodDefault<z.ZodBoolean>;
+            readReceipts: z.ZodDefault<z.ZodBoolean>;
+            deliveryReceipts: z.ZodDefault<z.ZodBoolean>;
+            threaded: z.ZodDefault<z.ZodBoolean>;
+            supportsHumanTransfer: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>]>>;
+    deliveryMode: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        send: "send";
+        draft: "draft";
+        notify: "notify";
+        artifact: "artifact";
+        approval: "approval";
+        "handoff-review": "handoff-review";
+        "provider-operation": "provider-operation";
+    }>>;
+    capability: z.ZodOptional<z.ZodString>;
+    providerPackageId: z.ZodOptional<z.ZodString>;
+    operationAlias: z.ZodOptional<z.ZodString>;
+    providerOperation: z.ZodOptional<z.ZodString>;
+    actionAudience: z.ZodOptional<z.ZodEnum<{
+        "customer-facing": "customer-facing";
+        "internal-support": "internal-support";
+        mixed: "mixed";
+    }>>;
+    outbound: z.ZodOptional<z.ZodBoolean>;
+    sideEffect: z.ZodOptional<z.ZodBoolean>;
+    externallyVisible: z.ZodOptional<z.ZodBoolean>;
+    exposesSensitiveData: z.ZodOptional<z.ZodBoolean>;
+    changesWorkflow: z.ZodOptional<z.ZodBoolean>;
+    requiredPolicyIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    text: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+    body: z.ZodOptional<z.ZodString>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    payload: z.ZodOptional<z.ZodUnknown>;
+    source: z.ZodOptional<z.ZodObject<{
+        sourceType: z.ZodOptional<z.ZodEnum<{
+            application: "application";
+            "provider-adapter": "provider-adapter";
+            "schedule-adapter": "schedule-adapter";
+            "operator-surface": "operator-surface";
+        }>>;
+        sourceId: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+        providerPackageId: z.ZodOptional<z.ZodString>;
+        eventId: z.ZodOptional<z.ZodString>;
+        streamId: z.ZodOptional<z.ZodString>;
+        deliveryId: z.ZodOptional<z.ZodString>;
+        receivedAt: z.ZodOptional<z.ZodString>;
+        verified: z.ZodOptional<z.ZodBoolean>;
+        externalObjectIds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        raw: z.ZodOptional<z.ZodUnknown>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+}, z.core.$loose>;
+declare const ChannelOutputResolutionDecisionInputSchema: z.ZodObject<{
+    reason: z.ZodOptional<z.ZodString>;
+    reasonCode: z.ZodOptional<z.ZodString>;
+    reasonLabel: z.ZodOptional<z.ZodString>;
+    policyId: z.ZodOptional<z.ZodString>;
+    policyIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    blockers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        kind: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    outcome: z.ZodEnum<{
+        send: "send";
+        draft: "draft";
+        notify: "notify";
+        artifact: "artifact";
+        defer: "defer";
+        "handoff-review": "handoff-review";
+        "no-op": "no-op";
+        "provider-operation": "provider-operation";
+        "approval-required": "approval-required";
+        block: "block";
+        drop: "drop";
+    }>;
+    status: z.ZodOptional<z.ZodEnum<{
+        blocked: "blocked";
+        deferred: "deferred";
+        "no-op": "no-op";
+        resolved: "resolved";
+        pending: "pending";
+    }>>;
+    deliveryMode: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        send: "send";
+        draft: "draft";
+        notify: "notify";
+        artifact: "artifact";
+        approval: "approval";
+        "handoff-review": "handoff-review";
+        "provider-operation": "provider-operation";
+    }>>;
+    capability: z.ZodOptional<z.ZodString>;
+    providerPackageId: z.ZodOptional<z.ZodString>;
+    operationAlias: z.ZodOptional<z.ZodString>;
+    providerOperation: z.ZodOptional<z.ZodString>;
+    actionAudience: z.ZodOptional<z.ZodEnum<{
+        "customer-facing": "customer-facing";
+        "internal-support": "internal-support";
+        mixed: "mixed";
+    }>>;
+    supportedApprovalResolutions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    editableFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    expiresAt: z.ZodOptional<z.ZodString>;
+    payload: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>;
+declare function defineChannelEvent<TPayload = NormalizedChannelPayload, TRawPayload = unknown>(input: ChannelEventEnvelopeInput<TPayload, TRawPayload>): ChannelEventEnvelope<TPayload, TRawPayload>;
+declare function channelEventDedupeKey(event: ChannelEventEnvelopeInput<unknown> | ChannelEventEnvelope<unknown>): string | undefined;
+declare function createMessageChannelEvent(input: {
+    id?: string;
+    channel: ConversationChannelInput;
     text: string;
-    recordingReferenceId?: string;
-    startedAtMs?: number;
-    endedAtMs?: number;
-    transcriptionSource?: string;
+    direction?: ChannelEventDirection;
+    intent?: ChannelEventIntent;
+    actor?: ChannelEventActor | ChannelEventActor["type"];
+    payload?: NormalizedChannelPayloadInput;
+    identity?: ChannelEventIdentity;
+    source?: ChannelEventSourceEvidence;
     metadata?: Record<string, unknown>;
+}): ChannelEventEnvelopeInput;
+declare function createScheduledChannelEvent(input: {
+    scheduleId: string;
+    conversationId?: string;
+    channel?: ConversationChannelInput;
+    dueAt: string;
+    scheduledFor?: string;
+    eventName: string;
+    payload?: unknown;
+    intent?: unknown;
+    metadata?: Record<string, unknown>;
+}): ChannelEventEnvelopeInput;
+declare function defineChannelOutputIntent<TPayload = NormalizedChannelPayload, TRawPayload = unknown>(input: ChannelOutputIntentInput<TPayload, TRawPayload>): ChannelOutputIntent<TPayload, TRawPayload>;
+declare function defineChannelOutputResolutionDecision<TPayload = unknown>(input: ChannelOutputResolutionDecision<TPayload>): ChannelOutputResolutionDecision<TPayload>;
+declare class CapabilityScope<TItem> {
+    private readonly items;
+    private onlyItems;
+    private readonly excludedItems;
+    add(...items: TItem[]): this;
+    only(...items: TItem[]): this;
+    exclude(...items: TItem[]): this;
+    list(inherited?: TItem[]): TItem[];
 }
-interface CommitVoiceTranscriptReferenceInput extends CommitVoiceTranscriptInput {
-    messageEventId: string;
-}
-interface CommitVoiceTranscriptResult {
-    message: RuntimeEvent;
-    event: RuntimeEvent;
-    events: RuntimeEvent[];
-}
-interface RecordVoiceInterruptionInput {
-    conversationId: string;
-    channelSegmentId: string;
-    connectionId?: string;
-    interruptedMessageId?: string;
-    source?: "userSpeech" | "adapter" | "provider";
-    reason?: string;
-    recordingReferenceId?: string;
-    offsetMs?: number;
-}
-type VoiceRuntimeEventInput = Extract<RuntimeEventInput, {
-    type: `voice.${string}`;
-}>;
-interface RuntimeSnapshot {
-    conversationId: string;
-    lifecycle: ConversationLifecycle;
-    activeJourneyId?: string;
-    activeStateIds: string[];
-    journeyContext?: unknown;
-    journeyContexts?: JourneyContextRecord[];
-    journeySummaries?: JourneySummary[];
-    compactionSummary?: unknown;
-    definitionHash?: string;
-    updatedAt: string;
-}
-interface JourneySummary {
-    journeyId: string;
-    kind: "stateMachine" | "delegation";
-    summary: string;
-    completedAt: string;
-    stateId?: string;
-    reason?: string;
-}
-interface JourneyContextRecord {
-    journeyId: string;
-    context: unknown;
-    updatedAt: string;
-    stateId?: string;
-}
-declare class DefinitionError extends Error {
-    constructor(message: string);
-}
-declare const conversationCompactionSummarySchema: z.ZodObject<{
-    summary: z.ZodString;
-    stableFacts: z.ZodArray<z.ZodString>;
-    openQuestions: z.ZodArray<z.ZodString>;
-    activeCommitments: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
-type ConversationCompactionSummary = z.infer<typeof conversationCompactionSummarySchema>;
-declare class CapabilityScope<TItem> {
-    private readonly items;
-    private onlyItems;
-    private readonly excludedItems;
-    add(...items: TItem[]): this;
-    only(...items: TItem[]): this;
-    exclude(...items: TItem[]): this;
-    list(inherited?: TItem[]): TItem[];
-}
-type MaybePromise$1<T> = T | Promise<T>;
-type FieldWidgetOption = WidgetDefinition | WidgetPromptDefinition;
-interface ConfirmationPolicy {
-    message?: string;
-    widget?: WidgetDefinition;
+type MaybePromise$1<T> = T | Promise<T>;
+type FieldWidgetOption = WidgetDefinition | WidgetPromptDefinition;
+interface ConfirmationPolicy {
+    message?: string;
+    widget?: WidgetDefinition;
     reason?: string;
 }
 interface FieldCollectionOptions<TContext> {
@@ -726,6 +2229,7 @@ declare function tool<const TName extends string, TInputSchema extends z.ZodType
     input: TInputSchema;
     output: TOutputSchema;
     sideEffect?: TSideEffect;
+    policy?: ToolPolicyOptions;
     idempotencyKey?: (args: {
         input: z.infer<TInputSchema>;
         conversationId: string;
@@ -738,8 +2242,8 @@ declare function widget<const TKind extends string, TInputSchema extends z.ZodTy
 }): WidgetDefinition<TKind, TInputSchema, TOutputSchema>;
 declare function widgetPrompt<TWidget extends WidgetDefinition>(widgetDefinition: TWidget, input: z.infer<TWidget["input"]>): WidgetPromptDefinition<TWidget>;
 declare function knowledgeSource<const TName extends string, TQuerySchema extends z.ZodType, TMetadataSchema extends z.ZodType>(name: TName, config: Omit<KnowledgeSource<TName, TQuerySchema, TMetadataSchema>, "kind" | "name">): {
-    query: TQuerySchema;
     metadata: TMetadataSchema;
+    query: TQuerySchema;
     retrieve: (input: {
         query: z.core.output<TQuerySchema>;
         signal?: AbortSignal;
@@ -777,6 +2281,10 @@ interface CompiledAgent {
     id: string;
     instructions: string;
     logLevel?: AgentLogLevel;
+    persona?: AgentPersonaOptions;
+    channels?: AgentChannelPolicyMap;
+    configuration?: AgentConfigurationOptions;
+    handoff?: AgentHandoffPolicyOptions;
     behavior: AgentBehaviorOptions;
     postProcessing: AgentPostProcessingOptions;
     voice?: VoiceProfile;
@@ -995,9 +2503,29 @@ interface AgentPostProcessingOptions {
     citations?: boolean;
 }
 type AgentLogLevel = "trace" | "debug" | "info" | "error";
+type AgentPolicyValue = string | number | boolean | null | AgentPolicyValue[] | {
+    [key: string]: AgentPolicyValue;
+};
+type AgentPersonaOptions = Record<string, AgentPolicyValue>;
+type AgentChannelPolicyOptions = Record<string, AgentPolicyValue>;
+type AgentChannelPolicyMap = Record<string, AgentChannelPolicyOptions>;
+type AgentHandoffPolicyOptions = Record<string, AgentPolicyValue>;
+interface AgentConfigurationOptions {
+    channelSets?: ChannelSetConfigInput[];
+    channels?: ChannelPolicyConfigInput[];
+    providerPackages?: ProviderManifestInput[];
+    capabilityAvailability?: CapabilityAvailabilityInput[];
+    credentialStatuses?: ProviderCredentialStatusInput[];
+    providerReadiness?: ProviderReadinessInput[];
+    policyIds?: string[];
+}
 interface AgentOptions {
     instructions: string;
     logLevel?: AgentLogLevel;
+    persona?: AgentPersonaOptions;
+    channels?: AgentChannelPolicyMap;
+    configuration?: AgentConfigurationOptions;
+    handoff?: AgentHandoffPolicyOptions;
     behavior?: AgentBehaviorOptions;
     postProcessing?: AgentPostProcessingOptions;
 }
@@ -1286,6 +2814,46 @@ declare function selectJourneyCandidates<TApp, TConversation, TTurn>(options: Se
 declare function validateJourneyIndex(agent: CompiledAgent, index: JourneyIndex, options?: ValidateJourneyIndexOptions): JourneyIndexValidationResult;
+interface ConversationRecord<TConversationContext = unknown> {
+    id: string;
+    agentId: string;
+    lifecycle: ConversationLifecycle;
+    context: TConversationContext;
+    channel?: ConversationChannel;
+    createdAt: string;
+    updatedAt: string;
+}
+type RuntimeEventInput<TType extends RuntimeEvent["type"] = RuntimeEvent["type"]> = Omit<Extract<RuntimeEvent, {
+    type: TType;
+}>, "id" | "offset" | "createdAt" | "telemetry"> & {
+    id?: string;
+    createdAt?: string;
+    telemetry?: RuntimeEvent["telemetry"];
+};
+interface ListEventsOptions {
+    conversationId: string;
+    afterOffset?: number;
+    limit?: number;
+}
+interface CreateConversationInput<TConversationContext = unknown> {
+    id?: string;
+    agentId: string;
+    context: TConversationContext;
+    channel?: ConversationChannelInput;
+}
+interface StorageAdapter {
+    initialize?(): Promise<void> | void;
+    createConversation<TConversationContext = unknown>(input: CreateConversationInput<TConversationContext>): Promise<ConversationRecord<TConversationContext>>;
+    getConversation<TConversationContext = unknown>(conversationId: string): Promise<ConversationRecord<TConversationContext> | null>;
+    updateConversationLifecycle(conversationId: string, lifecycle: ConversationLifecycle): Promise<ConversationRecord | null>;
+    appendEvent<TEvent extends RuntimeEventInput>(event: TEvent): Promise<RuntimeEvent>;
+    appendEventIfApprovalPending?<TEvent extends RuntimeEventInput<"approval.resolved">>(event: TEvent): Promise<RuntimeEvent | null>;
+    appendEventIfNoActiveVoiceSegment?<TEvent extends RuntimeEventInput<"voice.segment.started">>(event: TEvent): Promise<RuntimeEvent | null>;
+    listEvents(options: ListEventsOptions): Promise<RuntimeEvent[]>;
+    saveSnapshot(snapshot: RuntimeSnapshot): Promise<void>;
+    getSnapshot(conversationId: string): Promise<RuntimeSnapshot | null>;
+}
 interface ReplayedMessage {
     id: string;
     offset: number;
@@ -1303,6 +2871,140 @@ interface ReplayedPrompt {
     input: unknown;
 }
+declare const conversationCompactionSummarySchema: z.ZodObject<{
+    summary: z.ZodString;
+    stableFacts: z.ZodArray<z.ZodString>;
+    openQuestions: z.ZodArray<z.ZodString>;
+    activeCommitments: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type ConversationCompactionSummary = z.infer<typeof conversationCompactionSummarySchema>;
+interface RuntimeApprovalEvaluationInput {
+    conversation: ConversationRecord;
+    tool: AnyTool;
+    input: unknown;
+    channel?: ChannelContext;
+}
+interface PendingSupportAction {
+    approvalId: string;
+    conversationId: string;
+    requestedEventId: string;
+    requestedAt: string;
+    toolName: string;
+    input: unknown;
+    channel?: ChannelContext;
+    providerPackageId?: string;
+    operationAlias?: string;
+    providerOperation?: string;
+    capability?: string;
+    actionAudience?: string;
+    sideEffect?: boolean;
+    outbound?: boolean;
+    externallyVisible?: boolean;
+    exposesSensitiveData?: boolean;
+    changesWorkflow?: boolean;
+    reason?: string;
+    supportedResolutions: ApprovalResolutionMode[];
+    editableFields?: string[];
+    expiresAt?: string;
+    journeyId?: string;
+    stateId?: string;
+    metadata?: Record<string, unknown>;
+}
+interface ListPendingSupportActionsInput {
+    conversationId: string;
+}
+interface ResolvePendingSupportActionInput {
+    conversationId: string;
+    approvalId: string;
+    resolution: ApprovalResolutionMode;
+    editedInput?: unknown;
+    resolvedBy?: string;
+    reason?: string;
+    metadata?: Record<string, unknown>;
+    signal?: AbortSignal;
+}
+interface ResolvePendingSupportActionResult {
+    action: PendingSupportAction;
+    resolution: RuntimeEvent;
+    events: RuntimeEvent[];
+    executed: boolean;
+    result?: unknown;
+}
+interface EmitCustomEventInput<TEvent extends CustomRuntimeEventDefinition = CustomRuntimeEventDefinition> {
+    conversationId: string;
+    event: TEvent;
+    payload: z.infer<TEvent["payload"]>;
+}
+interface EmitJourneyEventInput<TEvent extends JourneyEventDefinition = JourneyEventDefinition> {
+    conversationId: string;
+    event: TEvent;
+    payload: z.infer<TEvent["payload"]>;
+    routing?: EventRoutingMode;
+    target?: {
+        journeyId?: string;
+        stateId?: string;
+    };
+    app?: unknown;
+    signal?: AbortSignal;
+}
+interface EmitJourneyEventResult {
+    event: RuntimeEvent;
+    snapshot: RuntimeSnapshot | null;
+    events: RuntimeEvent[];
+}
+interface EmitScheduledEventInput<TEvent extends JourneyEventDefinition = JourneyEventDefinition> {
+    conversationId: string;
+    scheduleId: string;
+    event: TEvent;
+    payload: z.infer<TEvent["payload"]>;
+    scheduledFor?: string;
+    dueAt?: string;
+    routing?: EventRoutingMode;
+    target?: {
+        journeyId?: string;
+        stateId?: string;
+    };
+    intent?: {
+        operationAlias?: string;
+        providerPackageId?: string;
+        capability?: string;
+        reason?: string;
+    };
+    metadata?: Record<string, unknown>;
+    app?: unknown;
+    signal?: AbortSignal;
+}
+interface EmitScheduledEventResult extends EmitJourneyEventResult {
+    channelEvent: ChannelEvent;
+    intake: ChannelEventIntakeResult;
+    scheduleEvent: RuntimeEvent;
+}
+interface RequestHandoffInput {
+    conversationId: string;
+    reason: string;
+    summary?: string;
+    target?: {
+        providerPackageId?: string;
+        destination?: string;
+        channelId?: string;
+        queue?: string;
+        externalConversationId?: string;
+        policyId?: string;
+    };
+    payload?: unknown;
+}
+interface ResumeConversationInput {
+    conversationId: string;
+    reason?: string;
+    payload?: unknown;
+}
+interface CompactConversationResult<TSummary = ConversationCompactionSummary> {
+    summary: TSummary;
+    snapshot: RuntimeSnapshot;
+    events: RuntimeEvent[];
+}
 type MaybePromise<T> = Promise<T> | T;
 interface PrivacyHookContext {
     conversationId: string;
@@ -1321,6 +3023,14 @@ interface PrivacyHooks {
     redactConversationContext?(input: PrivacyHookContext & {
         context: unknown;
     }): MaybePromise<unknown>;
+    redactInboundChannelEvent?(input: PrivacyHookContext & {
+        event: RuntimeEventInput<"channel.received">;
+        channel: ChannelContext;
+    }): MaybePromise<RuntimeEventInput<"channel.received">>;
+    redactOutboundChannelMessage?(input: PrivacyHookContext & {
+        event: RuntimeEventInput<"channel.sent">;
+        channel: ChannelContext;
+    }): MaybePromise<RuntimeEventInput<"channel.sent">>;
     redactRuntimeEvent?(input: PrivacyHookContext & {
         event: RuntimeEventInput;
     }): MaybePromise<RuntimeEventInput>;
@@ -1332,6 +3042,18 @@ interface PrivacyHooks {
     }): MaybePromise<TextGenerationInput>;
 }
+interface RuntimeContextResolveInput<TTurn = unknown> {
+    conversation: ConversationRecord;
+    turn: TTurn;
+    channel?: ChannelContext;
+    app: unknown;
+    text: string;
+}
+interface RuntimeContextOptions<TTurn = unknown> {
+    resolve?(input: RuntimeContextResolveInput<TTurn>): unknown | Promise<unknown>;
+    schema?: z.ZodType;
+    redact?: string[];
+}
 interface RuntimeOptions {
     storage: StorageAdapter;
     agent?: CompiledAgent;
@@ -1339,6 +3061,7 @@ interface RuntimeOptions {
     journeyIndex?: JourneyIndex;
     topKJourneys?: number;
     app?: unknown;
+    context?: RuntimeContextOptions;
     knowledgeLimit?: number;
     privacy?: PrivacyHooks;
     telemetry?: RuntimeTelemetryOptions;
@@ -1355,129 +3078,769 @@ interface RuntimeOptions {
     postProcessing?: {
         citations?: boolean;
     };
-    streaming?: {
-        syntheticDeltas?: boolean;
+    streaming?: {
+        syntheticDeltas?: boolean;
+    };
+    toolRetry?: {
+        maxAttempts?: number;
+        notice?: string;
+    };
+    approval?: {
+        evaluate?(input: RuntimeApprovalEvaluationInput): RuntimeApprovalDecision | null | undefined;
+    };
+    channelOutput?: {
+        resolve?(input: ChannelOutputResolutionPolicyInput): ChannelOutputResolutionDecision | null | undefined | Promise<ChannelOutputResolutionDecision | null | undefined>;
+        execute?(input: ChannelOutputResolverInput): ChannelOutputResolverResult | Promise<ChannelOutputResolverResult>;
+    };
+    channelSets?: ChannelSetConfig[];
+    channels?: ChannelPolicyConfig[];
+    providerPackages?: ProviderManifest[];
+    capabilityAvailability?: CapabilityAvailability[];
+    providerCredentialStatuses?: ProviderCredentialStatus[];
+    providerReadiness?: ProviderReadiness[];
+}
+interface RuntimeConfigurationSource {
+    channelSets?: ChannelSetConfig[];
+    channels?: ChannelPolicyConfig[];
+    providerPackages?: ProviderManifest[];
+    capabilityAvailability?: CapabilityAvailability[];
+    credentialStatuses?: ProviderCredentialStatus[];
+    providerReadiness?: ProviderReadiness[];
+}
+interface CreateRuntimeConversationInput<TConversationContext = unknown> extends CreateConversationInput<TConversationContext> {
+}
+interface HandleUserMessageInput<TTurn = unknown> {
+    conversationId: string;
+    text: string;
+    channel?: ConversationChannel;
+    turn?: TTurn;
+    app?: unknown;
+    signal?: AbortSignal;
+    recordUserMessage?: boolean;
+    assistantMessageMode?: "canonical" | "intermediate" | "none";
+    onAssistantTextDelta?(textDelta: string): Promise<void> | void;
+}
+interface HandleUserMessageResult {
+    conversation: ConversationRecord;
+    snapshot: RuntimeSnapshot;
+    events: RuntimeEvent[];
+    text: string;
+    activeJourneyId?: string;
+}
+interface ChannelEventBindingInput {
+    outcome?: ChannelEventBindingOutcome;
+    conversationId?: string;
+    agentId?: string;
+    conversationContext?: unknown;
+    linkedConversationId?: string;
+    reason?: string;
+    reasonCode?: string;
+    reasonLabel?: string;
+    blockers?: Array<{
+        code: string;
+        message: string;
+        kind?: string;
+    }>;
+    metadata?: Record<string, unknown>;
+}
+interface ChannelEventHandlingInput<TTurn = unknown> {
+    disposition?: ChannelEventHandlingDisposition;
+    text?: string;
+    turn?: TTurn;
+    recordUserMessage?: HandleUserMessageInput<TTurn>["recordUserMessage"];
+    assistantMessageMode?: HandleUserMessageInput<TTurn>["assistantMessageMode"];
+}
+interface HandleChannelEventInput<TPayload = unknown, TTurn = unknown> {
+    event: ChannelEventEnvelopeInput<TPayload>;
+    conversationId?: string;
+    agentId?: string;
+    conversationContext?: unknown;
+    createConversation?: CreateRuntimeConversationInput;
+    binding?: ChannelEventBindingInput;
+    handling?: ChannelEventHandlingInput<TTurn>;
+    app?: unknown;
+    signal?: AbortSignal;
+    onAssistantTextDelta?(textDelta: string): Promise<void> | void;
+}
+interface HandleChannelEventResult<TPayload = unknown> {
+    channelEvent: ChannelEvent<TPayload>;
+    intake: ChannelEventIntakeResult;
+    disposition: ChannelEventHandlingDisposition;
+    conversation?: ConversationRecord;
+    turn?: HandleUserMessageResult;
+    snapshot?: RuntimeSnapshot;
+    events: RuntimeEvent[];
+    text?: string;
+    activeJourneyId?: string;
+}
+interface RequestOutboundContactInput<TPayload = unknown> {
+    conversationId?: string;
+    agentId?: string;
+    conversationContext?: unknown;
+    channel: ConversationChannelInput;
+    text?: string;
+    payload?: TPayload;
+    app?: unknown;
+    signal?: AbortSignal;
+    binding?: ChannelEventBindingInput;
+    handling?: ChannelEventHandlingInput;
+}
+interface RequestChannelHandoffReviewInput<TPayload = unknown> {
+    conversationId?: string;
+    agentId?: string;
+    conversationContext?: unknown;
+    channel: ConversationChannelInput;
+    payload?: TPayload;
+    reason?: string;
+    reasonCode?: string;
+    reasonLabel?: string;
+    app?: unknown;
+    signal?: AbortSignal;
+    binding?: ChannelEventBindingInput;
+    handling?: ChannelEventHandlingInput;
+}
+interface RequestChannelHandoffInput<TPayload = unknown> {
+    conversationId: string;
+    fromChannel?: ConversationChannelInput;
+    toChannel: ConversationChannelInput;
+    payload?: TPayload;
+    reason?: string;
+    reasonCode?: string;
+    reasonLabel?: string;
+    app?: unknown;
+    signal?: AbortSignal;
+    binding?: ChannelEventBindingInput;
+    handling?: ChannelEventHandlingInput;
+}
+interface ChannelOutputResolutionPolicyInput<TPayload = unknown> {
+    conversation: ConversationRecord;
+    intent: ChannelOutputIntent<TPayload>;
+    channel: ChannelContext;
+    defaultResolution: ChannelOutputResolutionDecision;
+    capabilityDecision?: CapabilityUseDecision;
+    app: unknown;
+}
+interface ResolveChannelOutputInput<TPayload = unknown> {
+    conversationId: string;
+    intent: ChannelOutputIntentInput<TPayload>;
+    resolution?: ChannelOutputResolutionDecision;
+    app?: unknown;
+    signal?: AbortSignal;
+}
+interface ResolveChannelOutputResult<TPayload = unknown> {
+    conversation?: ConversationRecord;
+    outputIntent: ChannelOutputIntent<TPayload>;
+    resolution: ChannelOutputResolution;
+    channelEvent?: ChannelEvent<ChannelOutputResolutionPayload<TPayload>>;
+    event?: RuntimeEvent;
+    events: RuntimeEvent[];
+    shouldExecute: boolean;
+    execution?: ChannelOutputResolverResult;
+}
+interface HandleVoiceUserMessageInput<TTurn = unknown> extends HandleUserMessageInput<TTurn> {
+    channelSegmentId: string;
+    connectionId?: string;
+    recordingReferenceId?: string;
+    startedAtMs?: number;
+    endedAtMs?: number;
+    transcriptionSource?: string;
+    metadata?: Record<string, unknown>;
+}
+interface HandleVoiceUserMessageResult extends HandleUserMessageResult {
+    voiceEvents: RuntimeEvent[];
+}
+interface CompactConversationInput {
+    conversationId: string;
+    fromOffset?: number;
+    toOffset?: number;
+    schemaVersion?: string;
+    signal?: AbortSignal;
+}
+interface ReplayConversationInput {
+    conversationId: string;
+    afterOffset?: number;
+}
+interface ReplayConversationResult {
+    conversation: ConversationRecord;
+    snapshot: RuntimeSnapshot | null;
+    events: RuntimeEvent[];
+    messages: ReplayedMessage[];
+    openPrompts: ReplayedPrompt[];
+}
+interface ExplainTurnInput<TTurn = unknown> extends HandleUserMessageInput<TTurn> {
+}
+interface ExplainTurnResult {
+    conversationId: string;
+    agentId: string;
+    channel?: ChannelContext;
+    persona?: unknown;
+    agentChannelPolicy?: unknown;
+    channelPolicy?: unknown;
+    handoffPolicy?: unknown;
+    conversationContext?: unknown;
+    resolvedContext?: unknown;
+    resolvedContextKeys: string[];
+    policyEventData: Record<string, unknown>;
+}
+interface SubmitWidgetInput {
+    conversationId: string;
+    promptId: string;
+    widgetKind: string;
+    output: unknown;
+}
+interface EmitIntermediateMessageInput {
+    conversationId: string;
+    text: string;
+    visibleToModel?: boolean;
+}
+interface EmitGeneratedPreambleInput {
+    conversationId: string;
+    purpose?: string;
+    maxWords?: number;
+    signal?: AbortSignal;
+}
+interface EmitGeneratedPreambleResult {
+    text: string;
+    events: RuntimeEvent[];
+}
+type ChannelAdapterVerificationResult = {
+    verified: true;
+    evidence?: Record<string, unknown>;
+} | {
+    verified: false;
+    reason?: string;
+    reasonCode?: string;
+    metadata?: Record<string, unknown>;
+};
+interface ChannelEventSourceNormalizeInput<TRaw = unknown> {
+    raw: TRaw;
+    channel?: ConversationChannelInput;
+    source?: ChannelEventSourceEvidence<TRaw>;
+    app?: unknown;
+}
+interface ChannelEventSourceBindInput {
+    event: ChannelEventEnvelopeInput;
+    app?: unknown;
+}
+interface ChannelEventSourceBinding {
+    conversationId?: string;
+    agentId?: string;
+    conversationContext?: unknown;
+    outcome?: "start-new" | "resume-existing" | "link-and-start-new" | "ignore" | "defer" | "handoff-review" | "blocked";
+    reason?: string;
+    reasonCode?: string;
+    reasonLabel?: string;
+    metadata?: Record<string, unknown>;
+}
+interface ChannelEventSource<TRaw = unknown> {
+    id: string;
+    channel?: ConversationChannelInput;
+    sourceType?: ChannelEventSourceEvidence<TRaw>["sourceType"];
+    verify?(raw: TRaw): ChannelAdapterVerificationResult | Promise<ChannelAdapterVerificationResult>;
+    normalize(input: ChannelEventSourceNormalizeInput<TRaw>): ChannelEventEnvelopeInput | Promise<ChannelEventEnvelopeInput>;
+    identity?(event: ChannelEventEnvelopeInput, raw: TRaw): ChannelEventIdentity | string | undefined | Promise<ChannelEventIdentity | string | undefined>;
+    bind?(input: ChannelEventSourceBindInput): ChannelEventSourceBinding | Promise<ChannelEventSourceBinding>;
+}
+interface ChannelProviderAdapter<TRaw = unknown> extends ChannelEventSource<TRaw> {
+    provider: string;
+    providerPackageId?: string;
+    resolveOutput?(input: ChannelOutputResolverInput): Promise<ChannelOutputResolverResult>;
+}
+interface ChannelEventSourceHandleInput<TRaw = unknown, TTurn = unknown> {
+    raw: TRaw;
+    channel?: ConversationChannelInput;
+    conversationId?: string;
+    agentId?: string;
+    conversationContext?: unknown;
+    createConversation?: CreateRuntimeConversationInput;
+    binding?: ChannelEventBindingInput;
+    handling?: ChannelEventHandlingInput<TTurn>;
+    app?: unknown;
+    signal?: AbortSignal;
+    onAssistantTextDelta?(textDelta: string): Promise<void> | void;
+}
+interface ChannelEventRuntimeReceiver {
+    handleChannelEvent<TPayload = unknown, TTurn = unknown>(input: HandleChannelEventInput<TPayload, TTurn>): Promise<HandleChannelEventResult<TPayload>>;
+}
+declare function defineChannelEventSource<TRaw = unknown>(source: ChannelEventSource<TRaw>): ChannelEventSource<TRaw>;
+declare function defineChannelProviderAdapter<TRaw = unknown>(adapter: ChannelProviderAdapter<TRaw>): ChannelProviderAdapter<TRaw>;
+declare function createChannelEventInputFromSource<TRaw = unknown, TTurn = unknown>(source: ChannelEventSource<TRaw>, input: ChannelEventSourceHandleInput<TRaw, TTurn>): Promise<HandleChannelEventInput<unknown, TTurn>>;
+declare function handleChannelEventFromSource<TRaw = unknown, TTurn = unknown>(runtime: ChannelEventRuntimeReceiver, source: ChannelEventSource<TRaw>, input: ChannelEventSourceHandleInput<TRaw, TTurn>): Promise<HandleChannelEventResult>;
+interface RuntimeEventBase<TType extends string, TData> {
+    id: string;
+    conversationId: string;
+    offset: number;
+    type: TType;
+    createdAt: string;
+    telemetry?: RuntimeEventTelemetry;
+    data: TData;
+}
+type ConversationLifecycle = "active" | "handoff" | "closed";
+interface MessageSegment {
+    id: string;
+    text: string;
+    references?: SupportReference[];
+}
+type SupportReference = {
+    type: "knowledge";
+    id: string;
+    sourceName?: string;
+    title?: string;
+    metadata?: unknown;
+} | {
+    type: "toolResult";
+    id: string;
+};
+type RuntimeEvent = RuntimeEventBase<"message.started", {
+    role: "assistant" | "user";
+}> | RuntimeEventBase<"message.delta", {
+    textDelta: string;
+}> | RuntimeEventBase<"message.completed", {
+    text: string;
+    segments?: MessageSegment[];
+    usage?: UsageRecord;
+    intermediate?: boolean;
+    visibleToModel?: boolean;
+}> | RuntimeEventBase<"message.generated", {
+    textLength: number;
+    toolCallCount?: number;
+    usage?: UsageRecord;
+    channel?: ChannelContext;
+    policyApplied?: {
+        truncated?: boolean;
+        maxWords?: number;
+        maxCharacters?: number;
+    };
+}> | RuntimeEventBase<"message.aborted", {
+    reason: string;
+    partialText?: string;
+}> | RuntimeEventBase<"channel.event.received", {
+    eventId?: string;
+    kind: ChannelEventKind;
+    direction?: ChannelEventDirection;
+    intent?: ChannelEventIntent;
+    actor?: ChannelEventActor;
+    channel: ChannelContext;
+    bindingOutcome: ChannelEventBindingOutcome;
+    handlingDisposition: ChannelEventHandlingDisposition;
+    occurredAt?: string;
+    payload?: unknown;
+    identity?: ChannelEventIdentity;
+    source?: ChannelSourceEvidence;
+    metadata?: Record<string, unknown>;
+}> | RuntimeEventBase<"channel.received", {
+    channel: ChannelContext;
+    text?: string;
+    payload?: unknown;
+}> | RuntimeEventBase<"channel.sent", {
+    channel: ChannelContext;
+    text?: string;
+    payload?: unknown;
+}> | RuntimeEventBase<"channel.delivery.updated", {
+    channel: ChannelContext;
+    status: string;
+    payload?: unknown;
+}> | RuntimeEventBase<"channel.thread.linked", {
+    channel: ChannelContext;
+    previousChannel?: ChannelContext;
+    reason?: string;
+}> | RuntimeEventBase<"voice.segment.started", {
+    channelSegmentId: string;
+    connectionId: string;
+    adapter: string;
+    provider?: string;
+}> | RuntimeEventBase<"voice.segment.ended", {
+    channelSegmentId: string;
+    connectionId?: string;
+    reason?: string;
+}> | RuntimeEventBase<"voice.connection.failed", {
+    channelSegmentId: string;
+    connectionId?: string;
+    code: string;
+    message: string;
+    retryable?: boolean;
+}> | RuntimeEventBase<"voice.interrupted", {
+    channelSegmentId: string;
+    connectionId?: string;
+    interruptedMessageId?: string;
+    source?: "userSpeech" | "adapter" | "provider";
+    reason?: string;
+    recordingReferenceId?: string;
+    offsetMs?: number;
+}> | RuntimeEventBase<"voice.recording.started", {
+    channelSegmentId: string;
+    recordingReferenceId: string;
+    policy?: unknown;
+}> | RuntimeEventBase<"voice.recording.completed", {
+    channelSegmentId: string;
+    recordingReferenceId: string;
+    uri?: string;
+    startedAt?: string;
+    endedAt?: string;
+    metadata?: unknown;
+}> | RuntimeEventBase<"voice.transcript.committed", {
+    channelSegmentId: string;
+    speaker: "user" | "assistant";
+    messageEventId: string;
+    recordingReferenceId?: string;
+    startedAtMs?: number;
+    endedAtMs?: number;
+    transcriptionSource?: string;
+    metadata?: unknown;
+}> | RuntimeEventBase<"journey.candidates.retrieved", {
+    journeyIds: string[];
+}> | RuntimeEventBase<"journey.matched", {
+    candidates: Array<{
+        journeyId: string;
+        confidence: number;
+        reason?: string;
+    }>;
+}> | RuntimeEventBase<"journey.activated", {
+    journeyId: string;
+    previousJourneyId?: string;
+}> | RuntimeEventBase<"journey.completed", {
+    journeyId: string;
+    stateId?: string;
+    reason?: string;
+}> | RuntimeEventBase<"journey.guard.denied", {
+    journeyId: string;
+    stateId?: string;
+    code: string;
+    message?: string;
+    metadata?: Record<string, unknown>;
+}> | RuntimeEventBase<"journey.event.emitted", {
+    name: string;
+    payload: unknown;
+    routing: "none" | "activeJourneyOnly" | "full" | "targeted";
+    target?: {
+        journeyId?: string;
+        stateId?: string;
+    };
+}> | RuntimeEventBase<"journey.state.entered", {
+    journeyId: string;
+    stateId: string;
+}> | RuntimeEventBase<"journey.extraction.proposed", {
+    journeyId: string;
+    stateId: string;
+    fields: string[];
+}> | RuntimeEventBase<"journey.extraction.accepted", {
+    journeyId: string;
+    stateId: string;
+    fields: string[];
+}> | RuntimeEventBase<"action.started", {
+    actionName: string;
+    journeyId?: string;
+    stateId?: string;
+}> | RuntimeEventBase<"action.completed", {
+    actionName: string;
+    success: boolean;
+    journeyId?: string;
+    stateId?: string;
+    error?: string;
+}> | RuntimeEventBase<"tool.started", {
+    toolName: string;
+    journeyId?: string;
+    stateId?: string;
+}> | RuntimeEventBase<"tool.completed", {
+    toolName: string;
+    success: boolean;
+    journeyId?: string;
+    stateId?: string;
+    result?: unknown;
+    error?: string;
+    policyBlock?: {
+        code: string;
+        message: string;
+        blockers: Array<{
+            code: string;
+            message: string;
+            kind?: string;
+        }>;
+    };
+    approval?: {
+        approvalId: string;
+        status: "requested" | "resolved";
+    };
+}> | RuntimeEventBase<"approval.requested", {
+    approvalId: string;
+    toolName: string;
+    input: unknown;
+    channel?: ChannelContext;
+    providerPackageId?: string;
+    operationAlias?: string;
+    providerOperation?: string;
+    capability?: string;
+    actionAudience?: string;
+    sideEffect?: boolean;
+    outbound?: boolean;
+    externallyVisible?: boolean;
+    exposesSensitiveData?: boolean;
+    changesWorkflow?: boolean;
+    reason?: string;
+    supportedResolutions: ApprovalResolutionMode[];
+    editableFields?: string[];
+    expiresAt?: string;
+    journeyId?: string;
+    stateId?: string;
+    metadata?: Record<string, unknown>;
+}> | RuntimeEventBase<"approval.resolved", {
+    approvalId: string;
+    resolution: ApprovalResolutionMode;
+    toolName?: string;
+    resolvedBy?: string;
+    reason?: string;
+    editedInput?: unknown;
+    executed?: boolean;
+    result?: unknown;
+    error?: string;
+    policyBlock?: {
+        code: string;
+        message: string;
+        blockers: Array<{
+            code: string;
+            message: string;
+            kind?: string;
+        }>;
+    };
+    metadata?: Record<string, unknown>;
+}> | RuntimeEventBase<"knowledge.retrieved", {
+    sourceName: string;
+    itemIds: string[];
+}> | RuntimeEventBase<"context.resolved", {
+    keys: string[];
+    channel?: ChannelContext;
+}> | RuntimeEventBase<"policy.evaluated", {
+    channel?: ChannelContext;
+    channelPolicyId?: string;
+    configuredPolicyIds?: string[];
+    enabledCapabilities?: string[];
+    outboundEnabled?: boolean;
+    handoffEnabled?: boolean;
+    responseConstraints?: {
+        maxWords?: number;
+        maxCharacters?: number;
+    };
+    agentChannelPolicyKeys?: string[];
+    hasAgentHandoffPolicy?: boolean;
+}> | RuntimeEventBase<"ui.prompted", {
+    promptId: string;
+    widgetKind: string;
+    input: unknown;
+}> | RuntimeEventBase<"ui.submitted", {
+    promptId: string;
+    widgetKind: string;
+    output: unknown;
+}> | RuntimeEventBase<"conversation.compaction.started", {
+    fromOffset: number;
+    toOffset: number;
+}> | RuntimeEventBase<"conversation.compaction.completed", {
+    fromOffset: number;
+    toOffset: number;
+    schemaVersion: string;
+}> | RuntimeEventBase<"handoff.requested", {
+    reason: string;
+    summary?: string;
+    target?: {
+        providerPackageId?: string;
+        destination?: string;
+        channelId?: string;
+        queue?: string;
+        externalConversationId?: string;
+        policyId?: string;
+    };
+    payload?: unknown;
+}> | RuntimeEventBase<"handoff.completed", {
+    target?: {
+        providerPackageId?: string;
+        destination?: string;
+        channelId?: string;
+        queue?: string;
+        externalConversationId?: string;
+        policyId?: string;
     };
-    toolRetry?: {
-        maxAttempts?: number;
-        notice?: string;
+    channel?: ChannelContext;
+    policyId?: string;
+    status: "accepted" | "adapter-completed";
+    payload?: unknown;
+}> | RuntimeEventBase<"handoff.resumed", {
+    reason?: string;
+    payload?: unknown;
+}> | RuntimeEventBase<"schedule.due", {
+    scheduleId: string;
+    scheduledFor?: string;
+    dueAt: string;
+    eventName: string;
+    payload?: unknown;
+    intent?: {
+        operationAlias?: string;
+        providerPackageId?: string;
+        capability?: string;
+        reason?: string;
     };
+    metadata?: Record<string, unknown>;
+}> | RuntimeEventBase<"conversation.closed", {
+    reason?: string;
+}> | RuntimeEventBase<"error", {
+    code: string;
+    message: string;
+    details?: unknown;
+}> | RuntimeEventBase<"eval.completed", {
+    scenarioId?: string;
+    success: boolean;
+    score?: number;
+    details?: unknown;
+}> | RuntimeEventBase<`custom.${string}`, unknown>;
+type VoiceConnectionStatus = "starting" | "connected" | "ended" | "failed";
+type VoiceSpeaker = "user" | "assistant";
+interface VoiceIceServer {
+    urls: string | string[];
+    username?: string;
+    credential?: string;
 }
-interface CreateRuntimeConversationInput<TConversationContext = unknown> extends CreateConversationInput<TConversationContext> {
+interface VoiceRecordingPolicy {
+    enabled?: boolean;
+    requireConsent?: boolean;
+    mode?: "input" | "both";
+    metadata?: Record<string, unknown>;
 }
-interface HandleUserMessageInput<TTurn = unknown> {
-    conversationId: string;
-    text: string;
-    channel?: ConversationChannel;
-    turn?: TTurn;
-    app?: unknown;
-    signal?: AbortSignal;
-    recordUserMessage?: boolean;
-    assistantMessageMode?: "canonical" | "intermediate" | "none";
-    onAssistantTextDelta?(textDelta: string): Promise<void> | void;
+interface VoiceSelection {
+    provider: string;
+    voice: string;
 }
-interface HandleUserMessageResult {
-    conversation: ConversationRecord;
-    snapshot: RuntimeSnapshot;
-    events: RuntimeEvent[];
-    text: string;
-    activeJourneyId?: string;
+interface VoiceModelSet {
+    provider: string;
+    model: string;
+    voice?: string;
+    settings?: Record<string, unknown>;
 }
-interface HandleVoiceUserMessageInput<TTurn = unknown> extends HandleUserMessageInput<TTurn> {
-    channelSegmentId: string;
-    connectionId?: string;
-    recordingReferenceId?: string;
-    startedAtMs?: number;
-    endedAtMs?: number;
-    transcriptionSource?: string;
+interface VoiceProfile {
+    instructions?: string;
+    modelSet?: VoiceModelSet;
+    recording?: VoiceRecordingPolicy;
     metadata?: Record<string, unknown>;
 }
-interface HandleVoiceUserMessageResult extends HandleUserMessageResult {
-    voiceEvents: RuntimeEvent[];
-}
-interface CompactConversationInput {
+interface VoiceChannelSegment {
+    id: string;
     conversationId: string;
-    fromOffset?: number;
-    toOffset?: number;
-    schemaVersion?: string;
-    signal?: AbortSignal;
+    channel: "voice";
+    startedAt: string;
+    endedAt?: string;
 }
-interface ReplayConversationInput {
-    conversationId: string;
-    afterOffset?: number;
+interface VoiceConnection {
+    id: string;
+    channelSegmentId: string;
+    status: VoiceConnectionStatus;
+    adapter: string;
+    provider?: string;
+    providerSessionId?: string;
+    expiresAt?: string;
 }
-interface ReplayConversationResult {
-    conversation: ConversationRecord;
-    snapshot: RuntimeSnapshot | null;
-    events: RuntimeEvent[];
-    messages: ReplayedMessage[];
-    openPrompts: ReplayedPrompt[];
+interface VoiceSocketMetadata {
+    url: string;
+    token: string;
+    expiresAt: string;
+    protocol: "cognidesk.voice.v1";
 }
-interface SubmitWidgetInput {
-    conversationId: string;
-    promptId: string;
-    widgetKind: string;
-    output: unknown;
+interface VoiceStartClientHints {
+    userAgent?: string;
+    locale?: string;
+    metadata?: Record<string, unknown>;
 }
-interface EmitIntermediateMessageInput {
-    conversationId: string;
-    text: string;
-    visibleToModel?: boolean;
+interface StartVoiceConversationInput<TConversationContext = unknown> {
+    id?: string;
+    agentId: string;
+    context: TConversationContext;
+    client?: VoiceStartClientHints;
+    app?: unknown;
 }
-interface EmitGeneratedPreambleInput {
+interface StartVoiceSegmentInput {
     conversationId: string;
-    purpose?: string;
-    maxWords?: number;
-    signal?: AbortSignal;
+    client?: VoiceStartClientHints;
+    app?: unknown;
 }
-interface EmitGeneratedPreambleResult {
-    text: string;
+interface StartVoiceResult {
+    conversation: ConversationRecord;
+    channelSegment: VoiceChannelSegment;
+    connection: VoiceConnection;
+    socket?: VoiceSocketMetadata;
     events: RuntimeEvent[];
 }
-interface EmitCustomEventInput<TEvent extends CustomRuntimeEventDefinition = CustomRuntimeEventDefinition> {
+interface CommitVoiceTranscriptInput {
     conversationId: string;
-    event: TEvent;
-    payload: z.infer<TEvent["payload"]>;
+    channelSegmentId: string;
+    speaker: VoiceSpeaker;
+    text: string;
+    recordingReferenceId?: string;
+    startedAtMs?: number;
+    endedAtMs?: number;
+    transcriptionSource?: string;
+    metadata?: Record<string, unknown>;
 }
-interface EmitJourneyEventInput<TEvent extends JourneyEventDefinition = JourneyEventDefinition> {
-    conversationId: string;
-    event: TEvent;
-    payload: z.infer<TEvent["payload"]>;
-    routing?: EventRoutingMode;
-    target?: {
-        journeyId?: string;
-        stateId?: string;
-    };
-    app?: unknown;
-    signal?: AbortSignal;
+interface CommitVoiceTranscriptReferenceInput extends CommitVoiceTranscriptInput {
+    messageEventId: string;
 }
-interface EmitJourneyEventResult {
+interface CommitVoiceTranscriptResult {
+    message: RuntimeEvent;
     event: RuntimeEvent;
-    snapshot: RuntimeSnapshot | null;
     events: RuntimeEvent[];
 }
-interface RequestHandoffInput {
+interface RecordVoiceInterruptionInput {
     conversationId: string;
-    reason: string;
-    summary?: string;
-    payload?: unknown;
+    channelSegmentId: string;
+    connectionId?: string;
+    interruptedMessageId?: string;
+    source?: "userSpeech" | "adapter" | "provider";
+    reason?: string;
+    recordingReferenceId?: string;
+    offsetMs?: number;
 }
-interface ResumeConversationInput {
+type VoiceRuntimeEventInput = Extract<RuntimeEventInput, {
+    type: `voice.${string}`;
+}>;
+interface RuntimeSnapshot {
     conversationId: string;
+    lifecycle: ConversationLifecycle;
+    activeJourneyId?: string;
+    activeStateIds: string[];
+    journeyContext?: unknown;
+    journeyContexts?: JourneyContextRecord[];
+    journeySummaries?: JourneySummary[];
+    compactionSummary?: unknown;
+    definitionHash?: string;
+    updatedAt: string;
+}
+interface JourneySummary {
+    journeyId: string;
+    kind: "stateMachine" | "delegation";
+    summary: string;
+    completedAt: string;
+    stateId?: string;
     reason?: string;
-    payload?: unknown;
 }
-interface CompactConversationResult<TSummary = ConversationCompactionSummary> {
-    summary: TSummary;
-    snapshot: RuntimeSnapshot;
-    events: RuntimeEvent[];
+interface JourneyContextRecord {
+    journeyId: string;
+    context: unknown;
+    updatedAt: string;
+    stateId?: string;
+}
+declare class DefinitionError extends Error {
+    constructor(message: string);
 }
 declare class CognideskRuntime {
     private readonly activeTurns;
     private readonly kernel;
     private readonly options;
+    readonly debug: {
+        explainTurn: <TTurn = unknown>(input: ExplainTurnInput<TTurn>) => Promise<ExplainTurnResult>;
+    };
     constructor(options: RuntimeOptions);
+    configurationSource(): RuntimeConfigurationSource;
     initialize(): Promise<void>;
     createConversation<TConversationContext = unknown>(input: CreateRuntimeConversationInput<TConversationContext>): Promise<ConversationRecord<TConversationContext>>;
     emit<TEvent extends RuntimeEventInput>(event: TEvent): Promise<RuntimeEvent>;
@@ -1487,10 +3850,18 @@ declare class CognideskRuntime {
     emitGeneratedPreamble(input: EmitGeneratedPreambleInput): Promise<EmitGeneratedPreambleResult>;
     emitCustomEvent<TEvent extends CustomRuntimeEventDefinition>(input: EmitCustomEventInput<TEvent>): Promise<RuntimeEvent>;
     emitJourneyEvent<TEvent extends JourneyEventDefinition>(input: EmitJourneyEventInput<TEvent>): Promise<EmitJourneyEventResult>;
+    emitScheduledEvent<TEvent extends JourneyEventDefinition>(input: EmitScheduledEventInput<TEvent>): Promise<EmitScheduledEventResult>;
     listEvents(conversationId: string, afterOffset?: number): Promise<RuntimeEvent[]>;
+    listPendingSupportActions(input: ListPendingSupportActionsInput | string): Promise<PendingSupportAction[]>;
+    resolvePendingSupportAction(input: ResolvePendingSupportActionInput): Promise<ResolvePendingSupportActionResult>;
     replayConversation(input: ReplayConversationInput): Promise<ReplayConversationResult>;
     submitWidget(input: SubmitWidgetInput): Promise<RuntimeEvent>;
     getSnapshot(conversationId: string): Promise<RuntimeSnapshot | null>;
+    handleChannelEvent<TPayload = unknown, TTurn = unknown>(input: HandleChannelEventInput<TPayload, TTurn>): Promise<HandleChannelEventResult<TPayload>>;
+    requestOutboundContact<TPayload = unknown>(input: RequestOutboundContactInput<TPayload>): Promise<HandleChannelEventResult<TPayload>>;
+    requestChannelHandoff<TPayload = unknown>(input: RequestChannelHandoffInput<TPayload>): Promise<HandleChannelEventResult<TPayload>>;
+    requestChannelHandoffReview<TPayload = unknown>(input: RequestChannelHandoffReviewInput<TPayload>): Promise<HandleChannelEventResult<TPayload>>;
+    resolveChannelOutput<TPayload = unknown>(input: ResolveChannelOutputInput<TPayload>): Promise<ResolveChannelOutputResult<TPayload>>;
     handleUserMessage<TTurn = unknown>(input: HandleUserMessageInput<TTurn>): Promise<HandleUserMessageResult>;
     handleVoiceUserMessage<TTurn = unknown>(input: HandleVoiceUserMessageInput<TTurn>): Promise<HandleVoiceUserMessageResult>;
     startVoiceConversation<TConversationContext = unknown>(input: StartVoiceConversationInput<TConversationContext>): Promise<StartVoiceResult>;
@@ -1513,7 +3884,10 @@ declare class CognideskRuntime {
         event: RuntimeEvent;
     }>;
     compactConversation<TSummary = ConversationCompactionSummary>(input: CompactConversationInput): Promise<CompactConversationResult<TSummary>>;
+    private explainTurn;
     private runtimeOperation;
+    private channelFacadeContext;
+    private bindChannelEvent;
 }
 declare function createRuntime(options: RuntimeOptions): CognideskRuntime;
@@ -1568,10 +3942,10 @@ declare const formWidget: WidgetDefinition<"form", z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
         type: z.ZodEnum<{
             number: "number";
+            email: "email";
             date: "date";
             text: "text";
             choice: "choice";
-            email: "email";
         }>;
         required: z.ZodDefault<z.ZodBoolean>;
         placeholder: z.ZodOptional<z.ZodString>;
@@ -1645,10 +4019,10 @@ declare const builtInWidgets: {
             description: z.ZodOptional<z.ZodString>;
             type: z.ZodEnum<{
                 number: "number";
+                email: "email";
                 date: "date";
                 text: "text";
                 choice: "choice";
-                email: "email";
             }>;
             required: z.ZodDefault<z.ZodBoolean>;
             placeholder: z.ZodOptional<z.ZodString>;
@@ -1685,4 +4059,70 @@ declare const builtInTools: {
     }, z.core.$strip>, false>;
 };
-export { type ActionDefinition, type ActivationMetadata, type AgentBehaviorOptions, AgentBuilder, type AgentLogLevel, type AgentModelAdapters, type AgentModelSet, type AgentOptions, type AgentPostProcessingOptions, type AnyCustomRuntimeEvent, type AnyTool, type ApplicationContextParts, type BuildJourneyIndexOptions, type CandidateFilterPredicate, CapabilityScope, CognideskRuntime, type CommitVoiceTranscriptInput, type CommitVoiceTranscriptReferenceInput, type CommitVoiceTranscriptResult, type CompactConversationInput, type CompactConversationResult, type CompiledActionRun, type CompiledAgent, type CompiledContextReusePolicy, type CompiledDelegation, type CompiledJourney, type CompiledJourneyEntry, type CompiledState, type CompiledToolRun, type CompiledTransition, type ConfirmationPolicy, type ContextPath, type ContextReusePolicy, type ContextReusePredicate, type ConversationChannel, type ConversationCompactionSummary, type ConversationLifecycle, type ConversationRecord, type CreateConversationInput, type CreateRuntimeConversationInput, type CustomRuntimeEventDefinition, DefinitionError, DelegationJourneyBuilder, type DelegationJourneyOptions, type EmbeddingInput, type EmbeddingOutput, type EmitCustomEventInput, type EmitGeneratedPreambleInput, type EmitGeneratedPreambleResult, type EmitIntermediateMessageInput, type EmitJourneyEventInput, type EmitJourneyEventResult, type EventRoutingMode, type FieldCollectionOptions, type GuardContext, type GuardResult, type HandleUserMessageInput, type HandleUserMessageResult, type HandleVoiceUserMessageInput, type HandleVoiceUserMessageResult, type InferSchema, JOURNEY_INDEX_PROJECTION_VERSION, type JourneyActivationPredicate, type JourneyCandidate, type JourneyContextRecord, type JourneyEntryOptions, type JourneyEntryPredicate, type JourneyEventDefinition, type JourneyFragment, type JourneyFragmentOptions, type JourneyGraph, type JourneyGraphState, type JourneyGuardPredicate, type JourneyIndex, type JourneyIndexEmbedding, type JourneyIndexEntry, type JourneyIndexValidationResult, type JourneySummary, type KnowledgeItem, type KnowledgeSource, type ListCollectionOptions, type ListEventsOptions, type MessageSegment, type ModelAdapter, type ModelMessage, type ModelPromptProfile, type ModelPromptProfileRender, type ModelPromptProfileRenderInput, type ModelRole, type ModelToolCall, type ModelToolDefinition, type ModelVisiblePromptPayload, type ObjectSchema, type PrivacyHookContext, type PrivacyHooks, type PromptProfileRole, type PromptTask, type RecordVoiceInterruptionInput, type ReplayConversationInput, type ReplayConversationResult, type ReplayedMessage, type ReplayedPrompt, type RequestHandoffInput, type ResumeConversationInput, type RuntimeEvent, type RuntimeEventBase, type RuntimeEventInput, type RuntimeEventTelemetry, type RuntimeLogContext, type RuntimeOptions, type RuntimeSnapshot, type RuntimeTelemetryOptions, type SdkLogLevel, type SdkLogger, type SelectJourneyCandidatesOptions, type SideEffectTool, type StartVoiceConversationInput, type StartVoiceResult, type StartVoiceSegmentInput, type StateActionUseOptions, StateBuilder, StateCollection, StateMachineJourneyBuilder, type StateMachineJourneyOptions, type StateReference, type StorageAdapter, type StructuredOutputPromptMetadata, type SubmitWidgetInput, type SupportReference, type TelemetryContentMode, type TelemetryContext, type TelemetryContextSpanOptions, type TelemetrySpanOptions, type TelemetrySpanRunner, type TextGenerationInput, type TextGenerationOutput, type ToolDefinition, type ToolExecutionContext, type ToolRunOptions, type ToolRunOptionsFor, type TransitionOptions, TypedStateRegistry, type UsageRecord, type ValidateJourneyIndexOptions, type VoiceChannelSegment, type VoiceConnection, type VoiceConnectionStatus, type VoiceIceServer, type VoiceModelSet, type VoiceProfile, type VoiceProfileOptions, type VoiceRecordingPolicy, type VoiceRuntimeEventInput, type VoiceSelection, type VoiceSocketMetadata, type VoiceSpeaker, type VoiceStartClientHints, type WidgetDefinition, type WidgetPromptDefinition, action, activeRuntimeEventTelemetry, addTelemetryContentEvent, buildJourneyIndex, builtInTools, builtInWidgets, choiceWidget, confirmationWidget, conversationCompactionSummarySchema, createAgent, createJourneyRoutingText, createRuntime, createRuntimeLogger, createTelemetryContext, customRuntimeEvent, datePickerWidget, endConversationTool, formWidget, handoffTool, hashAgentRoutingDefinition, hashJourneyDefinition, journeyContextViewerTool, journeyEvent, journeyFragment, journeyIndexEmbeddingSchema, journeyIndexEntrySchema, journeyIndexSchema, knowledgeSource, recordRuntimeEventMetric, runtimeLogger, selectJourneyCandidates, telemetryAttributes, telemetryContentMode, telemetryEnabled, telemetryEventNames, telemetrySpanNames, textInputWidget, tool, validateJourneyIndex, widget, widgetPrompt, withTelemetrySpan };
+type ScheduleTrigger = {
+    kind: "at";
+    at: string | Date;
+} | {
+    kind: "after";
+    milliseconds: number;
+} | {
+    kind: "cron";
+    expression: string;
+    timezone?: string;
+};
+interface ScheduledOperationIntent {
+    operationAlias?: string;
+    providerPackageId?: string;
+    capability?: string;
+    reason?: string;
+}
+interface ScheduleDefinition<TId extends string = string, TEvent extends JourneyEventDefinition = JourneyEventDefinition> {
+    kind: "schedule";
+    id: TId;
+    trigger: ScheduleTrigger;
+    event: TEvent;
+    payload?: z.infer<TEvent["payload"]> | ((input: {
+        now: Date;
+    }) => z.infer<TEvent["payload"]>);
+    intent?: ScheduledOperationIntent;
+    metadata?: Record<string, unknown>;
+}
+interface ScheduledSupportAction {
+    id: string;
+    scheduleId: string;
+    conversationId: string;
+    dueAt: string;
+    eventName: string;
+    payload: unknown;
+    intent?: ScheduledOperationIntent;
+    metadata?: Record<string, unknown>;
+    status: "scheduled" | "cancelled" | "delivered";
+}
+interface ScheduleAdapter {
+    schedule(input: Omit<ScheduledSupportAction, "id" | "status"> & {
+        id?: string;
+    }): Promise<ScheduledSupportAction>;
+    cancel(id: string): Promise<boolean>;
+    list?(conversationId?: string): Promise<ScheduledSupportAction[]>;
+}
+interface InMemoryScheduleAdapterOptions {
+    now?: () => Date;
+    createId?: () => string;
+    onDue?(action: ScheduledSupportAction): Promise<void> | void;
+}
+declare function defineSchedule<const TId extends string, TEvent extends JourneyEventDefinition>(id: TId, options: Omit<ScheduleDefinition<TId, TEvent>, "kind" | "id">): ScheduleDefinition<TId, TEvent>;
+declare function at(atDate: string | Date): ScheduleTrigger;
+declare function after(input: {
+    milliseconds?: number;
+    seconds?: number;
+    minutes?: number;
+    hours?: number;
+    days?: number;
+}): ScheduleTrigger;
+declare function cron(expression: string, options?: {
+    timezone?: string;
+}): ScheduleTrigger;
+declare function resolveScheduleDueAt(trigger: ScheduleTrigger, now?: Date): Date;
+declare function createInMemoryScheduleAdapter(options?: InMemoryScheduleAdapterOptions): ScheduleAdapter;
+export { type ActionAudience, ActionAudienceSchema, type ActionDefinition, type ActivationMetadata, type AgentBehaviorOptions, AgentBuilder, type AgentChannelPolicyMap, type AgentChannelPolicyOptions, type AgentConfigurationOptions, type AgentHandoffPolicyOptions, type AgentLogLevel, type AgentModelAdapters, type AgentModelSet, type AgentOptions, type AgentPersonaOptions, type AgentPolicyValue, type AgentPostProcessingOptions, type AnyCustomRuntimeEvent, type AnyTool, type ApplicationContextParts, type ApprovalRequirement, type ApprovalResolutionMode, type BuildJourneyIndexOptions, type CandidateFilterPredicate, type CapabilityAvailability, type CapabilityAvailabilityInput, CapabilityAvailabilitySchema, type CapabilityAvailabilityStatus, CapabilityAvailabilityStatusSchema, CapabilityScope, type CapabilityUseDecision, type CapabilityUseRequest, type CapabilityUseRequestInput, CapabilityUseRequestSchema, type CategoryDataSourceDeclaration, type CategoryDataSourceDeclarationInput, CategoryDataSourceDeclarationSchema, type CategoryEventDeclaration, type CategoryEventDeclarationInput, CategoryEventDeclarationSchema, type CategoryEventDirection, CategoryEventDirectionSchema, type CategoryOperationCatalog, type CategoryOperationCatalogEntry, type CategoryOperationCatalogEntryInput, CategoryOperationCatalogEntrySchema, type CategoryOperationCatalogInput, CategoryOperationCatalogSchema, type CategoryOperationDeclaration, type CategoryOperationDeclarationInput, CategoryOperationDeclarationSchema, type CategoryOperationLevel, CategoryOperationLevelSchema, type CategoryOutputDeclaration, type CategoryOutputDeclarationInput, CategoryOutputDeclarationSchema, type ChannelAdapterVerificationResult, type ChannelAudience, ChannelAudienceSchema, type ChannelBehaviorPolicy, type ChannelBehaviorPolicyInput, ChannelBehaviorPolicySchema, type ChannelCapability, type ChannelCapabilityDeclaration, ChannelCapabilityDeclarationSchema, type ChannelCapabilityFlags, type ChannelCapabilityFlagsInput, ChannelCapabilityFlagsSchema, ChannelCapabilitySchema, type ChannelContext, type ChannelContextInput, ChannelContextSchema, type ChannelEvent, type ChannelEventActor, ChannelEventActorSchema, type ChannelEventActorType, ChannelEventActorTypeSchema, type ChannelEventBindingInput, type ChannelEventBindingOutcome, ChannelEventBindingOutcomeSchema, type ChannelEventBindingResult, type ChannelEventBindingStatus, ChannelEventBindingStatusSchema, type ChannelEventDirection, ChannelEventDirectionSchema, type ChannelEventEnvelope, type ChannelEventEnvelopeInput, ChannelEventEnvelopeInputSchema, type ChannelEventHandlingDisposition, type ChannelEventHandlingDispositionKind, ChannelEventHandlingDispositionKindSchema, type ChannelEventHandlingInput, type ChannelEventIdentity, ChannelEventIdentitySchema, type ChannelEventIntakeResult, type ChannelEventIntakeStatus, ChannelEventIntakeStatusSchema, type ChannelEventIntent, ChannelEventIntentSchema, type ChannelEventKind, type ChannelEventNature, ChannelEventNatureSchema, type ChannelEventRuntimeReceiver, type ChannelEventSource, type ChannelEventSourceBindInput, type ChannelEventSourceBinding, type ChannelEventSourceEvidence, ChannelEventSourceEvidenceSchema, type ChannelEventSourceHandleInput, type ChannelEventSourceNormalizeInput, type ChannelEventSourceType, ChannelEventSourceTypeSchema, type ChannelFlowActivation, type ChannelFlowActivationInput, ChannelFlowActivationSchema, type ChannelHandoffPolicy, type ChannelHandoffPolicyInput, ChannelHandoffPolicySchema, type ChannelOutboundPolicy, type ChannelOutboundPolicyInput, ChannelOutboundPolicySchema, type ChannelOutputDeliveryMode, ChannelOutputDeliveryModeSchema, type ChannelOutputIntent, type ChannelOutputIntentInput, ChannelOutputIntentInputSchema, type ChannelOutputIntentKind, ChannelOutputIntentKindSchema, type ChannelOutputIntentProducer, ChannelOutputIntentProducerSchema, type ChannelOutputPolicyReason, ChannelOutputPolicyReasonSchema, type ChannelOutputProducerType, ChannelOutputProducerTypeSchema, type ChannelOutputResolution, type ChannelOutputResolutionDecision, ChannelOutputResolutionDecisionInputSchema, type ChannelOutputResolutionOutcome, ChannelOutputResolutionOutcomeSchema, type ChannelOutputResolutionPayload, type ChannelOutputResolutionPolicyInput, type ChannelOutputResolutionStatus, ChannelOutputResolutionStatusSchema, type ChannelOutputResolverInput, type ChannelOutputResolverResult, type ChannelPolicyConfig, type ChannelPolicyConfigInput, ChannelPolicyConfigSchema, type ChannelProviderAdapter, type ChannelSetConfig, type ChannelSetConfigInput, ChannelSetConfigSchema, type ChannelSourceEvidence, CognideskRuntime, type CommitVoiceTranscriptInput, type CommitVoiceTranscriptReferenceInput, type CommitVoiceTranscriptResult, type CompactConversationInput, type CompactConversationResult, type CompiledActionRun, type CompiledAgent, type CompiledContextReusePolicy, type CompiledDelegation, type CompiledJourney, type CompiledJourneyEntry, type CompiledState, type CompiledToolRun, type CompiledTransition, type ConfirmationPolicy, type ContextPath, type ContextReusePolicy, type ContextReusePredicate, type ConversationChannel, type ConversationChannelInput, type ConversationChannelKind, ConversationChannelKindSchema, type ConversationCompactionSummary, type ConversationLifecycle, type ConversationRecord, type CoreChannelCapability, CoreChannelCapabilitySchema, type CoreChannelEventActor, type CoreChannelEventDirection, type CoreChannelEventIntent, type CoreChannelEventKind, type CoreChannelEventNature, type CoreChannelOutputIntentKind, type CoreConversationChannel, type CoreProviderCategory, type CreateConversationInput, type CreateRuntimeConversationInput, type CustomRuntimeEventDefinition, DefinitionError, DelegationJourneyBuilder, type DelegationJourneyOptions, type EmailAttachmentMetadata, type EmailAttachmentMetadataInput, type EmailQuoteTrimOptions, type EmailQuoteTrimResult, type EmailThreadContext, type EmailThreadContextMessage, type EmailThreadContextOptions, type EmailThreadMessageInput, type EmbeddingInput, type EmbeddingOutput, type EmitCustomEventInput, type EmitGeneratedPreambleInput, type EmitGeneratedPreambleResult, type EmitIntermediateMessageInput, type EmitJourneyEventInput, type EmitJourneyEventResult, type EmitScheduledEventInput, type EmitScheduledEventResult, type EventRoutingMode, type ExplainTurnInput, type ExplainTurnResult, type FieldCollectionOptions, type GuardContext, type GuardResult, type HandleChannelEventInput, type HandleChannelEventResult, type HandleUserMessageInput, type HandleUserMessageResult, type HandleVoiceUserMessageInput, type HandleVoiceUserMessageResult, type InMemoryScheduleAdapterOptions, type InferSchema, type IntegrationCategoryProfile, type IntegrationCategoryProfileInput, IntegrationCategoryProfileSchema, JOURNEY_INDEX_PROJECTION_VERSION, type JourneyActivationPredicate, type JourneyCandidate, type JourneyContextRecord, type JourneyEntryOptions, type JourneyEntryPredicate, type JourneyEventDefinition, type JourneyFragment, type JourneyFragmentOptions, type JourneyGraph, type JourneyGraphState, type JourneyGuardPredicate, type JourneyIndex, type JourneyIndexEmbedding, type JourneyIndexEntry, type JourneyIndexValidationResult, type JourneySummary, type KnowledgeItem, type KnowledgeSource, type ListCollectionOptions, type ListEventsOptions, type ListPendingSupportActionsInput, type MessageSegment, type ModelAdapter, type ModelMessage, type ModelPromptProfile, type ModelPromptProfileRender, type ModelPromptProfileRenderInput, type ModelRole, type ModelToolCall, type ModelToolDefinition, type ModelVisiblePromptPayload, type NormalizedChannelPayload, type NormalizedChannelPayloadInput, NormalizedChannelPayloadSchema, type ObjectSchema, type PendingSupportAction, type PrivacyHookContext, type PrivacyHooks, type PromptProfileRole, type PromptTask, type ProviderCapabilityCoverage, type ProviderCapabilityCoverageReport, ProviderCapabilityCoverageReportSchema, ProviderCapabilityCoverageSchema, type ProviderCategory, ProviderCategorySchema, type ProviderCoverage, type ProviderCoverageInput, ProviderCoverageSchema, type ProviderCoverageScope, ProviderCoverageScopeSchema, type ProviderCredentialRequirement, ProviderCredentialRequirementSchema, type ProviderCredentialState, ProviderCredentialStateSchema, type ProviderCredentialStatus, type ProviderCredentialStatusInput, ProviderCredentialStatusSchema, type ProviderDirection, ProviderDirectionSchema, type ProviderManifest, type ProviderManifestInput, ProviderManifestSchema, type ProviderObjectDescriptor, ProviderObjectDescriptorSchema, type ProviderOperationCoverageMismatch, ProviderOperationCoverageMismatchSchema, type ProviderOperationDeclaration, type ProviderOperationDeclarationInput, ProviderOperationDeclarationSchema, type ProviderReadiness, type ProviderReadinessInput, ProviderReadinessSchema, type ProviderRegistry, type ProviderRegistryQuery, type ProviderRegistryQueryInput, ProviderRegistryQuerySchema, type ProviderTrustLevel, ProviderTrustLevelSchema, type RecordVoiceInterruptionInput, type ReplayConversationInput, type ReplayConversationResult, type ReplayedMessage, type ReplayedPrompt, type RequestChannelHandoffInput, type RequestChannelHandoffReviewInput, type RequestHandoffInput, type RequestOutboundContactInput, type ResolveChannelOutputInput, type ResolveChannelOutputResult, type ResolvePendingSupportActionInput, type ResolvePendingSupportActionResult, type ResumeConversationInput, type RuntimeApprovalDecision, type RuntimeApprovalEvaluationInput, type RuntimeApprovalOutcome, type RuntimeConfigurationSource, type RuntimeContextOptions, type RuntimeContextResolveInput, type RuntimeEvent, type RuntimeEventBase, type RuntimeEventInput, type RuntimeEventTelemetry, type RuntimeLogContext, type RuntimeOptions, type RuntimeSnapshot, type RuntimeTelemetryOptions, type ScheduleAdapter, type ScheduleDefinition, type ScheduleTrigger, type ScheduledOperationIntent, type ScheduledSupportAction, type SdkLogLevel, type SdkLogger, type SelectJourneyCandidatesOptions, type SideEffectTool, type StartVoiceConversationInput, type StartVoiceResult, type StartVoiceSegmentInput, type StateActionUseOptions, StateBuilder, StateCollection, StateMachineJourneyBuilder, type StateMachineJourneyOptions, type StateReference, type StorageAdapter, type StructuredOutputPromptMetadata, type SubmitWidgetInput, type SupportReference, type TelemetryContentMode, type TelemetryContext, type TelemetryContextSpanOptions, type TelemetrySpanOptions, type TelemetrySpanRunner, type TextGenerationInput, type TextGenerationOutput, type ToolApprovalOptions, type ToolDefinition, type ToolExecutionContext, type ToolPolicyOptions, type ToolRunOptions, type ToolRunOptionsFor, type TransitionOptions, TypedStateRegistry, type UsageRecord, type ValidateJourneyIndexOptions, type VoiceChannelSegment, type VoiceConnection, type VoiceConnectionStatus, type VoiceIceServer, type VoiceModelSet, type VoiceProfile, type VoiceProfileOptions, type VoiceRecordingPolicy, type VoiceRuntimeEventInput, type VoiceSelection, type VoiceSocketMetadata, type VoiceSpeaker, type VoiceStartClientHints, type WidgetDefinition, type WidgetPromptDefinition, action, activeRuntimeEventTelemetry, addTelemetryContentEvent, after, at, buildJourneyIndex, builtInTools, builtInWidgets, capabilityAvailabilityStatuses, categoryEventDirections, categoryOperationLevels, channelAudiences, channelEventActorTypes, channelEventBindingOutcomes, channelEventBindingStatuses, channelEventDedupeKey, channelEventDirections, channelEventHandlingDispositionKinds, channelEventIntakeStatuses, channelEventSourceTypes, channelKindOf, channelOutputDeliveryModes, channelOutputProducerTypes, channelOutputResolutionOutcomes, channelOutputResolutionStatuses, checkProviderCapabilityCoverage, choiceWidget, collectEmailAttachmentMetadata, confirmationWidget, conversationCompactionSummarySchema, coreChannelCapabilities, coreChannelEventActors, coreChannelEventDirections, coreChannelEventIntents, coreChannelEventKinds, coreChannelEventNatures, coreChannelOutputIntentKinds, coreConversationChannels, coreProviderCategories, createAgent, createChannelEventInputFromSource, createEmailThreadContext, createInMemoryScheduleAdapter, createJourneyRoutingText, createMessageChannelEvent, createProviderRegistry, createRuntime, createRuntimeLogger, createScheduledChannelEvent, createTelemetryContext, cron, customRuntimeEvent, datePickerWidget, defaultChannelCapabilityFlags, defineCapabilityAvailability, defineChannelContext, defineChannelEvent, defineChannelEventSource, defineChannelOutputIntent, defineChannelOutputResolutionDecision, defineChannelPolicy, defineChannelProviderAdapter, defineIntegrationCategoryProfile, defineProviderPackage, defineSchedule, deriveProviderCapabilityCoverage, endConversationTool, evaluateCapabilityUse, formWidget, handleChannelEventFromSource, handoffTool, hashAgentRoutingDefinition, hashJourneyDefinition, isCoreChannelCapability, journeyContextViewerTool, journeyEvent, journeyFragment, journeyIndexEmbeddingSchema, journeyIndexEntrySchema, journeyIndexSchema, knowledgeSource, normalizeEmailAttachmentMetadata, providerCapabilityCoverageLevels, providerCredentialStatuses, providerDirections, providerTrustLevels, recordRuntimeEventMetric, resolveScheduleDueAt, runtimeLogger, selectJourneyCandidates, telemetryAttributes, telemetryContentMode, telemetryEnabled, telemetryEventNames, telemetrySpanNames, textInputWidget, tool, trimEmailQuote, validateJourneyIndex, widget, widgetPrompt, withTelemetrySpan };