@pinecall/protocol 0.3.0 → 0.5.0

package/dist/generated/commands.d.ts

@@ -46,6 +46,10 @@ export declare const AgentConfigureSchema: z.ZodObject<{
         knowledge: z.ZodOptional<z.ZodNullable<z.ZodObject<{
             path: z.ZodString;
             text: z.ZodString;
+            mode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                retrieved: "retrieved";
+                whole: "whole";
+            }>>>;
         }, z.core.$strict>>>;
         docs: z.ZodOptional<z.ZodNullable<z.ZodObject<{
             base: z.ZodString;
@@ -76,6 +80,7 @@ export declare const AgentConfigureSchema: z.ZodObject<{
             pii: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
             timeout_s: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         }, z.core.$strict>>>>;
+        uses_knowledge: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
         state_fields: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
             name: z.ZodString;
             visibility: z.ZodEnum<{
@@ -109,6 +114,7 @@ export declare const AgentRegisterSchema: z.ZodObject<{
         label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strict>>;
     sdk: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    host: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     takes_unclaimed: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
 }, z.core.$strict>;
 export type AgentRegister = z.infer<typeof AgentRegisterSchema>;
@@ -318,6 +324,10 @@ export declare const SessionConfigureSchema: z.ZodObject<{
         knowledge: z.ZodOptional<z.ZodNullable<z.ZodObject<{
             path: z.ZodString;
             text: z.ZodString;
+            mode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                retrieved: "retrieved";
+                whole: "whole";
+            }>>>;
         }, z.core.$strict>>>;
         docs: z.ZodOptional<z.ZodNullable<z.ZodObject<{
             base: z.ZodString;
@@ -348,6 +358,7 @@ export declare const SessionConfigureSchema: z.ZodObject<{
             pii: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
             timeout_s: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         }, z.core.$strict>>>>;
+        uses_knowledge: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
         state_fields: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
             name: z.ZodString;
             visibility: z.ZodEnum<{

package/dist/generated/commands.js

@@ -16,6 +16,7 @@ export const AgentConfigureSchema = z.strictObject({
 export const AgentRegisterSchema = z.strictObject({
     routes: z.array(RouteSchema),
     sdk: z.string().nullish(),
+    host: z.string().nullish(),
     takes_unclaimed: z.boolean().nullish(),
 });
 /**

package/dist/generated/defs.d.ts

@@ -459,6 +459,10 @@ export type EventSpec = z.infer<typeof EventSpecSchema>;
 export declare const KnowledgeFileSchema: z.ZodObject<{
     path: z.ZodString;
     text: z.ZodString;
+    mode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        retrieved: "retrieved";
+        whole: "whole";
+    }>>>;
 }, z.core.$strict>;
 export type KnowledgeFile = z.infer<typeof KnowledgeFileSchema>;
 /**
@@ -555,6 +559,10 @@ export declare const AgentConfigSchema: z.ZodObject<{
     knowledge: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         path: z.ZodString;
         text: z.ZodString;
+        mode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            retrieved: "retrieved";
+            whole: "whole";
+        }>>>;
     }, z.core.$strict>>>;
     docs: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         base: z.ZodString;
@@ -585,6 +593,7 @@ export declare const AgentConfigSchema: z.ZodObject<{
         pii: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
         timeout_s: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     }, z.core.$strict>>>>;
+    uses_knowledge: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
     state_fields: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         visibility: z.ZodEnum<{

package/dist/generated/defs.js

@@ -262,6 +262,7 @@ export const EventSpecSchema = z.strictObject({
 export const KnowledgeFileSchema = z.strictObject({
     path: z.string(),
     text: z.string(),
+    mode: z.enum(["retrieved", "whole"]).nullish(),
 });
 /**
  * The knowledge base the agent answers from, and how its chunks reach the model. It is named by
@@ -323,6 +324,7 @@ export const AgentConfigSchema = z.strictObject({
     memory: MemoryConfigSchema.nullish(),
     hangup: HangupConfigSchema.nullish(),
     tools: z.array(ToolSpecSchema).nullish(),
+    uses_knowledge: z.boolean().nullish(),
     state_fields: z.array(StateFieldSpecSchema).nullish(),
     events: z.array(EventSpecSchema).nullish(),
 });

package/dist/generated/registry.d.ts

@@ -1305,6 +1305,10 @@ export declare const COMMAND_SCHEMAS: {
             knowledge: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodObject<{
                 path: import("zod").ZodString;
                 text: import("zod").ZodString;
+                mode: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodEnum<{
+                    retrieved: "retrieved";
+                    whole: "whole";
+                }>>>;
             }, import("zod/v4/core").$strict>>>;
             docs: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodObject<{
                 base: import("zod").ZodString;
@@ -1335,6 +1339,7 @@ export declare const COMMAND_SCHEMAS: {
                 pii: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodArray<import("zod").ZodString>>>;
                 timeout_s: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
             }, import("zod/v4/core").$strict>>>>;
+            uses_knowledge: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
             state_fields: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodArray<import("zod").ZodObject<{
                 name: import("zod").ZodString;
                 visibility: import("zod").ZodEnum<{
@@ -1363,6 +1368,7 @@ export declare const COMMAND_SCHEMAS: {
             label: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
         }, import("zod/v4/core").$strict>>;
         sdk: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        host: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
         takes_unclaimed: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
     }, import("zod/v4/core").$strict>;
     readonly "agent.reply": import("zod").ZodObject<{
@@ -1485,6 +1491,10 @@ export declare const COMMAND_SCHEMAS: {
             knowledge: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodObject<{
                 path: import("zod").ZodString;
                 text: import("zod").ZodString;
+                mode: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodEnum<{
+                    retrieved: "retrieved";
+                    whole: "whole";
+                }>>>;
             }, import("zod/v4/core").$strict>>>;
             docs: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodObject<{
                 base: import("zod").ZodString;
@@ -1515,6 +1525,7 @@ export declare const COMMAND_SCHEMAS: {
                 pii: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodArray<import("zod").ZodString>>>;
                 timeout_s: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
             }, import("zod/v4/core").$strict>>>>;
+            uses_knowledge: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
             state_fields: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodArray<import("zod").ZodObject<{
                 name: import("zod").ZodString;
                 visibility: import("zod").ZodEnum<{

package/dist/generated/rest.d.ts

@@ -1128,6 +1128,59 @@ export declare const AgentListSchema: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type AgentList = z.infer<typeof AgentListSchema>;
+/**
+ * One app connected to the gateway right now: one process on one machine, holding one or more
+ * agents in one world.
+ */
+export declare const AppProcessSchema: z.ZodObject<{
+    app: z.ZodString;
+    agents: z.ZodArray<z.ZodString>;
+    env: z.ZodEnum<{
+        production: "production";
+        sandbox: "sandbox";
+    }>;
+    host: z.ZodNullable<z.ZodString>;
+    address: z.ZodNullable<z.ZodString>;
+    sdk: z.ZodNullable<z.ZodString>;
+    holder: z.ZodNullable<z.ZodObject<{
+        holder: z.ZodNullable<z.ZodString>;
+        name: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    connected_at: z.ZodNumber;
+}, z.core.$strict>;
+export type AppProcess = z.infer<typeof AppProcessSchema>;
+/**
+ * GET /v1/apps: every app connected in the request's world that this key may see — its own
+ * corner's and the org's, every corner's with `team`.
+ */
+export declare const AppListSchema: z.ZodObject<{
+    apps: z.ZodArray<z.ZodObject<{
+        app: z.ZodString;
+        agents: z.ZodArray<z.ZodString>;
+        env: z.ZodEnum<{
+            production: "production";
+            sandbox: "sandbox";
+        }>;
+        host: z.ZodNullable<z.ZodString>;
+        address: z.ZodNullable<z.ZodString>;
+        sdk: z.ZodNullable<z.ZodString>;
+        holder: z.ZodNullable<z.ZodObject<{
+            holder: z.ZodNullable<z.ZodString>;
+            name: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        connected_at: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type AppList = z.infer<typeof AppListSchema>;
+/**
+ * POST /v1/apps/{app}/stop, the answer: the socket was closed with the stop code, and the app
+ * exits rather than reconnect.
+ */
+export declare const AppStoppedSchema: z.ZodObject<{
+    app: z.ZodString;
+    stopped: z.ZodBoolean;
+}, z.core.$strict>;
+export type AppStopped = z.infer<typeof AppStoppedSchema>;
 /**
  * GET /v1/agents/{slug}/line: whose terminal a call that RINGS at this agent's doors lands in. An
  * org shares one sandbox number, so it rings in one place and which one is claimed.
@@ -1159,6 +1212,10 @@ export declare const KnowledgePushSchema: z.ZodObject<{
     files: z.ZodArray<z.ZodObject<{
         path: z.ZodString;
         text: z.ZodString;
+        mode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            retrieved: "retrieved";
+            whole: "whole";
+        }>>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type KnowledgePush = z.infer<typeof KnowledgePushSchema>;
@@ -1212,13 +1269,15 @@ export declare const KnowledgeScoreSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type KnowledgeScore = z.infer<typeof KnowledgeScoreSchema>;
 /**
- * PUT /v1/knowledge/{base}, the answer: which base, how many chunks it became, and how long that
- * took.
+ * PUT /v1/knowledge/{base}, the answer: which base, how many chunks it became, how long that took,
+ * and what its whole files weigh on every call.
  */
 export declare const KnowledgePushedSchema: z.ZodObject<{
     base: z.ZodString;
     chunks: z.ZodInt;
     took_ms: z.ZodNumber;
+    whole_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    notice: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
 }, z.core.$strict>;
 export type KnowledgePushed = z.infer<typeof KnowledgePushedSchema>;
 /** One knowledge base as the list draws it: its name, its size, and when it was last pushed. */
@@ -1437,8 +1496,9 @@ export declare const ExtractionRunSchema: z.ZodObject<{
 export type ExtractionRun = z.infer<typeof ExtractionRunSchema>;
 /**
  * POST /v1/calls/{call}/lookup, the body: which platform tool to run for this turn, and what to
- * run it with. Worker-only; the gateway runs it against its own stores and writes memory.ops or
- * docs.sources on the call's log itself.
+ * run it with. Asked by the worker for the call it serves, and by the app for a call of its own
+ * org — `this.knowledge.search` in a tool; the gateway runs it against its own stores and writes
+ * memory.ops or docs.sources on the call's log itself.
  */
 export declare const LookupRequestSchema: z.ZodObject<{
     tool: z.ZodEnum<{
@@ -1459,6 +1519,25 @@ export declare const LookupResultSchema: z.ZodObject<{
     took_ms: z.ZodNumber;
 }, z.core.$strict>;
 export type LookupResult = z.infer<typeof LookupResultSchema>;
+/** One chunk search found: the file it came from, the heading it sits under, and its text. */
+export declare const FoundChunkSchema: z.ZodObject<{
+    path: z.ZodString;
+    heading: z.ZodNullable<z.ZodString>;
+    text: z.ZodString;
+}, z.core.$strict>;
+export type FoundChunk = z.infer<typeof FoundChunkSchema>;
+/**
+ * What search answers in a lookup's output: the best chunks of every base the agent reads, the
+ * best first. The app's `this.knowledge.search` hands the chunks to the tool that asked.
+ */
+export declare const SearchFoundSchema: z.ZodObject<{
+    chunks: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        heading: z.ZodNullable<z.ZodString>;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SearchFound = z.infer<typeof SearchFoundSchema>;
 /**
  * POST /v1/calls/{call}/remember, the answer: what the call taught about the contact, counted.
  * Worker-only; the body is empty, the gateway reads the turns off its own log and writes
@@ -1518,3 +1597,595 @@ export declare const OutboundProvisionedSchema: z.ZodObject<{
     address: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strict>;
 export type OutboundProvisioned = z.infer<typeof OutboundProvisionedSchema>;
+/**
+ * An agent's tuning: what the org set over what the app declared, per world and per corner. Every
+ * field is optional; one left out is not set, and what the app declared — or the runtime's own
+ * default — stands for it.
+ */
+export declare const TuningBodySchema: z.ZodObject<{
+    voice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tts: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tts_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    stt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    llm: 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>>>;
+    hangup: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        when: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, 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>>>;
+    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>>>;
+    knowledge: z.ZodOptional<z.ZodNullable<z.ZodArray<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>>>>;
+}, z.core.$strict>;
+export type TuningBody = z.infer<typeof TuningBodySchema>;
+/**
+ * One kept version of an agent's tuning: whose corner, which version, who set it and when, and
+ * what it says.
+ */
+export declare const TuningRowSchema: z.ZodObject<{
+    holder: z.ZodString;
+    version: z.ZodInt;
+    author: z.ZodString;
+    note: z.ZodNullable<z.ZodString>;
+    set_at: z.ZodNumber;
+    config: z.ZodObject<{
+        voice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        tts: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        tts_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        stt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        llm: 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>>>;
+        hangup: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            when: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, 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>>>;
+        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>>>;
+        knowledge: z.ZodOptional<z.ZodNullable<z.ZodArray<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>>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type TuningRow = z.infer<typeof TuningRowSchema>;
+/**
+ * GET /v1/agents/{slug}/settings: the agent's tuning as this key sees it — its own corner's, the
+ * team's and production's, each corner's own newest row, or null when that corner set nothing.
+ */
+export declare const TuningAnswerSchema: z.ZodObject<{
+    world: z.ZodEnum<{
+        production: "production";
+        sandbox: "sandbox";
+    }>;
+    yours: z.ZodNullable<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        config: z.ZodObject<{
+            voice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            stt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            llm: 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>>>;
+            hangup: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                when: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, 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>>>;
+            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>>>;
+            knowledge: z.ZodOptional<z.ZodNullable<z.ZodArray<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>>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    team: z.ZodNullable<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        config: z.ZodObject<{
+            voice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            stt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            llm: 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>>>;
+            hangup: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                when: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, 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>>>;
+            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>>>;
+            knowledge: z.ZodOptional<z.ZodNullable<z.ZodArray<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>>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    production: z.ZodNullable<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        config: z.ZodObject<{
+            voice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            stt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            llm: 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>>>;
+            hangup: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                when: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, 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>>>;
+            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>>>;
+            knowledge: z.ZodOptional<z.ZodNullable<z.ZodArray<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>>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type TuningAnswer = z.infer<typeof TuningAnswerSchema>;
+/**
+ * PUT /v1/agents/{slug}/settings, the body: the whole set, the version it was read at, why, and
+ * whose corner.
+ */
+export declare const TuningPutSchema: z.ZodObject<{
+    config: z.ZodObject<{
+        voice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        tts: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        tts_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        stt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        llm: 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>>>;
+        hangup: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            when: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, 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>>>;
+        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>>>;
+        knowledge: z.ZodOptional<z.ZodNullable<z.ZodArray<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>>>>;
+    }, z.core.$strict>;
+    if_version: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodInt>>>;
+    note: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+    team: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strict>;
+export type TuningPut = z.infer<typeof TuningPutSchema>;
+/** GET /v1/agents/{slug}/settings/history: one corner's versions, newest first. */
+export declare const TuningHistorySchema: z.ZodObject<{
+    world: z.ZodEnum<{
+        production: "production";
+        sandbox: "sandbox";
+    }>;
+    holder: z.ZodString;
+    rows: z.ZodArray<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        config: z.ZodObject<{
+            voice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            stt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            llm: 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>>>;
+            hangup: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                when: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, 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>>>;
+            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>>>;
+            knowledge: z.ZodOptional<z.ZodNullable<z.ZodArray<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>>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type TuningHistory = z.infer<typeof TuningHistorySchema>;
+/**
+ * GET /v1/agents/{slug}/settings/diff: what this key's corner reads against another corner's
+ * newest, and which fields differ.
+ */
+export declare const TuningDiffSchema: z.ZodObject<{
+    ours: z.ZodNullable<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        config: z.ZodObject<{
+            voice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            stt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            llm: 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>>>;
+            hangup: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                when: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, 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>>>;
+            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>>>;
+            knowledge: z.ZodOptional<z.ZodNullable<z.ZodArray<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>>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    theirs: z.ZodNullable<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        config: z.ZodObject<{
+            voice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            stt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            llm: 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>>>;
+            hangup: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                when: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, 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>>>;
+            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>>>;
+            knowledge: z.ZodOptional<z.ZodNullable<z.ZodArray<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>>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    changed: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type TuningDiff = z.infer<typeof TuningDiffSchema>;
+/**
+ * POST /v1/agents/{slug}/settings/rollback, the body: which version to bring back. It comes back
+ * as a NEW version; nothing is deleted.
+ */
+export declare const RollbackSchema: z.ZodObject<{
+    version: z.ZodInt;
+    team: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strict>;
+export type Rollback = z.infer<typeof RollbackSchema>;
+/**
+ * The org's lexicon: how the voice says the words it would get wrong, and the words the ears must
+ * know. Shared by every agent of the org, laid over each one's own says and hears.
+ */
+export declare const LexiconBodySchema: z.ZodObject<{
+    said: z.ZodArray<z.ZodObject<{
+        word: z.ZodString;
+        spoken: z.ZodString;
+    }, z.core.$strict>>;
+    heard: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type LexiconBody = z.infer<typeof LexiconBodySchema>;
+/** One kept version of the org's lexicon. */
+export declare const LexiconRowSchema: z.ZodObject<{
+    holder: z.ZodString;
+    version: z.ZodInt;
+    author: z.ZodString;
+    note: z.ZodNullable<z.ZodString>;
+    set_at: z.ZodNumber;
+    lexicon: z.ZodObject<{
+        said: z.ZodArray<z.ZodObject<{
+            word: z.ZodString;
+            spoken: z.ZodString;
+        }, z.core.$strict>>;
+        heard: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type LexiconRow = z.infer<typeof LexiconRowSchema>;
+/**
+ * GET /v1/lexicon: the org's words as this key sees them — its own corner's, the team's and
+ * production's, each corner's own newest, or null.
+ */
+export declare const LexiconAnswerSchema: z.ZodObject<{
+    world: z.ZodEnum<{
+        production: "production";
+        sandbox: "sandbox";
+    }>;
+    yours: z.ZodNullable<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        lexicon: z.ZodObject<{
+            said: z.ZodArray<z.ZodObject<{
+                word: z.ZodString;
+                spoken: z.ZodString;
+            }, z.core.$strict>>;
+            heard: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    team: z.ZodNullable<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        lexicon: z.ZodObject<{
+            said: z.ZodArray<z.ZodObject<{
+                word: z.ZodString;
+                spoken: z.ZodString;
+            }, z.core.$strict>>;
+            heard: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    production: z.ZodNullable<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        lexicon: z.ZodObject<{
+            said: z.ZodArray<z.ZodObject<{
+                word: z.ZodString;
+                spoken: z.ZodString;
+            }, z.core.$strict>>;
+            heard: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type LexiconAnswer = z.infer<typeof LexiconAnswerSchema>;
+/** PUT /v1/lexicon, the body: the whole lexicon, the version it was read at, why, and whose corner. */
+export declare const LexiconPutSchema: z.ZodObject<{
+    lexicon: z.ZodObject<{
+        said: z.ZodArray<z.ZodObject<{
+            word: z.ZodString;
+            spoken: z.ZodString;
+        }, z.core.$strict>>;
+        heard: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    if_version: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodInt>>>;
+    note: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+    team: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strict>;
+export type LexiconPut = z.infer<typeof LexiconPutSchema>;
+/** GET /v1/lexicon/history: one corner's versions, newest first. */
+export declare const LexiconHistorySchema: z.ZodObject<{
+    world: z.ZodEnum<{
+        production: "production";
+        sandbox: "sandbox";
+    }>;
+    holder: z.ZodString;
+    rows: z.ZodArray<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        lexicon: z.ZodObject<{
+            said: z.ZodArray<z.ZodObject<{
+                word: z.ZodString;
+                spoken: z.ZodString;
+            }, z.core.$strict>>;
+            heard: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type LexiconHistory = z.infer<typeof LexiconHistorySchema>;
+/**
+ * GET /v1/calls/{call}/settings: the exact tuning and lexicon a call was built on, by the versions
+ * its head row recorded.
+ */
+export declare const CallTuningSchema: z.ZodObject<{
+    config_version: z.ZodNullable<z.ZodInt>;
+    lexicon_version: z.ZodNullable<z.ZodInt>;
+    config: z.ZodNullable<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        config: z.ZodObject<{
+            voice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            stt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            llm: 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>>>;
+            hangup: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                when: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, 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>>>;
+            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>>>;
+            knowledge: z.ZodOptional<z.ZodNullable<z.ZodArray<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>>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    lexicon: z.ZodNullable<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        lexicon: z.ZodObject<{
+            said: z.ZodArray<z.ZodObject<{
+                word: z.ZodString;
+                spoken: z.ZodString;
+            }, z.core.$strict>>;
+            heard: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CallTuning = z.infer<typeof CallTuningSchema>;
+/** One base and the agents whose settings attach it. */
+export declare const KnowledgeUseSchema: z.ZodObject<{
+    base: z.ZodString;
+    agents: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type KnowledgeUse = z.infer<typeof KnowledgeUseSchema>;
+/**
+ * GET /v1/knowledge/attached: which agents read each base, off every agent's newest settings in
+ * this world.
+ */
+export declare const KnowledgeUsesSchema: z.ZodObject<{
+    bases: z.ZodArray<z.ZodObject<{
+        base: z.ZodString;
+        agents: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type KnowledgeUses = z.infer<typeof KnowledgeUsesSchema>;

package/dist/generated/rest.js

@@ -1,6 +1,6 @@
 // Generated from schema/rest.json: the envelopes the read doors answer in. Never edited by hand.
 import { z } from "zod";
-import { ChannelSchema, ContactSchema, CostSchema, DirectionSchema, EndReasonSchema, EnvSchema, KnowledgeFileSchema, PlatformToolSchema, } from "./defs.js";
+import { ChannelSchema, ContactSchema, CostSchema, DirectionSchema, DocsConfigSchema, EndReasonSchema, EnvSchema, GreetingConfigSchema, HangupConfigSchema, KnowledgeFileSchema, MemoryConfigSchema, PlatformToolSchema, PronunciationSchema, TurnConfigSchema, } from "./defs.js";
 import { EntrySchema } from "./envelope.js";
 import { CallStatusSchema, StateSchema } from "./state.js";
 /** GET /v1/calls/{call}/state: the whole log folded, and the seq a stream resumes from. */
@@ -340,6 +340,35 @@ export const HeldAgentSchema = z.strictObject({
 export const AgentListSchema = z.strictObject({
     agents: z.array(HeldAgentSchema),
 });
+/**
+ * One app connected to the gateway right now: one process on one machine, holding one or more
+ * agents in one world.
+ */
+export const AppProcessSchema = z.strictObject({
+    app: z.string(),
+    agents: z.array(z.string()),
+    env: EnvSchema,
+    host: z.string().nullable(),
+    address: z.string().nullable(),
+    sdk: z.string().nullable(),
+    holder: LineHolderSchema.nullable(),
+    connected_at: z.number(),
+});
+/**
+ * GET /v1/apps: every app connected in the request's world that this key may see — its own
+ * corner's and the org's, every corner's with `team`.
+ */
+export const AppListSchema = z.strictObject({
+    apps: z.array(AppProcessSchema),
+});
+/**
+ * POST /v1/apps/{app}/stop, the answer: the socket was closed with the stop code, and the app
+ * exits rather than reconnect.
+ */
+export const AppStoppedSchema = z.strictObject({
+    app: z.string(),
+    stopped: z.boolean(),
+});
 /**
  * GET /v1/agents/{slug}/line: whose terminal a call that RINGS at this agent's doors lands in. An
  * org shares one sandbox number, so it rings in one place and which one is claimed.
@@ -399,13 +428,15 @@ export const KnowledgeScoreSchema = z.strictObject({
     misses: z.array(GoldenMissSchema),
 });
 /**
- * PUT /v1/knowledge/{base}, the answer: which base, how many chunks it became, and how long that
- * took.
+ * PUT /v1/knowledge/{base}, the answer: which base, how many chunks it became, how long that took,
+ * and what its whole files weigh on every call.
  */
 export const KnowledgePushedSchema = z.strictObject({
     base: z.string(),
     chunks: z.int(),
     took_ms: z.number(),
+    whole_tokens: z.int().nullish(),
+    notice: z.string().nullable().nullish(),
 });
 /** One knowledge base as the list draws it: its name, its size, and when it was last pushed. */
 export const KnowledgeBaseSchema = z.strictObject({
@@ -551,8 +582,9 @@ export const ExtractionRunSchema = z.strictObject({
 });
 /**
  * POST /v1/calls/{call}/lookup, the body: which platform tool to run for this turn, and what to
- * run it with. Worker-only; the gateway runs it against its own stores and writes memory.ops or
- * docs.sources on the call's log itself.
+ * run it with. Asked by the worker for the call it serves, and by the app for a call of its own
+ * org — `this.knowledge.search` in a tool; the gateway runs it against its own stores and writes
+ * memory.ops or docs.sources on the call's log itself.
  */
 export const LookupRequestSchema = z.strictObject({
     tool: PlatformToolSchema,
@@ -568,6 +600,19 @@ export const LookupResultSchema = z.strictObject({
     output: z.record(z.string(), z.unknown()),
     took_ms: z.number(),
 });
+/** One chunk search found: the file it came from, the heading it sits under, and its text. */
+export const FoundChunkSchema = z.strictObject({
+    path: z.string(),
+    heading: z.string().nullable(),
+    text: z.string(),
+});
+/**
+ * What search answers in a lookup's output: the best chunks of every base the agent reads, the
+ * best first. The app's `this.knowledge.search` hands the chunks to the tool that asked.
+ */
+export const SearchFoundSchema = z.strictObject({
+    chunks: z.array(FoundChunkSchema),
+});
 /**
  * POST /v1/calls/{call}/remember, the answer: what the call taught about the contact, counted.
  * Worker-only; the body is empty, the gateway reads the turns off its own log and writes
@@ -614,3 +659,137 @@ export const OutboundProvisionedSchema = z.strictObject({
     trunk: z.string().nullish(),
     address: z.string().nullish(),
 });
+/**
+ * An agent's tuning: what the org set over what the app declared, per world and per corner. Every
+ * field is optional; one left out is not set, and what the app declared — or the runtime's own
+ * default — stands for it.
+ */
+export const TuningBodySchema = z.strictObject({
+    voice: z.string().nullish(),
+    tts: z.string().nullish(),
+    tts_model: z.string().nullish(),
+    stt: z.string().nullish(),
+    llm: z.string().nullish(),
+    greeting: GreetingConfigSchema.nullish(),
+    hangup: HangupConfigSchema.nullish(),
+    turn: TurnConfigSchema.nullish(),
+    memory: MemoryConfigSchema.nullish(),
+    knowledge: z.array(DocsConfigSchema).nullish(),
+});
+/**
+ * One kept version of an agent's tuning: whose corner, which version, who set it and when, and
+ * what it says.
+ */
+export const TuningRowSchema = z.strictObject({
+    holder: z.string(),
+    version: z.int(),
+    author: z.string(),
+    note: z.string().nullable(),
+    set_at: z.number(),
+    config: TuningBodySchema,
+});
+/**
+ * GET /v1/agents/{slug}/settings: the agent's tuning as this key sees it — its own corner's, the
+ * team's and production's, each corner's own newest row, or null when that corner set nothing.
+ */
+export const TuningAnswerSchema = z.strictObject({
+    world: EnvSchema,
+    yours: TuningRowSchema.nullable(),
+    team: TuningRowSchema.nullable(),
+    production: TuningRowSchema.nullable(),
+});
+/**
+ * PUT /v1/agents/{slug}/settings, the body: the whole set, the version it was read at, why, and
+ * whose corner.
+ */
+export const TuningPutSchema = z.strictObject({
+    config: TuningBodySchema,
+    if_version: z.int().nullable().nullish(),
+    note: z.string().nullable().nullish(),
+    team: z.boolean().nullish(),
+});
+/** GET /v1/agents/{slug}/settings/history: one corner's versions, newest first. */
+export const TuningHistorySchema = z.strictObject({
+    world: EnvSchema,
+    holder: z.string(),
+    rows: z.array(TuningRowSchema),
+});
+/**
+ * GET /v1/agents/{slug}/settings/diff: what this key's corner reads against another corner's
+ * newest, and which fields differ.
+ */
+export const TuningDiffSchema = z.strictObject({
+    ours: TuningRowSchema.nullable(),
+    theirs: TuningRowSchema.nullable(),
+    changed: z.array(z.string()),
+});
+/**
+ * POST /v1/agents/{slug}/settings/rollback, the body: which version to bring back. It comes back
+ * as a NEW version; nothing is deleted.
+ */
+export const RollbackSchema = z.strictObject({
+    version: z.int(),
+    team: z.boolean().nullish(),
+});
+/**
+ * The org's lexicon: how the voice says the words it would get wrong, and the words the ears must
+ * know. Shared by every agent of the org, laid over each one's own says and hears.
+ */
+export const LexiconBodySchema = z.strictObject({
+    said: z.array(PronunciationSchema),
+    heard: z.array(z.string()),
+});
+/** One kept version of the org's lexicon. */
+export const LexiconRowSchema = z.strictObject({
+    holder: z.string(),
+    version: z.int(),
+    author: z.string(),
+    note: z.string().nullable(),
+    set_at: z.number(),
+    lexicon: LexiconBodySchema,
+});
+/**
+ * GET /v1/lexicon: the org's words as this key sees them — its own corner's, the team's and
+ * production's, each corner's own newest, or null.
+ */
+export const LexiconAnswerSchema = z.strictObject({
+    world: EnvSchema,
+    yours: LexiconRowSchema.nullable(),
+    team: LexiconRowSchema.nullable(),
+    production: LexiconRowSchema.nullable(),
+});
+/** PUT /v1/lexicon, the body: the whole lexicon, the version it was read at, why, and whose corner. */
+export const LexiconPutSchema = z.strictObject({
+    lexicon: LexiconBodySchema,
+    if_version: z.int().nullable().nullish(),
+    note: z.string().nullable().nullish(),
+    team: z.boolean().nullish(),
+});
+/** GET /v1/lexicon/history: one corner's versions, newest first. */
+export const LexiconHistorySchema = z.strictObject({
+    world: EnvSchema,
+    holder: z.string(),
+    rows: z.array(LexiconRowSchema),
+});
+/**
+ * GET /v1/calls/{call}/settings: the exact tuning and lexicon a call was built on, by the versions
+ * its head row recorded.
+ */
+export const CallTuningSchema = z.strictObject({
+    config_version: z.int().nullable(),
+    lexicon_version: z.int().nullable(),
+    config: TuningRowSchema.nullable(),
+    lexicon: LexiconRowSchema.nullable(),
+});
+/** One base and the agents whose settings attach it. */
+export const KnowledgeUseSchema = z.strictObject({
+    base: z.string(),
+    agents: z.array(z.string()),
+});
+/**
+ * GET /v1/knowledge/attached: which agents read each base, off every agent's newest settings in
+ * this world.
+ */
+export const KnowledgeUsesSchema = z.strictObject({
+    bases: z.array(KnowledgeUseSchema),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pinecall/protocol",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "The Pinecall wire: zod schemas and types generated from the protocol schema, and the log reducer",
   "license": "Apache-2.0",
   "author": "Pinecall <hello@pinecall.io>",