@pinecall/protocol 0.1.0

package/dist/generated/defs.d.ts

@@ -0,0 +1,604 @@
+import { z } from "zod";
+/**
+ * The door the public came through: a phone call over SIP, the browser widget over WebRTC, or
+ * WhatsApp text.
+ */
+export declare const ChannelSchema: z.ZodEnum<{
+    phone: "phone";
+    web: "web";
+    whatsapp: "whatsapp";
+}>;
+export type Channel = z.infer<typeof ChannelSchema>;
+/** Inbound: the public reached the agent. Outbound: the agent reached out (a dial). */
+export declare const DirectionSchema: z.ZodEnum<{
+    inbound: "inbound";
+    outbound: "outbound";
+}>;
+export type Direction = z.infer<typeof DirectionSchema>;
+/**
+ * Which of the two worlds a key opens, and so which world an agent is held in and a call ran in. A
+ * key is issued into one; an agent registered on it and every call it takes carry that one; a door
+ * claimed in one is refused to a key of the other. `sandbox` is where things are written and
+ * `production` is what the public reaches — and whether a sandbox agent is one PERSON's copy or
+ * the team's shared one is not this field: it is whether the key that registered it names a
+ * person. Every key issued before the field existed is production.
+ */
+export declare const EnvSchema: z.ZodEnum<{
+    production: "production";
+    sandbox: "sandbox";
+}>;
+export type Env = z.infer<typeof EnvSchema>;
+/**
+ * What a console may ask of the process standing in the agent's directory, relayed by the gateway:
+ * a written call to the class mounted there (chat), a simulated caller from its personas, its
+ * goldens and a suite of them, its knowledge folder pushed or its golden asked, its memory
+ * goldens, a call promoted to a candidate file, the drift of the last two windows, and the
+ * reproductions a broken run left on that disk. Everything else a console needs is a door of the
+ * gateway.
+ */
+export declare const DevVerbSchema: z.ZodEnum<{
+    "chat.roster": "chat.roster";
+    "chat.start": "chat.start";
+    "chat.say": "chat.say";
+    "chat.end": "chat.end";
+    "simulate.roster": "simulate.roster";
+    "simulate.start": "simulate.start";
+    "goldens.roster": "goldens.roster";
+    "goldens.run": "goldens.run";
+    "knowledge.roster": "knowledge.roster";
+    "knowledge.push": "knowledge.push";
+    "knowledge.eval": "knowledge.eval";
+    "memory.roster": "memory.roster";
+    "memory.eval": "memory.eval";
+    "memory.extraction": "memory.extraction";
+    "promote.roster": "promote.roster";
+    "promote.write": "promote.write";
+    "drift.read": "drift.read";
+    "reproductions.roster": "reproductions.roster";
+    "reproductions.read": "reproductions.read";
+}>;
+export type DevVerb = z.infer<typeof DevVerbSchema>;
+/**
+ * Why the call is over. Who hung up, what failed before anybody could, drained: the platform took
+ * the worker down (a deploy, a stop) with the call still on it, or app_detached: the app holding
+ * the agent closed its socket mid-call, so nothing was rendering the prompt or answering a tool —
+ * both are nobody's fault and neither is an error.
+ */
+export declare const EndReasonSchema: z.ZodEnum<{
+    caller_hung_up: "caller_hung_up";
+    agent_hung_up: "agent_hung_up";
+    supervisor_ended: "supervisor_ended";
+    transferred: "transferred";
+    no_answer: "no_answer";
+    busy: "busy";
+    dial_failed: "dial_failed";
+    timeout: "timeout";
+    drained: "drained";
+    app_detached: "app_detached";
+    error: "error";
+}>;
+export type EndReason = z.infer<typeof EndReasonSchema>;
+/** Whose action ended the call. platform covers timeouts, errors and a drained worker. */
+export declare const EndedBySchema: z.ZodEnum<{
+    agent: "agent";
+    caller: "caller";
+    supervisor: "supervisor";
+    platform: "platform";
+}>;
+export type EndedBy = z.infer<typeof EndedBySchema>;
+/**
+ * What one judge answered about a finished call. Held: the rule held. Broken: it did not, and the
+ * reason names the evidence. Deferred: the judge was asked and could not settle it. Skipped:
+ * nobody asked it — no model was reachable inside the call's judging budget.
+ */
+export declare const ScoreVerdictSchema: z.ZodEnum<{
+    held: "held";
+    broken: "broken";
+    deferred: "deferred";
+    skipped: "skipped";
+}>;
+export type ScoreVerdict = z.infer<typeof ScoreVerdictSchema>;
+/**
+ * Cold: the caller is sent on and the agent leaves. Warm: the agent stays on the line until the
+ * other side answers, then leaves.
+ */
+export declare const TransferModeSchema: z.ZodEnum<{
+    cold: "cold";
+    warm: "warm";
+}>;
+export type TransferMode = z.infer<typeof TransferModeSchema>;
+/**
+ * Which region of the prompt a block lives in: static, before the history, cached by the provider;
+ * or dynamic, after the history, replaced every turn. The append-only history in between is never
+ * written by the app.
+ */
+export declare const PromptRegionSchema: z.ZodEnum<{
+    static: "static";
+    dynamic: "dynamic";
+}>;
+export type PromptRegion = z.infer<typeof PromptRegionSchema>;
+/**
+ * How the knowledge base reaches the model: retrieved, the platform runs search itself when the
+ * caller's turn ends; or tool, the model calls search when it decides to. Either way the chunks
+ * arrive as a tool result.
+ */
+export declare const DocsModeSchema: z.ZodEnum<{
+    retrieved: "retrieved";
+    tool: "tool";
+}>;
+export type DocsMode = z.infer<typeof DocsModeSchema>;
+/**
+ * The two tools the platform runs on the app's behalf: recall reads the contact's facts out of
+ * memory, search reads chunks out of the knowledge base. The app declares memory and docs and
+ * writes neither method; the platform runs the lookup, and the answer reaches the model as a tool
+ * result rather than as part of the prompt.
+ */
+export declare const PlatformToolSchema: z.ZodEnum<{
+    recall: "recall";
+    search: "search";
+}>;
+export type PlatformTool = z.infer<typeof PlatformToolSchema>;
+/**
+ * One named block of the prompt and the region it lives in. The default layout, when an agent
+ * declares none, is identity, knowledge and tools (static), then the history, then view (dynamic).
+ * A block's text is written per call with prompt.set.
+ */
+export declare const PromptBlockSpecSchema: z.ZodObject<{
+    name: z.ZodString;
+    region: z.ZodEnum<{
+        static: "static";
+        dynamic: "dynamic";
+    }>;
+}, z.core.$strict>;
+export type PromptBlockSpec = z.infer<typeof PromptBlockSpecSchema>;
+/**
+ * What the platform believes the person on the line is doing right now. The states are the
+ * session's own.
+ */
+export declare const UserStateSchema: z.ZodEnum<{
+    listening: "listening";
+    speaking: "speaking";
+    away: "away";
+}>;
+export type UserState = z.infer<typeof UserStateSchema>;
+/**
+ * What the agent is doing right now, in the session's own words: warming up, waiting, hearing the
+ * caller, generating, or playing audio.
+ */
+export declare const AgentStateSchema: z.ZodEnum<{
+    listening: "listening";
+    speaking: "speaking";
+    initializing: "initializing";
+    idle: "idle";
+    thinking: "thinking";
+}>;
+export type AgentState = z.infer<typeof AgentStateSchema>;
+/**
+ * Who a participant is to the call: the person the agent serves (over SIP or the widget), the
+ * agent itself, a supervisor who took a seat in the room, a listener who only hears, or a second
+ * SIP leg that room.invite brought in.
+ */
+export declare const ParticipantKindSchema: z.ZodEnum<{
+    agent: "agent";
+    caller: "caller";
+    supervisor: "supervisor";
+    listener: "listener";
+    sip: "sip";
+}>;
+export type ParticipantKind = z.infer<typeof ParticipantKindSchema>;
+/** What a track carries: a microphone's audio, a camera's video, or a screen share. */
+export declare const TrackKindSchema: z.ZodEnum<{
+    audio: "audio";
+    video: "video";
+    screen: "screen";
+}>;
+export type TrackKind = z.infer<typeof TrackKindSchema>;
+/** Where a track comes from, as livekit's TrackSource names it, in lower case. */
+export declare const TrackSourceSchema: z.ZodEnum<{
+    unknown: "unknown";
+    microphone: "microphone";
+    camera: "camera";
+    screen_share: "screen_share";
+    screen_share_audio: "screen_share_audio";
+}>;
+export type TrackSource = z.infer<typeof TrackSourceSchema>;
+/**
+ * Where an outside fact came from: the tenant's backend over the app socket (app), or a
+ * participant's browser over the DataChannel (participant).
+ */
+export declare const EventSourceSchema: z.ZodEnum<{
+    app: "app";
+    participant: "participant";
+}>;
+export type EventSource = z.infer<typeof EventSourceSchema>;
+/**
+ * Who may see a field of the app's state: everyone in the call (public), the tenant's own readers
+ * (tenant, the default for a field never declared), or nobody without masking (pii).
+ */
+export declare const VisibilitySchema: z.ZodEnum<{
+    public: "public";
+    tenant: "tenant";
+    pii: "pii";
+}>;
+export type Visibility = z.infer<typeof VisibilitySchema>;
+/**
+ * Which projection a sink applies before a state or an entry leaves the platform: public for a
+ * participant reading its own call, tenant for the tenant's readers. The contract is
+ * docs/protocol/projections.md; a client never applies one.
+ */
+export declare const ProjectionSchema: z.ZodEnum<{
+    public: "public";
+    tenant: "tenant";
+}>;
+export type Projection = z.infer<typeof ProjectionSchema>;
+/**
+ * Who is on the line, as far as the platform knows. Everything is optional: a web visitor may be
+ * nobody yet.
+ */
+export declare const ContactSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    external_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type Contact = z.infer<typeof ContactSchema>;
+/**
+ * One door to an agent: a channel and, for phone and WhatsApp, the number that answers. A number
+ * is a route, never an agent.
+ */
+export declare const RouteSchema: z.ZodObject<{
+    channel: z.ZodEnum<{
+        phone: "phone";
+        web: "web";
+        whatsapp: "whatsapp";
+    }>;
+    number: z.ZodNullable<z.ZodString>;
+    label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type Route = z.infer<typeof RouteSchema>;
+/** The human who sent a supervise verb, as the token that let them in names them. */
+export declare const SupervisorSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type Supervisor = z.infer<typeof SupervisorSchema>;
+/**
+ * What the app declares about one tool: the contract the model sees and the rules the platform
+ * enforces before running it.
+ */
+export declare const ToolSpecSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    side_effect: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        read: "read";
+        write: "write";
+        irreversible: "irreversible";
+    }>>>;
+    confirm: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    pii: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    timeout_s: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strict>;
+export type ToolSpec = z.infer<typeof ToolSpecSchema>;
+/**
+ * What came back from running a tool in the app's process. Either an output or an error, never
+ * both.
+ */
+export declare const ToolResultSchema: z.ZodObject<{
+    call_id: z.ZodString;
+    name: z.ZodString;
+    output: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    summary: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    duration_s: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strict>;
+export type ToolResult = z.infer<typeof ToolResultSchema>;
+/**
+ * One thing remembered about a contact: a sentence, where it came from, and how well it matched
+ * when recalled.
+ */
+export declare const MemoryFactSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    text: z.ZodString;
+    category: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type MemoryFact = z.infer<typeof MemoryFactSchema>;
+/**
+ * One operation against the contact's memory: a recall during the turn, a remember at hangup, or a
+ * forget on request.
+ */
+export declare const MemoryOpSchema: z.ZodObject<{
+    op: z.ZodEnum<{
+        recall: "recall";
+        remember: "remember";
+        forget: "forget";
+    }>;
+    contact: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    query: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    facts: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        text: z.ZodString;
+        category: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>;
+    took_ms: z.ZodNumber;
+}, z.core.$strict>;
+export type MemoryOp = z.infer<typeof MemoryOpSchema>;
+/** One chunk of the knowledge base that retrieval put in front of the model for this turn. */
+export declare const DocSourceSchema: z.ZodObject<{
+    id: z.ZodString;
+    path: z.ZodString;
+    heading: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    score: z.ZodNumber;
+    excerpt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type DocSource = z.infer<typeof DocSourceSchema>;
+/** The exchange rate the cost was computed with, stated so the number can be reproduced. */
+export declare const CostRateSchema: z.ZodObject<{
+    currency: z.ZodLiteral<"EUR">;
+    usd_to_eur: z.ZodNumber;
+    as_of: z.ZodString;
+}, z.core.$strict>;
+export type CostRate = z.infer<typeof CostRateSchema>;
+/** One priced line: a model, what was counted, how much, and what it came to. */
+export declare const CostRowSchema: z.ZodObject<{
+    provider: z.ZodString;
+    model: z.ZodString;
+    unit: z.ZodEnum<{
+        input_tokens: "input_tokens";
+        cached_input_tokens: "cached_input_tokens";
+        cache_creation_tokens: "cache_creation_tokens";
+        output_tokens: "output_tokens";
+        characters: "characters";
+        audio_seconds: "audio_seconds";
+        requests: "requests";
+        session_seconds: "session_seconds";
+    }>;
+    quantity: z.ZodNumber;
+    unit_price_usd: z.ZodNumber;
+    eur: z.ZodNumber;
+}, z.core.$strict>;
+export type CostRow = z.infer<typeof CostRowSchema>;
+/** A usage row the price table does not know. It is listed, never priced at zero. */
+export declare const UnpricedRowSchema: z.ZodObject<{
+    provider: z.ZodString;
+    model: z.ZodString;
+}, z.core.$strict>;
+export type UnpricedRow = z.infer<typeof UnpricedRowSchema>;
+/**
+ * What the call cost in provider fees, informational, in euros. The runtime never prices
+ * commercially; this is the provider's bill as best we know it.
+ */
+export declare const CostSchema: z.ZodObject<{
+    eur: z.ZodNumber;
+    rate: z.ZodObject<{
+        currency: z.ZodLiteral<"EUR">;
+        usd_to_eur: z.ZodNumber;
+        as_of: z.ZodString;
+    }, z.core.$strict>;
+    rows: z.ZodArray<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        unit: z.ZodEnum<{
+            input_tokens: "input_tokens";
+            cached_input_tokens: "cached_input_tokens";
+            cache_creation_tokens: "cache_creation_tokens";
+            output_tokens: "output_tokens";
+            characters: "characters";
+            audio_seconds: "audio_seconds";
+            requests: "requests";
+            session_seconds: "session_seconds";
+        }>;
+        quantity: z.ZodNumber;
+        unit_price_usd: z.ZodNumber;
+        eur: z.ZodNumber;
+    }, z.core.$strict>>;
+    unpriced: z.ZodArray<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type Cost = z.infer<typeof CostSchema>;
+/** Which voice speaks for the agent: the name it was asked for, or the id the provider knows it by. */
+export declare const VoiceConfigSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    provider: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    voice_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type VoiceConfig = z.infer<typeof VoiceConfigSchema>;
+/** Which model does a job (the LLM, or the STT), and the one or two knobs worth turning. */
+export declare const ModelConfigSchema: z.ZodObject<{
+    provider: z.ZodString;
+    model: z.ZodString;
+    temperature: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strict>;
+export type ModelConfig = z.infer<typeof ModelConfigSchema>;
+/** How the session decides that the caller has finished, and when the caller may interrupt. */
+export declare const TurnConfigSchema: z.ZodObject<{
+    min_interruption_words: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    endpointing_ms: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+}, z.core.$strict>;
+export type TurnConfig = z.infer<typeof TurnConfigSchema>;
+/** How the voice says one word it would otherwise get wrong: a proper name, a brand, a street. */
+export declare const PronunciationSchema: z.ZodObject<{
+    word: z.ZodString;
+    spoken: z.ZodString;
+}, z.core.$strict>;
+export type Pronunciation = z.infer<typeof PronunciationSchema>;
+/**
+ * What the app declares about one field of its state: who may see it. A field never declared is
+ * tenant.
+ */
+export declare const StateFieldSpecSchema: z.ZodObject<{
+    name: z.ZodString;
+    visibility: z.ZodEnum<{
+        public: "public";
+        tenant: "tenant";
+        pii: "pii";
+    }>;
+}, z.core.$strict>;
+export type StateFieldSpec = z.infer<typeof StateFieldSpecSchema>;
+/**
+ * One outside event the agent accepts, and from whom. An event nobody declared is refused before
+ * it touches the log.
+ */
+export declare const EventSpecSchema: z.ZodObject<{
+    name: z.ZodString;
+    from: z.ZodArray<z.ZodEnum<{
+        app: "app";
+        participant: "participant";
+    }>>;
+}, z.core.$strict>;
+export type EventSpec = z.infer<typeof EventSpecSchema>;
+/** One file of knowledge, sent whole: its path as the tenant keeps it, and its text. */
+export declare const KnowledgeFileSchema: z.ZodObject<{
+    path: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strict>;
+export type KnowledgeFile = z.infer<typeof KnowledgeFileSchema>;
+/**
+ * The knowledge base the agent answers from, and how its chunks reach the model. It is named by
+ * the base it was pushed under, with PUT /v1/knowledge/{base}.
+ */
+export declare const DocsConfigSchema: z.ZodObject<{
+    base: z.ZodString;
+    mode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        retrieved: "retrieved";
+        tool: "tool";
+    }>>>;
+    k: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    min_score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strict>;
+export type DocsConfig = z.infer<typeof DocsConfigSchema>;
+/**
+ * How the agent opens a call, before the caller has said anything. Exactly one of the two, because
+ * there are only two ways to open one: `say` are the words themselves and `reply` is what the
+ * model is told before it finds its own. They are agent.say and agent.reply declared instead of
+ * called, so a class that opens every call the same way needs no onCall hook to do it, and an
+ * operator can turn the opening at the pipeline door without a deploy. Absent: nobody speaks until
+ * the caller does.
+ */
+export declare const GreetingConfigSchema: z.ZodObject<{
+    say: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    reply: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    allow_interruptions: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strict>;
+export type GreetingConfig = z.infer<typeof GreetingConfigSchema>;
+/**
+ * Whether the model may end the call itself. Declaring this is what puts livekit's own end_call
+ * tool in front of the model; a class that says nothing here cannot hang up, and the call ends
+ * when the caller does or when a supervisor says so. The tool is hidden while the agent is
+ * greeting, because a model that can hang up on its first turn eventually does.
+ */
+export declare const HangupConfigSchema: z.ZodObject<{
+    when: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type HangupConfig = z.infer<typeof HangupConfigSchema>;
+/**
+ * What memory keeps about a contact across calls, and what it must never keep. Both lists are in
+ * the tenant's own words.
+ */
+export declare const MemoryConfigSchema: z.ZodObject<{
+    remember: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    forget: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+}, z.core.$strict>;
+export type MemoryConfig = z.infer<typeof MemoryConfigSchema>;
+/**
+ * What an app declares about its agent: the voice, the models, the language, the greeting, the
+ * tools, and who may see and send what. Every field is optional so a configure can change one
+ * thing.
+ */
+export declare const AgentConfigSchema: z.ZodObject<{
+    prompt: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        region: z.ZodEnum<{
+            static: "static";
+            dynamic: "dynamic";
+        }>;
+    }, z.core.$strict>>>>;
+    language: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    greeting: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        say: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        reply: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        allow_interruptions: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$strict>>>;
+    voice: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        provider: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        voice_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>>;
+    llm: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        temperature: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strict>>>;
+    stt: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        temperature: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strict>>>;
+    turn: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        min_interruption_words: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+        endpointing_ms: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    }, z.core.$strict>>>;
+    says: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        word: z.ZodString;
+        spoken: z.ZodString;
+    }, z.core.$strict>>>>;
+    hears: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    knowledge: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        path: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>>>;
+    docs: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        base: z.ZodString;
+        mode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            retrieved: "retrieved";
+            tool: "tool";
+        }>>>;
+        k: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+        min_score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strict>>>;
+    memory: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        remember: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        forget: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strict>>>;
+    hangup: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        when: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>>;
+    tools: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        side_effect: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            read: "read";
+            write: "write";
+            irreversible: "irreversible";
+        }>>>;
+        confirm: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        pii: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        timeout_s: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strict>>>>;
+    state_fields: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        visibility: z.ZodEnum<{
+            public: "public";
+            tenant: "tenant";
+            pii: "pii";
+        }>;
+    }, z.core.$strict>>>>;
+    events: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        from: z.ZodArray<z.ZodEnum<{
+            app: "app";
+            participant: "participant";
+        }>>;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>;
+export type AgentConfig = z.infer<typeof AgentConfigSchema>;