@pinecall/protocol 0.3.0 → 0.4.0

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. */
@@ -399,13 +399,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 +553,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 +571,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 +630,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/dist/generated/room.d.ts

@@ -23,9 +23,9 @@ export declare const ParticipantJoinedSchema: z.ZodObject<{
     kind: z.ZodEnum<{
         agent: "agent";
         caller: "caller";
-        supervisor: "supervisor";
         listener: "listener";
         sip: "sip";
+        supervisor: "supervisor";
     }>;
     name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     attributes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -51,15 +51,15 @@ export declare const TrackPublishedSchema: z.ZodObject<{
     identity: z.ZodString;
     kind: z.ZodEnum<{
         audio: "audio";
-        video: "video";
         screen: "screen";
+        video: "video";
     }>;
     source: z.ZodEnum<{
-        unknown: "unknown";
-        microphone: "microphone";
         camera: "camera";
+        microphone: "microphone";
         screen_share: "screen_share";
         screen_share_audio: "screen_share_audio";
+        unknown: "unknown";
     }>;
 }, z.core.$strict>;
 export type TrackPublished = z.infer<typeof TrackPublishedSchema>;
@@ -71,15 +71,15 @@ export declare const TrackUnpublishedSchema: z.ZodObject<{
     identity: z.ZodString;
     kind: z.ZodEnum<{
         audio: "audio";
-        video: "video";
         screen: "screen";
+        video: "video";
     }>;
     source: z.ZodEnum<{
-        unknown: "unknown";
-        microphone: "microphone";
         camera: "camera";
+        microphone: "microphone";
         screen_share: "screen_share";
         screen_share_audio: "screen_share_audio";
+        unknown: "unknown";
     }>;
 }, z.core.$strict>;
 export type TrackUnpublished = z.infer<typeof TrackUnpublishedSchema>;

package/dist/generated/state.d.ts

@@ -4,11 +4,11 @@ import { z } from "zod";
  * looks like.
  */
 export declare const CallStatusSchema: z.ZodEnum<{
-    idle: "idle";
-    ringing: "ringing";
-    dialing: "dialing";
     active: "active";
+    dialing: "dialing";
     ended: "ended";
+    idle: "idle";
+    ringing: "ringing";
 }>;
 export type CallStatus = z.infer<typeof CallStatusSchema>;
 /** One finished turn of the caller, with what the session measured about it. */
@@ -277,9 +277,9 @@ export declare const ToolRunSchema: z.ZodObject<{
     arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     speech_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     status: z.ZodEnum<{
-        running: "running";
         done: "done";
         failed: "failed";
+        running: "running";
     }>;
     output: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
     error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -312,9 +312,9 @@ export declare const ConfirmSchema: z.ZodObject<{
     audience: z.ZodString;
     phrase: z.ZodString;
     status: z.ZodEnum<{
-        pending: "pending";
-        granted: "granted";
         declined: "declined";
+        granted: "granted";
+        pending: "pending";
     }>;
     said: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -372,9 +372,9 @@ export declare const ParticipantSchema: z.ZodObject<{
     kind: z.ZodEnum<{
         agent: "agent";
         caller: "caller";
-        supervisor: "supervisor";
         listener: "listener";
         sip: "sip";
+        supervisor: "supervisor";
     }>;
     name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     joined_at: z.ZodNumber;
@@ -391,9 +391,9 @@ export declare const RoomSchema: z.ZodObject<{
         kind: z.ZodEnum<{
             agent: "agent";
             caller: "caller";
-            supervisor: "supervisor";
             listener: "listener";
             sip: "sip";
+            supervisor: "supervisor";
         }>;
         name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         joined_at: z.ZodNumber;
@@ -430,11 +430,11 @@ export declare const StateSchema: z.ZodObject<{
     agent: z.ZodString;
     call: z.ZodNullable<z.ZodString>;
     status: z.ZodEnum<{
-        idle: "idle";
-        ringing: "ringing";
-        dialing: "dialing";
         active: "active";
+        dialing: "dialing";
         ended: "ended";
+        idle: "idle";
+        ringing: "ringing";
     }>;
     channel: z.ZodNullable<z.ZodEnum<{
         phone: "phone";
@@ -462,9 +462,9 @@ export declare const StateSchema: z.ZodObject<{
             kind: z.ZodEnum<{
                 agent: "agent";
                 caller: "caller";
-                supervisor: "supervisor";
                 listener: "listener";
                 sip: "sip";
+                supervisor: "supervisor";
             }>;
             name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             joined_at: z.ZodNumber;
@@ -476,29 +476,29 @@ export declare const StateSchema: z.ZodObject<{
     started_at: z.ZodNullable<z.ZodNumber>;
     ended_at: z.ZodNullable<z.ZodNumber>;
     end_reason: z.ZodNullable<z.ZodEnum<{
-        caller_hung_up: "caller_hung_up";
         agent_hung_up: "agent_hung_up";
-        supervisor_ended: "supervisor_ended";
-        transferred: "transferred";
-        no_answer: "no_answer";
+        app_detached: "app_detached";
         busy: "busy";
+        caller_hung_up: "caller_hung_up";
         dial_failed: "dial_failed";
-        timeout: "timeout";
         drained: "drained";
-        app_detached: "app_detached";
         error: "error";
+        no_answer: "no_answer";
+        supervisor_ended: "supervisor_ended";
+        timeout: "timeout";
+        transferred: "transferred";
     }>>;
     outcome: z.ZodNullable<z.ZodString>;
     user_state: z.ZodNullable<z.ZodEnum<{
+        away: "away";
         listening: "listening";
         speaking: "speaking";
-        away: "away";
     }>>;
     agent_state: z.ZodNullable<z.ZodEnum<{
+        idle: "idle";
+        initializing: "initializing";
         listening: "listening";
         speaking: "speaking";
-        initializing: "initializing";
-        idle: "idle";
         thinking: "thinking";
     }>>;
     live: z.ZodObject<{
@@ -714,9 +714,9 @@ export declare const StateSchema: z.ZodObject<{
         arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         speech_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         status: z.ZodEnum<{
-            running: "running";
             done: "done";
             failed: "failed";
+            running: "running";
         }>;
         output: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
         error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -746,18 +746,18 @@ export declare const StateSchema: z.ZodObject<{
         audience: z.ZodString;
         phrase: z.ZodString;
         status: z.ZodEnum<{
-            pending: "pending";
-            granted: "granted";
             declined: "declined";
+            granted: "granted";
+            pending: "pending";
         }>;
         said: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strict>>;
     memory: z.ZodArray<z.ZodObject<{
         op: z.ZodEnum<{
+            forget: "forget";
             recall: "recall";
             remember: "remember";
-            forget: "forget";
         }>;
         contact: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         query: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -857,12 +857,12 @@ export declare const StateSchema: z.ZodObject<{
             provider: z.ZodString;
             model: z.ZodString;
             unit: z.ZodEnum<{
-                input_tokens: "input_tokens";
-                cached_input_tokens: "cached_input_tokens";
+                audio_seconds: "audio_seconds";
                 cache_creation_tokens: "cache_creation_tokens";
-                output_tokens: "output_tokens";
+                cached_input_tokens: "cached_input_tokens";
                 characters: "characters";
-                audio_seconds: "audio_seconds";
+                input_tokens: "input_tokens";
+                output_tokens: "output_tokens";
                 requests: "requests";
                 session_seconds: "session_seconds";
             }>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pinecall/protocol",
-  "version": "0.3.0",
+  "version": "0.4.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>",