npm - @pinecall/protocol - Versions diffs - 0.1.0 - Mend

@pinecall/protocol 0.1.0

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

Files changed (34) hide show

package/LICENSE +202 -0
package/dist/fixtures/call-log-golden.json +127 -0
package/dist/fixtures/call-log-golden.state.json +39 -0
package/dist/generated/codec.d.ts +53 -0
package/dist/generated/codec.js +67 -0
package/dist/generated/commands.d.ts +423 -0
package/dist/generated/commands.js +168 -0
package/dist/generated/defs.d.ts +604 -0
package/dist/generated/defs.js +328 -0
package/dist/generated/envelope.d.ts +27 -0
package/dist/generated/envelope.js +26 -0
package/dist/generated/events.d.ts +1234 -0
package/dist/generated/events.js +388 -0
package/dist/generated/index.d.ts +12 -0
package/dist/generated/index.js +13 -0
package/dist/generated/metrics.d.ts +386 -0
package/dist/generated/metrics.js +268 -0
package/dist/generated/registry.d.ts +1591 -0
package/dist/generated/registry.js +130 -0
package/dist/generated/rest.d.ts +1031 -0
package/dist/generated/rest.js +291 -0
package/dist/generated/room.d.ts +111 -0
package/dist/generated/room.js +72 -0
package/dist/generated/state.d.ts +902 -0
package/dist/generated/state.js +179 -0
package/dist/generated/units.d.ts +2 -0
package/dist/generated/units.js +80 -0
package/dist/generated/verbs.d.ts +77 -0
package/dist/generated/verbs.js +49 -0
package/dist/index.d.ts +2 -0
package/dist/index.js +3 -0
package/dist/reduce.d.ts +10 -0
package/dist/reduce.js +352 -0
package/package.json +38 -0

package/dist/generated/codec.d.ts ADDED Viewed

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { type Command, type Entry } from "./envelope.js";
+import { COMMAND_SCHEMAS, EVENT_SCHEMAS, type CommandType, type EventType } from "./registry.js";
+export declare class ProtocolError extends Error {
+    readonly name = "ProtocolError";
+}
+/** The data shape of one event type. */
+export type EventData<K extends EventType> = z.infer<(typeof EVENT_SCHEMAS)[K]>;
+/** One event, typed by its type: switch on `type` and `data` narrows with it. */
+export type Event = {
+    [K in EventType]: {
+        type: K;
+        data: EventData<K>;
+    };
+}[EventType];
+/** The data shape of one command type. */
+export type CommandData<K extends CommandType> = z.infer<(typeof COMMAND_SCHEMAS)[K]>;
+/** One command, typed by its type. */
+export type AnyCommand = {
+    [K in CommandType]: {
+        type: K;
+        data: CommandData<K>;
+    };
+}[CommandType];
+/** One log line from decoded JSON. A bad shape throws. */
+export declare function decodeEntry(raw: unknown): Entry;
+/** A whole log from a JSON array text, in the order it came. */
+export declare function decodeEntries(text: string): Entry[];
+/** The entry's data as the shape its type names. An unknown type or a bad shape throws. */
+export declare function eventOf(entry: Entry): Event;
+/** The command's data as the shape its type names. An unknown type or a bad shape throws. */
+export declare function commandOf(command: Command): AnyCommand;
+export declare function isEventType(type: string): type is EventType;
+export declare function isCommandType(type: string): type is CommandType;
+/** "llm_node_ttft" as a type becomes "llmNodeTtft". */
+export type CamelCase<S extends string> = S extends `${infer Head}_${infer Tail}` ? `${Head}${Capitalize<CamelCase<Tail>>}` : S;
+/** "llmNodeTtft" as a type becomes "llm_node_ttft". */
+export type SnakeCase<S extends string> = S extends `${infer Head}${infer Tail}` ? Head extends Lowercase<Head> ? `${Head}${SnakeCase<Tail>}` : `_${Lowercase<Head>}${SnakeCase<Tail>}` : S;
+/** A wire shape with every key camelCased, deep, except under the opaque keys. */
+export type Camel<T> = T extends readonly (infer Item)[] ? Camel<Item>[] : T extends object ? {
+    [K in keyof T as K extends string ? CamelCase<K> : K]: K extends OpaqueKey ? T[K] : Camel<T[K]>;
+} : T;
+/** A camelCased shape back to the wire's keys, deep, except under the opaque keys. */
+export type Snake<T> = T extends readonly (infer Item)[] ? Snake<Item>[] : T extends object ? {
+    [K in keyof T as K extends string ? SnakeCase<K> : K]: K extends OpaqueKey ? T[K] : Snake<T[K]>;
+} : T;
+/** The keys whose values belong to the app (its state, a tool's arguments, a map it named): never renamed below them. */
+export declare const OPAQUE_KEYS: Set<string>;
+export type OpaqueKey = "app_state" | "arguments" | "attributes" | "data" | "input" | "metadata" | "output" | "parameters" | "prompt" | "result" | "state";
+/** Rename every key from snake_case to camelCase, deep. Values are never touched. */
+export declare function toCamel<T>(value: T): Camel<T>;
+/** Rename every key from camelCase to snake_case, deep. Values are never touched. */
+export declare function toSnake<T>(value: T): Snake<T>;

package/dist/generated/codec.js ADDED Viewed

@@ -0,0 +1,67 @@
+// The wire, decoded and typed. The only file that touches a key name: snake_case on the wire,
+// camelCase for whoever wants it. Never edited by hand.
+import { z } from "zod";
+import { EntrySchema } from "./envelope.js";
+import { COMMAND_SCHEMAS, EVENT_SCHEMAS } from "./registry.js";
+export class ProtocolError extends Error {
+    name = "ProtocolError";
+}
+/** One log line from decoded JSON. A bad shape throws. */
+export function decodeEntry(raw) {
+    return EntrySchema.parse(raw);
+}
+/** A whole log from a JSON array text, in the order it came. */
+export function decodeEntries(text) {
+    return z.array(EntrySchema).parse(JSON.parse(text));
+}
+/** The entry's data as the shape its type names. An unknown type or a bad shape throws. */
+export function eventOf(entry) {
+    if (!isEventType(entry.type)) {
+        throw new ProtocolError(`unknown event type: ${entry.type}`);
+    }
+    const data = EVENT_SCHEMAS[entry.type].parse(entry.data);
+    return { type: entry.type, data };
+}
+/** The command's data as the shape its type names. An unknown type or a bad shape throws. */
+export function commandOf(command) {
+    if (!isCommandType(command.type)) {
+        throw new ProtocolError(`unknown command type: ${command.type}`);
+    }
+    const data = COMMAND_SCHEMAS[command.type].parse(command.data);
+    return { type: command.type, data };
+}
+export function isEventType(type) {
+    return Object.hasOwn(EVENT_SCHEMAS, type);
+}
+export function isCommandType(type) {
+    return Object.hasOwn(COMMAND_SCHEMAS, type);
+}
+/** The keys whose values belong to the app (its state, a tool's arguments, a map it named): never renamed below them. */
+export const OPAQUE_KEYS = new Set(["app_state", "arguments", "attributes", "data", "input", "metadata", "output", "parameters", "prompt", "result", "state"]);
+/** Rename every key from snake_case to camelCase, deep. Values are never touched. */
+export function toCamel(value) {
+    return renameKeys(value, camelCase);
+}
+/** Rename every key from camelCase to snake_case, deep. Values are never touched. */
+export function toSnake(value) {
+    return renameKeys(value, snakeCase);
+}
+function renameKeys(value, rename) {
+    if (Array.isArray(value)) {
+        return value.map((item) => renameKeys(item, rename));
+    }
+    if (value === null || typeof value !== "object") {
+        return value;
+    }
+    const renamed = {};
+    for (const [key, inner] of Object.entries(value)) {
+        renamed[rename(key)] = OPAQUE_KEYS.has(key) ? inner : renameKeys(inner, rename);
+    }
+    return renamed;
+}
+function camelCase(key) {
+    return key.replace(/_([a-z0-9])/g, (_, letter) => letter.toUpperCase());
+}
+function snakeCase(key) {
+    return key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}

package/dist/generated/commands.d.ts ADDED Viewed

@@ -0,0 +1,423 @@
+import { z } from "zod";
+/**
+ * Declare or change what the agent is: voice, models, language, greeting, the full tool list. Only
+ * the fields sent change.
+ */
+export declare const AgentConfigureSchema: z.ZodObject<{
+    config: 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>;
+}, z.core.$strict>;
+export type AgentConfigure = z.infer<typeof AgentConfigureSchema>;
+/**
+ * The app's first message: this socket speaks for this agent and answers these doors. The gateway
+ * answers agent.registered, or error.
+ */
+export declare const AgentRegisterSchema: z.ZodObject<{
+    routes: z.ZodArray<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>>;
+    sdk: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    takes_unclaimed: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strict>;
+export type AgentRegister = z.infer<typeof AgentRegisterSchema>;
+/**
+ * Make the model speak now, guided by an instruction it reads and the caller never hears: 'tell
+ * them a slot at 10:15 just opened'. On livekit's session.generate_reply; the sibling of
+ * agent.say, which speaks verbatim. The reply lands as turn.agent.
+ */
+export declare const AgentReplySchema: z.ZodObject<{
+    instructions: z.ZodString;
+    allow_interruptions: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strict>;
+export type AgentReply = z.infer<typeof AgentReplySchema>;
+/**
+ * Make the agent say this text now, verbatim, outside the model's turn: a greeting, a read-back, a
+ * system notice. The reply lands as turn.agent.
+ */
+export declare const AgentSaySchema: z.ZodObject<{
+    text: z.ZodString;
+    allow_interruptions: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strict>;
+export type AgentSay = z.infer<typeof AgentSaySchema>;
+/**
+ * Place an outbound call as this agent. The new call's log opens with call.dialing; call.started
+ * follows when the far end answers.
+ */
+export declare const CallDialSchema: z.ZodObject<{
+    to: z.ZodString;
+    from: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    caller: z.ZodOptional<z.ZodNullable<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>>>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strict>;
+export type CallDial = z.infer<typeof CallDialSchema>;
+/** Send touch tones down the line, for an IVR on the far end. */
+export declare const CallDtmfSchema: z.ZodObject<{
+    digits: z.ZodString;
+}, z.core.$strict>;
+export type CallDtmf = z.infer<typeof CallDtmfSchema>;
+/**
+ * Hand the agent a fact from the tenant's backend: a slot freed, an order shipped, a payment
+ * confirmed. Lands as event.received with source app. The agent must have declared the name in its
+ * events with app among the senders, or the gateway answers error and nothing touches the log.
+ */
+export declare const CallEventSchema: z.ZodObject<{
+    name: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>;
+export type CallEvent = z.infer<typeof CallEventSchema>;
+/** End the call from the app's side. call.ended follows with reason agent_hung_up. */
+export declare const CallHangupSchema: z.ZodObject<{
+    reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type CallHangup = z.infer<typeof CallHangupSchema>;
+/** Put the caller on hold: they hear hold audio, the agent hears nothing. */
+export declare const CallHoldSchema: z.ZodObject<{}, z.core.$strict>;
+export type CallHold = z.infer<typeof CallHoldSchema>;
+/**
+ * Write a line of the app's own into the call's log. It gets a seq like everything else and lands
+ * as custom.
+ */
+export declare const CallLogSchema: z.ZodObject<{
+    name: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>;
+export type CallLog = z.infer<typeof CallLogSchema>;
+/** Mute the agent: it keeps listening and thinking, produces no audio. */
+export declare const CallMuteSchema: z.ZodObject<{}, z.core.$strict>;
+export type CallMute = z.infer<typeof CallMuteSchema>;
+/** Send the caller to another number. call.transferred says whether it worked. */
+export declare const CallTransferSchema: z.ZodObject<{
+    to: z.ZodString;
+    mode: z.ZodEnum<{
+        cold: "cold";
+        warm: "warm";
+    }>;
+}, z.core.$strict>;
+export type CallTransfer = z.infer<typeof CallTransferSchema>;
+/** Take the caller off hold. */
+export declare const CallUnholdSchema: z.ZodObject<{}, z.core.$strict>;
+export type CallUnhold = z.infer<typeof CallUnholdSchema>;
+/** Unmute the agent. */
+export declare const CallUnmuteSchema: z.ZodObject<{}, z.core.$strict>;
+export type CallUnmute = z.infer<typeof CallUnmuteSchema>;
+/**
+ * Why the verb did not run, in the words the console shows: the status it travels under, and the
+ * sentence.
+ */
+export declare const DevRefusalSchema: z.ZodObject<{
+    status: z.ZodInt;
+    detail: z.ZodString;
+}, z.core.$strict>;
+export type DevRefusal = z.infer<typeof DevRefusalSchema>;
+/** What came of one dev.request, named by its id. */
+export declare const DevAnswerSchema: z.ZodObject<{
+    id: z.ZodString;
+    result: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    refused: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        status: z.ZodInt;
+        detail: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type DevAnswer = z.infer<typeof DevAnswerSchema>;
+/**
+ * Silence a participant for the rest of the call: their audio leaves the room, for everyone in it.
+ * Lands as track.unpublished for their microphone. There is no unmute; a leg that must speak again
+ * is invited again.
+ */
+export declare const ParticipantMuteSchema: z.ZodObject<{
+    identity: z.ZodString;
+}, z.core.$strict>;
+export type ParticipantMute = z.infer<typeof ParticipantMuteSchema>;
+/**
+ * Put a participant out of the room. Lands as participant.left with reason participant_removed.
+ * Removing the caller ends the call.
+ */
+export declare const ParticipantRemoveSchema: z.ZodObject<{
+    identity: z.ZodString;
+}, z.core.$strict>;
+export type ParticipantRemove = z.infer<typeof ParticipantRemoveSchema>;
+/** Is the socket alive? The gateway answers pong. */
+export declare const PingSchema: z.ZodObject<{}, z.core.$strict>;
+export type Ping = z.infer<typeof PingSchema>;
+/**
+ * Rewrite one block of the prompt, whole, by name. The name must be one of the agent's declared
+ * blocks, or one of the default four; anything else is refused with the name.
+ */
+export declare const PromptSetSchema: z.ZodObject<{
+    name: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strict>;
+export type PromptSet = z.infer<typeof PromptSetSchema>;
+/**
+ * Bring somebody else into the call's room. A second SIP leg dialed to a number is the warm path:
+ * the agent stays on with the caller while the other side answers. Lands as participant.joined
+ * when they arrive, or error when they do not.
+ */
+export declare const RoomInviteSchema: z.ZodObject<{
+    to: z.ZodString;
+    kind: z.ZodEnum<{
+        sip: "sip";
+        participant: "participant";
+    }>;
+}, z.core.$strict>;
+export type RoomInvite = z.infer<typeof RoomInviteSchema>;
+/**
+ * Push a payload to a browser in the room over the DataChannel: a card to render, a form to open.
+ * Lands as room.sent with the size, never the payload. The widget listens on pinecall.ui; a topic
+ * of the tenant's own reaches the tenant's own page code.
+ */
+export declare const RoomSendSchema: z.ZodObject<{
+    topic: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    to: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type RoomSend = z.infer<typeof RoomSendSchema>;
+/**
+ * Set up this one call before the first turn: the app's initial state, and any config that differs
+ * from the agent's defaults for this caller.
+ */
+export declare const SessionConfigureSchema: z.ZodObject<{
+    state: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    config: z.ZodOptional<z.ZodNullable<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>>>;
+}, z.core.$strict>;
+export type SessionConfigure = z.infer<typeof SessionConfigureSchema>;
+/** The app's state changed and this is all of it. The platform logs state.changed and re-renders. */
+export declare const StateSetSchema: z.ZodObject<{
+    state: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    changed: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+}, z.core.$strict>;
+export type StateSet = z.infer<typeof StateSetSchema>;
+/** One supervise verb, from the human the door named. */
+export declare const SupervisorVerbSchema: z.ZodObject<{
+    by: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>;
+    verb: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        verb: z.ZodLiteral<"say">;
+        text: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        verb: z.ZodLiteral<"whisper">;
+        text: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        verb: z.ZodLiteral<"takeover">;
+    }, z.core.$strict>, z.ZodObject<{
+        verb: z.ZodLiteral<"release">;
+    }, z.core.$strict>, z.ZodObject<{
+        verb: z.ZodLiteral<"transfer">;
+        to: z.ZodString;
+        mode: z.ZodEnum<{
+            cold: "cold";
+            warm: "warm";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        verb: z.ZodLiteral<"end">;
+        reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>], "verb">;
+}, z.core.$strict>;
+export type SupervisorVerb = z.infer<typeof SupervisorVerbSchema>;
+/**
+ * The tools the model may see now. The full list was declared in agent.configure; this is the
+ * subset whose when allows them in this state.
+ */
+export declare const ToolsSetSchema: z.ZodObject<{
+    tools: 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>>;
+}, z.core.$strict>;
+export type ToolsSet = z.infer<typeof ToolsSetSchema>;