@cognidesk/core 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,1688 @@
+import * as zod from 'zod';
+import { z } from 'zod';
+import { Attributes, Span } from '@opentelemetry/api';
+import pino, { Logger } from 'pino';
+import * as zod_v4_core from 'zod/v4/core';
+
+interface UsageRecord {
+    inputTokens?: number;
+    outputTokens?: number;
+    cachedInputTokens?: number;
+    reasoningTokens?: number;
+    totalTokens?: number;
+    providerMetadata?: Record<string, unknown>;
+}
+interface ModelMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+    name?: string;
+    toolCallId?: string;
+    toolCalls?: ModelToolCall[];
+}
+interface ModelToolDefinition {
+    name: string;
+    description?: string;
+    input: z.ZodType;
+}
+interface ModelToolCall {
+    id: string;
+    name: string;
+    input: unknown;
+    providerMetadata?: Record<string, unknown>;
+}
+interface TextGenerationInput {
+    role: ModelRole;
+    promptTask?: PromptTask;
+    promptPayload?: ModelVisiblePromptPayload;
+    messages: ModelMessage[];
+    responseFormat?: z.ZodType;
+    tools?: ModelToolDefinition[];
+    toolChoice?: "auto" | "none" | "required";
+    onTextDelta?(delta: string): void | Promise<void>;
+    signal?: AbortSignal;
+}
+interface TextGenerationOutput<T = unknown> {
+    text: string;
+    structured?: T;
+    toolCalls?: ModelToolCall[];
+    usage?: UsageRecord;
+    providerMetadata?: Record<string, unknown>;
+}
+interface EmbeddingInput {
+    role: "journeyEmbedding";
+    text: string;
+    signal?: AbortSignal;
+}
+interface EmbeddingOutput {
+    embedding: number[];
+    model: string;
+    dimensions: number;
+    usage?: UsageRecord;
+    providerMetadata?: Record<string, unknown>;
+}
+type ModelRole = "response" | "matcher" | "extraction" | "citationPostProcessing" | "journeyEmbedding" | "compaction";
+type PromptProfileRole = Exclude<ModelRole, "journeyEmbedding">;
+type PromptTask = "response" | "journey-matcher" | "transition-matcher" | "delegation-completion" | "extraction" | "citation-post-processing" | "compaction" | "generated-preamble";
+type ModelVisiblePromptPayload = Record<string, unknown>;
+interface StructuredOutputPromptMetadata {
+    required: boolean;
+    name: string;
+    schema?: unknown;
+}
+interface ModelPromptProfileRenderInput {
+    role: PromptProfileRole;
+    promptTask: PromptTask;
+    model: {
+        provider: string;
+        model: string;
+        logicalModelSlug?: string;
+    };
+    payload: ModelVisiblePromptPayload;
+    structuredOutput?: StructuredOutputPromptMetadata;
+}
+type ModelPromptProfileRender = (input: ModelPromptProfileRenderInput) => string | Promise<string>;
+interface ModelPromptProfile {
+    readonly id: string;
+    readonly description?: string;
+    readonly logicalModelSlug?: string;
+    renderInstruction(input: ModelPromptProfileRenderInput): string | Promise<string>;
+}
+interface ModelAdapter {
+    readonly provider: string;
+    readonly model: string;
+    readonly promptProfile?: ModelPromptProfile;
+    generateText(input: TextGenerationInput): Promise<TextGenerationOutput>;
+    embed?(input: EmbeddingInput): Promise<EmbeddingOutput>;
+}
+type AgentModelAdapters = {
+    [Role in ModelRole]: ModelAdapter;
+};
+type AgentModelSet = AgentModelAdapters;
+
+type MaybePromise$2<T> = Promise<T> | T;
+type TelemetryContentMode = "redacted" | "full";
+interface RuntimeTelemetryOptions {
+    enabled?: boolean;
+    content?: TelemetryContentMode;
+}
+interface RuntimeEventTelemetry {
+    traceId: string;
+    spanId?: string;
+}
+interface TelemetryContextSpanOptions {
+    attributes?: Attributes;
+}
+type TelemetrySpanRunner<T> = (span: Span) => MaybePromise$2<T>;
+interface TelemetryContext {
+    startSpan(name: string, options?: TelemetryContextSpanOptions): Span;
+    withSpan<T>(name: string, run: TelemetrySpanRunner<T>): Promise<T>;
+    withSpan<T>(name: string, options: TelemetryContextSpanOptions, run: TelemetrySpanRunner<T>): Promise<T>;
+    setAttribute(name: string, value: string | number | boolean): void;
+    addEvent(name: string, attributes?: Attributes): void;
+    recordException(error: unknown): void;
+}
+declare const telemetrySpanNames: {
+    readonly runtimeInitialize: "cognidesk.runtime.initialize";
+    readonly runtimeCreateConversation: "cognidesk.runtime.create_conversation";
+    readonly runtimeEmitEvent: "cognidesk.runtime.emit_event";
+    readonly runtimeEmitIntermediateMessage: "cognidesk.runtime.emit_intermediate_message";
+    readonly runtimeEmitGeneratedPreamble: "cognidesk.runtime.emit_generated_preamble";
+    readonly runtimeEmitCustomEvent: "cognidesk.runtime.emit_custom_event";
+    readonly runtimeEmitJourneyEvent: "cognidesk.runtime.emit_journey_event";
+    readonly runtimeListEvents: "cognidesk.runtime.list_events";
+    readonly runtimeReplayConversation: "cognidesk.runtime.replay_conversation";
+    readonly runtimeSubmitWidget: "cognidesk.runtime.submit_widget";
+    readonly runtimeGetSnapshot: "cognidesk.runtime.get_snapshot";
+    readonly runtimeHandleUserMessage: "cognidesk.runtime.handle_user_message";
+    readonly runtimeCloseConversation: "cognidesk.runtime.close_conversation";
+    readonly runtimeRequestHandoff: "cognidesk.runtime.request_handoff";
+    readonly runtimeResumeConversation: "cognidesk.runtime.resume_conversation";
+    readonly runtimeCompactConversation: "cognidesk.runtime.compact_conversation";
+    readonly journeySelect: "cognidesk.journey.select";
+    readonly modelGenerate: "cognidesk.model.generate";
+    readonly toolExecute: "cognidesk.tool.execute";
+    readonly actionExecute: "cognidesk.action.execute";
+    readonly knowledgeRetrieve: "cognidesk.knowledge.retrieve";
+};
+declare const telemetryAttributes: {
+    readonly agentId: "cognidesk.agent.id";
+    readonly conversationId: "cognidesk.conversation.id";
+    readonly journeyId: "cognidesk.journey.id";
+    readonly stateId: "cognidesk.state.id";
+    readonly operation: "cognidesk.operation";
+    readonly modelRole: "cognidesk.model.role";
+    readonly modelProvider: "cognidesk.model.provider";
+    readonly modelName: "cognidesk.model.name";
+    readonly promptTask: "cognidesk.prompt.task";
+    readonly toolName: "cognidesk.tool.name";
+    readonly actionName: "cognidesk.action.name";
+    readonly knowledgeSourceName: "cognidesk.knowledge.source.name";
+    readonly success: "cognidesk.success";
+    readonly errorType: "cognidesk.error.type";
+};
+declare const telemetryEventNames: {
+    readonly runtimeEvent: "cognidesk.runtime.event";
+    readonly userMessage: "cognidesk.user.message";
+    readonly modelInput: "cognidesk.model.input";
+    readonly modelOutput: "cognidesk.model.output";
+    readonly toolInput: "cognidesk.tool.input";
+    readonly toolOutput: "cognidesk.tool.output";
+    readonly knowledgeItems: "cognidesk.knowledge.items";
+};
+type TelemetryOptionsCarrier = {
+    telemetry?: RuntimeTelemetryOptions;
+};
+type MetricKind = "runtime" | "model" | "tool" | "action" | "knowledge";
+type TelemetryMetricOptions = {
+    kind: MetricKind;
+    attributes?: Attributes;
+    tokenUsage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
+    };
+};
+interface TelemetrySpanOptions {
+    name: string;
+    attributes?: Attributes;
+    metric?: TelemetryMetricOptions;
+}
+declare function telemetryEnabled(options: TelemetryOptionsCarrier): boolean;
+declare function telemetryContentMode(options: TelemetryOptionsCarrier): TelemetryContentMode;
+declare function withTelemetrySpan<T>(options: TelemetryOptionsCarrier, spanOptions: TelemetrySpanOptions, run: (span: Span) => MaybePromise$2<T>): Promise<T>;
+declare function recordRuntimeEventMetric(options: TelemetryOptionsCarrier, attributes?: Attributes): void;
+declare function addTelemetryContentEvent(options: TelemetryOptionsCarrier, name: string, attributes: Record<string, unknown>): void;
+declare function activeRuntimeEventTelemetry(options: TelemetryOptionsCarrier): RuntimeEventTelemetry | undefined;
+declare function createTelemetryContext(options: TelemetryOptionsCarrier): TelemetryContext;
+
+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 : {
+    [K in StringKey<T>]: T[K] extends Primitive | readonly unknown[] ? K : K | `${K}.${ContextPath<T[K]>}`;
+}[StringKey<T>];
+type ObjectSchema = z.ZodObject<Record<string, z.ZodType>>;
+type InferSchema<TSchema extends z.ZodType> = z.infer<TSchema>;
+interface ApplicationContextParts<TConversation, TTurn> {
+    conversation: TConversation;
+    turn: TTurn;
+}
+type GuardResult = boolean | {
+    allow: true;
+} | {
+    allow: false;
+    code: string;
+    message?: string;
+    prompt?: WidgetPromptDefinition<WidgetDefinition>;
+    metadata?: Record<string, unknown>;
+};
+type GuardContext<TApp, TJourneyContext> = {
+    app: TApp;
+    context: TJourneyContext;
+};
+interface ToolExecutionContext<TInput, TApp = unknown> {
+    input: TInput;
+    app: TApp;
+    conversationId: string;
+    telemetry: TelemetryContext;
+    idempotencyKey?: string;
+    signal?: AbortSignal;
+}
+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;
+    description?: string;
+    input: TInputSchema;
+    output: TOutputSchema;
+    sideEffect: TSideEffect;
+    idempotencyKey?: (args: {
+        input: z.infer<TInputSchema>;
+        conversationId: string;
+    }) => string;
+    execute: (context: ToolExecutionContext<z.infer<TInputSchema>>) => Promise<z.infer<TOutputSchema>>;
+}
+type AnyTool = ToolDefinition<string, z.ZodType, z.ZodType, boolean>;
+type SideEffectTool = ToolDefinition<string, z.ZodType, z.ZodType, true>;
+interface WidgetDefinition<TKind extends string = string, TInputSchema extends z.ZodType = z.ZodType, TOutputSchema extends z.ZodType = z.ZodType> {
+    kind: TKind;
+    input: TInputSchema;
+    output: TOutputSchema;
+}
+interface WidgetPromptDefinition<TWidget extends WidgetDefinition = WidgetDefinition> {
+    widget: TWidget;
+    input: z.infer<TWidget["input"]>;
+}
+interface KnowledgeItem<TMetadata = unknown> {
+    id: string;
+    title?: string;
+    content: string;
+    score?: number;
+    metadata: TMetadata;
+}
+interface KnowledgeSource<TName extends string = string, TQuerySchema extends z.ZodType = z.ZodType, TMetadataSchema extends z.ZodType = z.ZodType> {
+    kind: "knowledgeSource";
+    name: TName;
+    query: TQuerySchema;
+    metadata: TMetadataSchema;
+    retrieve(input: {
+        query: z.infer<TQuerySchema>;
+        signal?: AbortSignal;
+    }): Promise<{
+        items: Array<KnowledgeItem<z.infer<TMetadataSchema>>>;
+    }>;
+}
+interface CustomRuntimeEventDefinition<TName extends string = string, TPayloadSchema extends z.ZodType = z.ZodType> {
+    kind: "customRuntimeEvent";
+    name: TName;
+    payload: TPayloadSchema;
+    visibleToModel?: boolean;
+}
+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;
+}
+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.aborted", {
+    reason: string;
+    partialText?: 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;
+}> | 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> {
+    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>;
+}
+interface VoiceChannelSegment {
+    id: string;
+    conversationId: string;
+    channel: "voice";
+    startedAt: string;
+    endedAt?: string;
+}
+interface VoiceConnection {
+    id: string;
+    channelSegmentId: string;
+    status: VoiceConnectionStatus;
+    adapter: string;
+    provider?: string;
+    providerSessionId?: string;
+    expiresAt?: string;
+}
+interface VoiceSocketMetadata {
+    url: string;
+    token: string;
+    expiresAt: string;
+    protocol: "cognidesk.voice.v1";
+}
+interface VoiceStartClientHints {
+    userAgent?: string;
+    locale?: string;
+    metadata?: Record<string, unknown>;
+}
+interface StartVoiceConversationInput<TConversationContext = unknown> {
+    id?: string;
+    agentId: string;
+    context: TConversationContext;
+    client?: VoiceStartClientHints;
+    app?: unknown;
+}
+interface StartVoiceSegmentInput {
+    conversationId: string;
+    client?: VoiceStartClientHints;
+    app?: unknown;
+}
+interface StartVoiceResult {
+    conversation: ConversationRecord;
+    channelSegment: VoiceChannelSegment;
+    connection: VoiceConnection;
+    socket?: VoiceSocketMetadata;
+    events: RuntimeEvent[];
+}
+interface CommitVoiceTranscriptInput {
+    conversationId: string;
+    channelSegmentId: string;
+    speaker: VoiceSpeaker;
+    text: string;
+    recordingReferenceId?: string;
+    startedAtMs?: number;
+    endedAtMs?: number;
+    transcriptionSource?: string;
+    metadata?: Record<string, unknown>;
+}
+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;
+    reason?: string;
+}
+interface FieldCollectionOptions<TContext> {
+    prompt?: string;
+    required?: boolean;
+    requiredWhen?: (args: {
+        context: TContext;
+    }) => boolean;
+    extract?: boolean;
+    confirm?: boolean | "beforeAction" | ConfirmationPolicy;
+    widget?: FieldWidgetOption;
+    widgetInput?: (args: {
+        context: TContext;
+    }) => unknown;
+}
+interface ListCollectionOptions<TContext, TItemSchema extends z.ZodType> {
+    item: TItemSchema;
+    countFrom?: ContextPath<TContext>;
+    prompt?: string;
+    widget?: FieldWidgetOption;
+}
+interface TransitionOptions<TContext> {
+    priority?: number;
+    guard?: (context: GuardContext<unknown, TContext>) => MaybePromise$1<GuardResult>;
+    description?: string;
+}
+interface ToolRunOptions<TTool extends AnyTool, TContext> {
+    input?: (args: {
+        context: TContext;
+    }) => z.infer<TTool["input"]>;
+    assign?: Partial<Record<ContextPath<TContext>, (args: {
+        output: z.infer<TTool["output"]>;
+        context: TContext;
+    }) => unknown>>;
+    onSuccess?: StateBuilder<string, ObjectSchema>;
+    onFailure?: StateBuilder<string, ObjectSchema>;
+    onValidationError?: StateBuilder<string, ObjectSchema>;
+}
+type ToolRunOptionsFor<TTool extends AnyTool, TContext> = TTool extends SideEffectTool ? ToolRunOptions<TTool, TContext> & {
+    confirm: ConfirmationPolicy;
+} : ToolRunOptions<TTool, TContext> & {
+    confirm?: ConfirmationPolicy;
+};
+interface StateActionUseOptions<TAction extends ActionDefinition, TContext> {
+    type?: "entry" | "exit" | "transition";
+    input?: (args: {
+        context: TContext;
+    }) => z.infer<TAction["input"]>;
+}
+interface ActionDefinition<TName extends string = string, TInputSchema extends z.ZodType = z.ZodType> {
+    kind: "action";
+    name: TName;
+    input: TInputSchema;
+    run: (args: {
+        input: z.infer<TInputSchema>;
+    }) => MaybePromise$1<void>;
+    requiresVisit?: boolean;
+    retry?: false | {
+        maxAttempts?: number;
+        notice?: string;
+    };
+}
+interface JourneyEventDefinition<TName extends string = string, TPayloadSchema extends z.ZodType = z.ZodType> {
+    kind: "journeyEvent";
+    name: TName;
+    payload: TPayloadSchema;
+    routing?: EventRoutingMode;
+}
+type EventRoutingMode = "none" | "activeJourneyOnly" | "full" | "targeted";
+declare function tool<const TName extends string, TInputSchema extends z.ZodType, TOutputSchema extends z.ZodType, const TSideEffect extends boolean = false>(name: TName, config: {
+    description?: string;
+    input: TInputSchema;
+    output: TOutputSchema;
+    sideEffect?: TSideEffect;
+    idempotencyKey?: (args: {
+        input: z.infer<TInputSchema>;
+        conversationId: string;
+    }) => string;
+    execute: (context: ToolExecutionContext<z.infer<TInputSchema>>) => Promise<z.infer<TOutputSchema>>;
+}): ToolDefinition<TName, TInputSchema, TOutputSchema, TSideEffect>;
+declare function widget<const TKind extends string, TInputSchema extends z.ZodType, TOutputSchema extends z.ZodType>(kind: TKind, config: {
+    input: TInputSchema;
+    output: TOutputSchema;
+}): 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;
+    retrieve: (input: {
+        query: z.core.output<TQuerySchema>;
+        signal?: AbortSignal;
+    }) => Promise<{
+        items: KnowledgeItem<z.core.output<TMetadataSchema>>[];
+    }>;
+    kind: "knowledgeSource";
+    name: TName;
+};
+declare function action<const TName extends string, TInputSchema extends z.ZodType>(name: TName, config: {
+    input: TInputSchema;
+    run: (args: {
+        input: z.infer<TInputSchema>;
+    }) => MaybePromise$1<void>;
+    requiresVisit?: boolean;
+    retry?: false | {
+        maxAttempts?: number;
+        notice?: string;
+    };
+}): ActionDefinition<TName, TInputSchema>;
+declare function journeyEvent<const TName extends string, TPayloadSchema extends z.ZodType>(name: TName, config: {
+    payload: TPayloadSchema;
+    routing?: EventRoutingMode;
+}): JourneyEventDefinition<TName, TPayloadSchema>;
+declare function customRuntimeEvent<const TName extends string, TPayloadSchema extends z.ZodType>(name: TName, config: {
+    payload: TPayloadSchema;
+    visibleToModel?: boolean;
+}): CustomRuntimeEventDefinition<TName, TPayloadSchema>;
+
+type InferObject$2<TSchema extends ObjectSchema> = z.infer<TSchema>;
+interface StateReference<TId extends string = string> {
+    readonly id: TId;
+}
+interface CompiledAgent {
+    id: string;
+    instructions: string;
+    logLevel?: AgentLogLevel;
+    behavior: AgentBehaviorOptions;
+    postProcessing: AgentPostProcessingOptions;
+    voice?: VoiceProfile;
+    journeys: CompiledJourney[];
+    tools: AnyTool[];
+    knowledge: KnowledgeSource[];
+    widgets: WidgetDefinition[];
+    customEvents: AnyCustomRuntimeEvent[];
+}
+interface CompiledJourney {
+    id: string;
+    kind: "stateMachine" | "delegation";
+    condition: string;
+    examples: string[];
+    tags: string[];
+    priority: number;
+    stickiness: "low" | "medium" | "high";
+    alwaysInclude: boolean;
+    always?: JourneyActivationPredicate;
+    includeWhen?: CandidateFilterPredicate;
+    matcher?: JourneyActivationPredicate;
+    guard?: JourneyGuardPredicate;
+    contextReuse?: CompiledContextReusePolicy;
+    knowledge: KnowledgeSource[];
+    tools: AnyTool[];
+    context?: ObjectSchema;
+    delegation?: CompiledDelegation;
+    states: CompiledState[];
+    initialStateId?: string;
+    alternateEntries: CompiledJourneyEntry[];
+    toGraph(): JourneyGraph;
+    toJSON(): JourneyGraph;
+    toMermaid(): string;
+}
+interface CompiledState {
+    id: string;
+    parentId?: string;
+    initialStateId?: string;
+    type: "state" | "parallel" | "final";
+    instructions?: string;
+    summary?: string;
+    tools: AnyTool[];
+    knowledge: KnowledgeSource[];
+    collected: Array<{
+        path: string;
+        required: boolean;
+        extract: boolean;
+        confirm?: true | "beforeAction" | ConfirmationPolicy;
+        prompt?: string;
+        widget?: WidgetDefinition;
+        widgetInput?: unknown | ((args: {
+            context: unknown;
+        }) => unknown);
+        requiredWhen?: (args: {
+            context: unknown;
+        }) => boolean;
+    }>;
+    transitions: CompiledTransition[];
+    actions: Array<{
+        type: "entry" | "exit" | "transition";
+        name: string;
+    }>;
+    actionRuns: CompiledActionRun[];
+    toolRuns: CompiledToolRun[];
+    requiresVisit: boolean;
+}
+interface CompiledTransition<TContext = unknown> {
+    kind: "event" | "conversational";
+    targetId: string;
+    eventName?: string;
+    description?: string;
+    priority?: number;
+    guard?: (context: GuardContext<unknown, TContext>) => MaybePromise$1<GuardResult>;
+}
+interface CompiledToolRun<TContext = unknown> {
+    tool: AnyTool;
+    confirm?: ConfirmationPolicy;
+    actionType: "entry" | "exit" | "transition";
+    input?: (args: {
+        context: TContext;
+    }) => unknown;
+    assign: Array<{
+        path: string;
+        value: (args: {
+            output: unknown;
+            context: TContext;
+        }) => unknown;
+    }>;
+    onSuccessId?: string;
+    onFailureId?: string;
+    onValidationErrorId?: string;
+}
+interface CompiledActionRun<TContext = unknown> {
+    action: ActionDefinition;
+    actionType: "entry" | "exit" | "transition";
+    input?: (args: {
+        context: TContext;
+    }) => unknown;
+}
+interface CompiledDelegation {
+    goal: string;
+    instructions?: string;
+    tools: AnyTool[];
+    completeWhen: string[];
+}
+interface CompiledJourneyEntry<TContext = unknown> {
+    stateId: string;
+    description?: string;
+    priority?: number;
+    when: JourneyEntryPredicate<unknown, unknown, unknown, TContext>;
+}
+interface JourneyGraphState {
+    id: string;
+    parentId?: string;
+    initialStateId?: string;
+    type: "state" | "parallel" | "final";
+    instructions?: string;
+    summary?: string;
+    collected: Array<{
+        path: string;
+        required: boolean;
+        extract: boolean;
+    }>;
+    transitions: Array<{
+        kind: "event" | "conversational";
+        targetId: string;
+        eventName?: string;
+        description?: string;
+        priority?: number;
+    }>;
+    actions: Array<{
+        type: "entry" | "exit" | "transition";
+        name: string;
+    }>;
+    requiresVisit: boolean;
+}
+interface JourneyGraph {
+    id: string;
+    kind: "stateMachine" | "delegation";
+    initialStateId?: string;
+    alternateEntries?: Array<{
+        stateId: string;
+        description?: string;
+        priority?: number;
+    }>;
+    states: JourneyGraphState[];
+}
+type JourneyActivationPredicate<TApp = unknown, TConversation = unknown, TTurn = unknown> = (args: ApplicationContextParts<TConversation, TTurn> & {
+    app: TApp;
+    activeJourneyId?: string;
+}) => MaybePromise$1<boolean>;
+type CandidateFilterPredicate<TApp = unknown, TConversation = unknown, TTurn = unknown> = (args: ApplicationContextParts<TConversation, TTurn> & {
+    app: TApp;
+    activeJourneyId?: string;
+}) => boolean;
+type JourneyGuardPredicate<TApp = unknown, TConversation = unknown, TTurn = unknown> = (args: ApplicationContextParts<TConversation, TTurn> & {
+    app: TApp;
+    activeJourneyId?: string;
+    journeyId: string;
+}) => MaybePromise$1<GuardResult>;
+type ContextReusePredicate<TApp = unknown, TConversation = unknown, TTurn = unknown, TContext = unknown> = (args: ApplicationContextParts<TConversation, TTurn> & {
+    app: TApp;
+    activeJourneyId?: string;
+    journeyId: string;
+    previousContext: TContext;
+}) => MaybePromise$1<boolean>;
+type JourneyEntryPredicate<TApp = unknown, TConversation = unknown, TTurn = unknown, TContext = unknown> = (args: ApplicationContextParts<TConversation, TTurn> & {
+    app: TApp;
+    context: TContext;
+    journeyId: string;
+    activeJourneyId?: string;
+}) => MaybePromise$1<boolean>;
+interface JourneyEntryOptions<TContext> {
+    description?: string;
+    priority?: number;
+    when: JourneyEntryPredicate<unknown, unknown, unknown, TContext>;
+}
+interface ContextReusePolicy<TContext> {
+    fields?: Array<ContextPath<TContext>>;
+    when: ContextReusePredicate<unknown, unknown, unknown, TContext>;
+}
+interface CompiledContextReusePolicy {
+    fields?: string[];
+    when: ContextReusePredicate;
+}
+interface ActivationMetadata {
+    condition: string;
+    examples?: string[];
+    tags?: string[];
+    priority?: number;
+    stickiness?: "low" | "medium" | "high";
+    always?: boolean | JourneyActivationPredicate;
+    alwaysInclude?: boolean;
+    includeWhen?: CandidateFilterPredicate;
+    matcher?: JourneyActivationPredicate;
+    guard?: JourneyGuardPredicate;
+}
+interface StateMachineJourneyOptions<TContextSchema extends ObjectSchema> extends ActivationMetadata {
+    context: TContextSchema;
+    description?: string;
+    contextReuse?: ContextReusePolicy<InferObject$2<TContextSchema>>;
+}
+interface DelegationJourneyOptions extends ActivationMetadata {
+    specialist: {
+        goal: string;
+        instructions?: string;
+        tools?: AnyTool[];
+        knowledge?: KnowledgeSource[];
+    };
+    completeWhen?: string[];
+}
+interface AgentBehaviorOptions {
+    interruptOnNewMessage?: boolean;
+}
+interface AgentPostProcessingOptions {
+    citations?: boolean;
+}
+type AgentLogLevel = "trace" | "debug" | "info" | "error";
+interface AgentOptions {
+    instructions: string;
+    logLevel?: AgentLogLevel;
+    behavior?: AgentBehaviorOptions;
+    postProcessing?: AgentPostProcessingOptions;
+}
+type VoiceProfileOptions = VoiceProfile;
+
+type InferObject$1<TSchema extends ObjectSchema> = z.infer<TSchema>;
+interface InternalTransition {
+    kind: "event" | "conversational";
+    target: StateBuilder<string, ObjectSchema>;
+    eventName?: string;
+    description?: string;
+    priority?: number;
+    guard?: (context: GuardContext<unknown, unknown>) => MaybePromise$1<GuardResult>;
+}
+interface InternalToolRun {
+    tool: AnyTool;
+    confirm?: ConfirmationPolicy;
+    actionType: "entry" | "exit" | "transition";
+    input?: (args: {
+        context: unknown;
+    }) => unknown;
+    assign: Array<{
+        path: string;
+        value: (args: {
+            output: unknown;
+            context: unknown;
+        }) => unknown;
+    }>;
+    onSuccess?: StateBuilder<string, ObjectSchema>;
+    onFailure?: StateBuilder<string, ObjectSchema>;
+    onValidationError?: StateBuilder<string, ObjectSchema>;
+}
+interface InternalActionRun {
+    action: ActionDefinition;
+    actionType: "entry" | "exit" | "transition";
+    input?: (args: {
+        context: unknown;
+    }) => unknown;
+}
+interface CollectedField {
+    path: string;
+    required: boolean;
+    extract: boolean;
+    confirm?: true | "beforeAction" | ConfirmationPolicy;
+    prompt?: string;
+    widget?: WidgetDefinition;
+    widgetInput?: unknown | ((args: {
+        context: unknown;
+    }) => unknown);
+    requiredWhen?: (args: {
+        context: unknown;
+    }) => boolean;
+}
+interface StateActionRecord {
+    type: "entry" | "exit" | "transition";
+    name: string;
+    requiresVisit?: boolean;
+}
+interface TransitionTargetBuilder<TContextSchema extends ObjectSchema, TReturn> {
+    target(state: StateBuilder<string, TContextSchema>): TReturn;
+}
+
+declare class StateBuilder<const TId extends string, TContextSchema extends ObjectSchema> implements StateReference<TId> {
+    readonly id: TId;
+    readonly contextSchema: TContextSchema;
+    readonly parent?: StateBuilder<string, TContextSchema> | undefined;
+    readonly tools: CapabilityScope<AnyTool>;
+    readonly knowledge: CapabilityScope<KnowledgeSource<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+    readonly children: StateBuilder<string, TContextSchema>[];
+    readonly transitions: InternalTransition[];
+    readonly toolRuns: InternalToolRun[];
+    readonly actionRuns: InternalActionRun[];
+    readonly collectedFields: CollectedField[];
+    readonly stateActions: StateActionRecord[];
+    private visitRequirement;
+    private stateInstructions?;
+    private stateSummary?;
+    private stateType;
+    private initialChildState?;
+    constructor(id: TId, contextSchema: TContextSchema, parent?: StateBuilder<string, TContextSchema> | undefined);
+    instructions(value: string): this;
+    summary(value: string): this;
+    collect(path: ContextPath<InferObject$1<TContextSchema>>, options?: FieldCollectionOptions<InferObject$1<TContextSchema>>): this;
+    collectList<TItemSchema extends z.ZodType>(path: ContextPath<InferObject$1<TContextSchema>>, options: ListCollectionOptions<InferObject$1<TContextSchema>, TItemSchema>): this;
+    state<const TChildId extends string>(id: TChildId): StateBuilder<TChildId, TContextSchema>;
+    parallel<const TChildId extends string>(id: TChildId): StateBuilder<TChildId, TContextSchema>;
+    final<const TChildId extends string>(id: TChildId): StateBuilder<TChildId, TContextSchema>;
+    initial(state: StateBuilder<string, TContextSchema>): this;
+    markFinal(): this;
+    markParallel(): this;
+    when(description: string, options?: TransitionOptions<InferObject$1<TContextSchema>>): TransitionTargetBuilder<TContextSchema, this>;
+    on(event: JourneyEventDefinition, options?: TransitionOptions<InferObject$1<TContextSchema>>): TransitionTargetBuilder<TContextSchema, this>;
+    transitionTo(state: StateBuilder<string, TContextSchema>, options?: TransitionOptions<InferObject$1<TContextSchema>>): this;
+    entry<TTool extends AnyTool>(toolDefinition: TTool, options: ToolRunOptionsFor<TTool, InferObject$1<TContextSchema>>): this;
+    exit<TTool extends AnyTool>(toolDefinition: TTool, options: ToolRunOptionsFor<TTool, InferObject$1<TContextSchema>>): this;
+    runTool<TTool extends AnyTool>(toolDefinition: TTool, options: ToolRunOptionsFor<TTool, InferObject$1<TContextSchema>>): this;
+    private registerToolRun;
+    useAction<TAction extends ActionDefinition>(actionDefinition: TAction, options?: StateActionUseOptions<TAction, InferObject$1<TContextSchema>> | "entry" | "exit" | "transition"): this;
+    requiresVisit(reason?: string): this;
+    allowSkip(): this;
+    compile(parentId?: string, inheritedTools?: AnyTool[], inheritedKnowledge?: KnowledgeSource[], inheritedCollectedFields?: StateBuilder<string, TContextSchema>["collectedFields"]): CompiledState[];
+}
+
+type InferObject<TSchema extends ObjectSchema> = z.infer<TSchema>;
+interface JourneyFragment<TName extends string = string, TContextSchema extends ObjectSchema = ObjectSchema> {
+    kind: "journeyFragment";
+    name: TName;
+    context: TContextSchema;
+    apply(journey: StateMachineJourneyBuilder<string, TContextSchema>): void;
+}
+interface JourneyFragmentOptions<TContextSchema extends ObjectSchema> {
+    context: TContextSchema;
+    tools?: AnyTool[];
+    knowledge?: KnowledgeSource[];
+    define: (journey: StateMachineJourneyBuilder<string, TContextSchema>) => void;
+}
+declare class StateCollection<TContextSchema extends ObjectSchema> {
+    private readonly contextSchema;
+    private readonly states;
+    constructor(contextSchema: TContextSchema);
+    add<const TId extends string>(id: TId): StateBuilder<TId, TContextSchema>;
+    get<TId extends string>(id: TId): StateBuilder<TId, TContextSchema>;
+    list(): StateBuilder<string, TContextSchema>[];
+}
+declare class TypedStateRegistry<TStateIds extends string, TContextSchema extends ObjectSchema> {
+    private readonly collection;
+    constructor(collection: StateCollection<TContextSchema>);
+    get<TId extends TStateIds>(id: TId): StateBuilder<TId, TContextSchema>;
+}
+declare class StateMachineJourneyBuilder<const TId extends string, TContextSchema extends ObjectSchema> {
+    readonly id: TId;
+    readonly options: StateMachineJourneyOptions<TContextSchema>;
+    readonly kind: "stateMachine";
+    readonly states: StateCollection<TContextSchema>;
+    readonly tools: CapabilityScope<AnyTool>;
+    readonly knowledge: CapabilityScope<KnowledgeSource<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+    private readonly alternateEntryStates;
+    private initialState?;
+    constructor(id: TId, options: StateMachineJourneyOptions<TContextSchema>);
+    state<const TStateId extends string>(id: TStateId): StateBuilder<TStateId, TContextSchema>;
+    parallel<const TStateId extends string>(id: TStateId): StateBuilder<TStateId, TContextSchema>;
+    defineStates<const TStateIds extends readonly [string, ...string[]]>(...ids: TStateIds): TypedStateRegistry<TStateIds[number], TContextSchema>;
+    final<const TStateId extends string>(id: TStateId): StateBuilder<TStateId, TContextSchema>;
+    event<const TName extends string, TPayloadSchema extends z.ZodType>(name: TName, config: {
+        payload: TPayloadSchema;
+        routing?: EventRoutingMode;
+    }): JourneyEventDefinition<TName, TPayloadSchema>;
+    use(fragment: JourneyFragment<string, TContextSchema>): this;
+    alternateEntry(state: StateBuilder<string, TContextSchema>, options: JourneyEntryOptions<InferObject<TContextSchema>>): this;
+    initial(state: StateBuilder<string, TContextSchema>): this;
+    compile(): CompiledJourney;
+}
+declare class DelegationJourneyBuilder<const TId extends string> {
+    readonly id: TId;
+    readonly options: DelegationJourneyOptions;
+    readonly kind: "delegation";
+    constructor(id: TId, options: DelegationJourneyOptions);
+    compile(): CompiledJourney;
+}
+declare function journeyFragment<const TName extends string, TContextSchema extends ObjectSchema>(name: TName, options: JourneyFragmentOptions<TContextSchema>): JourneyFragment<TName, TContextSchema>;
+
+declare class AgentBuilder<const TId extends string> {
+    readonly id: TId;
+    readonly options: AgentOptions;
+    readonly tools: CapabilityScope<AnyTool>;
+    readonly knowledge: CapabilityScope<KnowledgeSource<string, zod.ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>, zod.ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>>;
+    readonly customEvents: CapabilityScope<AnyCustomRuntimeEvent>;
+    readonly widgets: WidgetDefinition[];
+    private voiceProfile?;
+    private readonly journeys;
+    constructor(id: TId, options: AgentOptions);
+    stateMachineJourney<const TJourneyId extends string, TContextSchema extends ObjectSchema>(id: TJourneyId, options: StateMachineJourneyOptions<TContextSchema>): StateMachineJourneyBuilder<TJourneyId, TContextSchema>;
+    delegationJourney<const TJourneyId extends string>(id: TJourneyId, options: DelegationJourneyOptions): DelegationJourneyBuilder<TJourneyId>;
+    registerWidget(widgetDefinition: WidgetDefinition): this;
+    voice(options: VoiceProfileOptions): this;
+    compile(): CompiledAgent;
+}
+declare function createAgent<const TId extends string>(id: TId, options: AgentOptions): AgentBuilder<TId>;
+
+declare const JOURNEY_INDEX_PROJECTION_VERSION = "cognidesk.journey-index.v1";
+declare const journeyIndexEmbeddingSchema: z.ZodObject<{
+    model: z.ZodString;
+    dimensions: z.ZodNumber;
+    vector: z.ZodArray<z.ZodNumber>;
+}, z.core.$strip>;
+declare const journeyIndexEntrySchema: z.ZodObject<{
+    journeyId: z.ZodString;
+    kind: z.ZodEnum<{
+        stateMachine: "stateMachine";
+        delegation: "delegation";
+    }>;
+    condition: z.ZodString;
+    examples: z.ZodArray<z.ZodString>;
+    tags: z.ZodArray<z.ZodString>;
+    priority: z.ZodNumber;
+    stickiness: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>;
+    alwaysInclude: z.ZodBoolean;
+    definitionHash: z.ZodString;
+    routingText: z.ZodString;
+    embedding: z.ZodObject<{
+        model: z.ZodString;
+        dimensions: z.ZodNumber;
+        vector: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const journeyIndexSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    projectionVersion: z.ZodLiteral<"cognidesk.journey-index.v1">;
+    definitionHash: z.ZodString;
+    embeddingProvider: z.ZodString;
+    embeddingModel: z.ZodString;
+    generatedAt: z.ZodString;
+    entries: z.ZodArray<z.ZodObject<{
+        journeyId: z.ZodString;
+        kind: z.ZodEnum<{
+            stateMachine: "stateMachine";
+            delegation: "delegation";
+        }>;
+        condition: z.ZodString;
+        examples: z.ZodArray<z.ZodString>;
+        tags: z.ZodArray<z.ZodString>;
+        priority: z.ZodNumber;
+        stickiness: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>;
+        alwaysInclude: z.ZodBoolean;
+        definitionHash: z.ZodString;
+        routingText: z.ZodString;
+        embedding: z.ZodObject<{
+            model: z.ZodString;
+            dimensions: z.ZodNumber;
+            vector: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type JourneyIndexEmbedding = z.infer<typeof journeyIndexEmbeddingSchema>;
+type JourneyIndexEntry = z.infer<typeof journeyIndexEntrySchema>;
+type JourneyIndex = z.infer<typeof journeyIndexSchema>;
+interface BuildJourneyIndexOptions {
+    embeddingModel: ModelAdapter;
+    generatedAt?: string;
+    signal?: AbortSignal;
+}
+interface JourneyIndexValidationResult {
+    ok: boolean;
+    errors: string[];
+}
+interface ValidateJourneyIndexOptions {
+    embeddingModel?: Pick<ModelAdapter, "provider" | "model">;
+}
+interface SelectJourneyCandidatesOptions<TApp = unknown, TConversation = unknown, TTurn = unknown> {
+    agent: CompiledAgent;
+    index: JourneyIndex;
+    embeddingModel: ModelAdapter;
+    message: string;
+    app: TApp;
+    conversation: TConversation;
+    turn: TTurn;
+    activeJourneyId?: string;
+    topK?: number;
+    allowStaleIndex?: boolean;
+    signal?: AbortSignal;
+}
+interface JourneyCandidate {
+    journeyId: string;
+    journey: CompiledJourney;
+    score: number;
+    similarity: number;
+    reason: "always" | "matcher" | "embedding";
+    definitionHash: string;
+}
+
+declare function buildJourneyIndex(agent: CompiledAgent, options: BuildJourneyIndexOptions): Promise<JourneyIndex>;
+
+declare function createJourneyRoutingText(journey: CompiledJourney): string;
+declare function hashAgentRoutingDefinition(agent: CompiledAgent): string;
+declare function hashJourneyDefinition(journey: CompiledJourney): string;
+
+declare function selectJourneyCandidates<TApp, TConversation, TTurn>(options: SelectJourneyCandidatesOptions<TApp, TConversation, TTurn>): Promise<JourneyCandidate[]>;
+
+declare function validateJourneyIndex(agent: CompiledAgent, index: JourneyIndex, options?: ValidateJourneyIndexOptions): JourneyIndexValidationResult;
+
+interface ReplayedMessage {
+    id: string;
+    offset: number;
+    role: "user" | "assistant";
+    text: string;
+    intermediate: boolean;
+    aborted: boolean;
+    reason?: string;
+    segments?: MessageSegment[];
+}
+interface ReplayedPrompt {
+    promptId: string;
+    offset: number;
+    widgetKind: string;
+    input: unknown;
+}
+
+type MaybePromise<T> = Promise<T> | T;
+interface PrivacyHookContext {
+    conversationId: string;
+    agentId: string;
+}
+interface PrivacyHooks {
+    redactUserMessage?(input: PrivacyHookContext & {
+        text: string;
+    }): MaybePromise<string>;
+    redactModelMessages?(input: PrivacyHookContext & {
+        messages: ModelMessage[];
+    }): MaybePromise<ModelMessage[]>;
+    redactAssistantMessage?(input: PrivacyHookContext & {
+        text: string;
+    }): MaybePromise<string>;
+    redactConversationContext?(input: PrivacyHookContext & {
+        context: unknown;
+    }): MaybePromise<unknown>;
+    redactRuntimeEvent?(input: PrivacyHookContext & {
+        event: RuntimeEventInput;
+    }): MaybePromise<RuntimeEventInput>;
+    redactRuntimeSnapshot?(input: PrivacyHookContext & {
+        snapshot: RuntimeSnapshot;
+    }): MaybePromise<RuntimeSnapshot>;
+    redactModelInput?(input: PrivacyHookContext & {
+        input: TextGenerationInput;
+    }): MaybePromise<TextGenerationInput>;
+}
+
+interface RuntimeOptions {
+    storage: StorageAdapter;
+    agent?: CompiledAgent;
+    models?: AgentModelSet;
+    journeyIndex?: JourneyIndex;
+    topKJourneys?: number;
+    app?: unknown;
+    knowledgeLimit?: number;
+    privacy?: PrivacyHooks;
+    telemetry?: RuntimeTelemetryOptions;
+    logLevel?: AgentLogLevel;
+    logger?: Pick<Logger, "trace" | "debug" | "info" | "warn" | "error" | "child">;
+    compaction?: {
+        beforeTurn?: boolean;
+        afterTurn?: boolean;
+        minEvents?: number;
+        schemaVersion?: string;
+        instructions?: string;
+        summarySchema?: z.ZodType;
+    };
+    postProcessing?: {
+        citations?: boolean;
+    };
+    streaming?: {
+        syntheticDeltas?: boolean;
+    };
+    toolRetry?: {
+        maxAttempts?: number;
+        notice?: string;
+    };
+}
+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 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 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[];
+}
+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 RequestHandoffInput {
+    conversationId: string;
+    reason: string;
+    summary?: string;
+    payload?: unknown;
+}
+interface ResumeConversationInput {
+    conversationId: string;
+    reason?: string;
+    payload?: unknown;
+}
+interface CompactConversationResult<TSummary = ConversationCompactionSummary> {
+    summary: TSummary;
+    snapshot: RuntimeSnapshot;
+    events: RuntimeEvent[];
+}
+
+declare class CognideskRuntime {
+    private readonly activeTurns;
+    private readonly kernel;
+    private readonly options;
+    constructor(options: RuntimeOptions);
+    initialize(): Promise<void>;
+    createConversation<TConversationContext = unknown>(input: CreateRuntimeConversationInput<TConversationContext>): Promise<ConversationRecord<TConversationContext>>;
+    emit<TEvent extends RuntimeEventInput>(event: TEvent): Promise<RuntimeEvent>;
+    emitIntermediateMessage(input: EmitIntermediateMessageInput): Promise<{
+        events: RuntimeEvent[];
+    }>;
+    emitGeneratedPreamble(input: EmitGeneratedPreambleInput): Promise<EmitGeneratedPreambleResult>;
+    emitCustomEvent<TEvent extends CustomRuntimeEventDefinition>(input: EmitCustomEventInput<TEvent>): Promise<RuntimeEvent>;
+    emitJourneyEvent<TEvent extends JourneyEventDefinition>(input: EmitJourneyEventInput<TEvent>): Promise<EmitJourneyEventResult>;
+    listEvents(conversationId: string, afterOffset?: number): Promise<RuntimeEvent[]>;
+    replayConversation(input: ReplayConversationInput): Promise<ReplayConversationResult>;
+    submitWidget(input: SubmitWidgetInput): Promise<RuntimeEvent>;
+    getSnapshot(conversationId: string): Promise<RuntimeSnapshot | null>;
+    handleUserMessage<TTurn = unknown>(input: HandleUserMessageInput<TTurn>): Promise<HandleUserMessageResult>;
+    handleVoiceUserMessage<TTurn = unknown>(input: HandleVoiceUserMessageInput<TTurn>): Promise<HandleVoiceUserMessageResult>;
+    startVoiceConversation<TConversationContext = unknown>(input: StartVoiceConversationInput<TConversationContext>): Promise<StartVoiceResult>;
+    startVoiceSegment(input: StartVoiceSegmentInput): Promise<StartVoiceResult>;
+    endVoiceSegment(input: {
+        conversationId: string;
+        channelSegmentId: string;
+        connectionId?: string;
+        reason?: string;
+    }): Promise<RuntimeEvent>;
+    commitVoiceTranscript(input: CommitVoiceTranscriptInput): Promise<CommitVoiceTranscriptResult>;
+    recordVoiceInterruption(input: RecordVoiceInterruptionInput): Promise<RuntimeEvent>;
+    closeConversation(conversationId: string, reason?: string): Promise<ConversationRecord<unknown>>;
+    requestHandoff(input: RequestHandoffInput): Promise<{
+        conversation: ConversationRecord<unknown>;
+        event: RuntimeEvent;
+    }>;
+    resumeConversation(input: ResumeConversationInput): Promise<{
+        conversation: ConversationRecord<unknown>;
+        event: RuntimeEvent;
+    }>;
+    compactConversation<TSummary = ConversationCompactionSummary>(input: CompactConversationInput): Promise<CompactConversationResult<TSummary>>;
+    private runtimeOperation;
+}
+declare function createRuntime(options: RuntimeOptions): CognideskRuntime;
+
+type SdkLogLevel = AgentLogLevel;
+type SdkLogger = Pick<Logger, "trace" | "debug" | "info" | "warn" | "error" | "child">;
+interface RuntimeLogContext {
+    agentId?: string;
+    conversationId?: string;
+    journeyId?: string;
+    stateId?: string;
+}
+declare function createRuntimeLogger(options: RuntimeOptions): SdkLogger;
+declare function runtimeLogger(options: RuntimeOptions, context?: RuntimeLogContext): Pick<pino.Logger, "error" | "trace" | "debug" | "info" | "warn" | "child">;
+
+declare const textInputWidget: WidgetDefinition<"text-input", z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    placeholder: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    value: z.ZodString;
+}, z.core.$strip>>;
+declare const choiceWidget: WidgetDefinition<"choice", z.ZodObject<{
+    label: z.ZodString;
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    selectedId: z.ZodString;
+}, z.core.$strip>>;
+declare const confirmationWidget: WidgetDefinition<"confirmation", z.ZodObject<{
+    title: z.ZodString;
+    message: z.ZodString;
+    confirmLabel: z.ZodOptional<z.ZodString>;
+    cancelLabel: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    confirmed: z.ZodBoolean;
+}, z.core.$strip>>;
+declare const datePickerWidget: WidgetDefinition<"date-picker", z.ZodObject<{
+    label: z.ZodString;
+    min: z.ZodOptional<z.ZodString>;
+    max: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    value: z.ZodString;
+}, z.core.$strip>>;
+declare const formWidget: WidgetDefinition<"form", z.ZodObject<{
+    title: z.ZodString;
+    fields: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        type: z.ZodEnum<{
+            number: "number";
+            date: "date";
+            text: "text";
+            choice: "choice";
+            email: "email";
+        }>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        placeholder: z.ZodOptional<z.ZodString>;
+        min: z.ZodOptional<z.ZodString>;
+        max: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    values: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>>;
+declare const endConversationTool: ToolDefinition<"cognidesk.endConversation", z.ZodObject<{
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    closed: z.ZodLiteral<true>;
+}, z.core.$strip>, true>;
+declare const handoffTool: ToolDefinition<"cognidesk.handoff", z.ZodObject<{
+    reason: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    payload: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    handoffRequested: z.ZodLiteral<true>;
+}, z.core.$strip>, true>;
+declare const journeyContextViewerTool: ToolDefinition<"cognidesk.viewJourneyContext", z.ZodObject<{
+    journeyId: z.ZodString;
+    fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    journeyId: z.ZodString;
+    context: z.ZodUnknown;
+}, z.core.$strip>, false>;
+declare const builtInWidgets: {
+    textInputWidget: WidgetDefinition<"text-input", z.ZodObject<{
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        placeholder: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    choiceWidget: WidgetDefinition<"choice", z.ZodObject<{
+        label: z.ZodString;
+        options: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        selectedId: z.ZodString;
+    }, z.core.$strip>>;
+    confirmationWidget: WidgetDefinition<"confirmation", z.ZodObject<{
+        title: z.ZodString;
+        message: z.ZodString;
+        confirmLabel: z.ZodOptional<z.ZodString>;
+        cancelLabel: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        confirmed: z.ZodBoolean;
+    }, z.core.$strip>>;
+    datePickerWidget: WidgetDefinition<"date-picker", z.ZodObject<{
+        label: z.ZodString;
+        min: z.ZodOptional<z.ZodString>;
+        max: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    formWidget: WidgetDefinition<"form", z.ZodObject<{
+        title: z.ZodString;
+        fields: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            type: z.ZodEnum<{
+                number: "number";
+                date: "date";
+                text: "text";
+                choice: "choice";
+                email: "email";
+            }>;
+            required: z.ZodDefault<z.ZodBoolean>;
+            placeholder: z.ZodOptional<z.ZodString>;
+            min: z.ZodOptional<z.ZodString>;
+            max: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        values: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>;
+};
+declare const builtInTools: {
+    endConversationTool: ToolDefinition<"cognidesk.endConversation", z.ZodObject<{
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        closed: z.ZodLiteral<true>;
+    }, z.core.$strip>, true>;
+    handoffTool: ToolDefinition<"cognidesk.handoff", z.ZodObject<{
+        reason: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        payload: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+        handoffRequested: z.ZodLiteral<true>;
+    }, z.core.$strip>, true>;
+    journeyContextViewerTool: ToolDefinition<"cognidesk.viewJourneyContext", z.ZodObject<{
+        journeyId: z.ZodString;
+        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        journeyId: z.ZodString;
+        context: z.ZodUnknown;
+    }, 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 };