@pinecall/protocol 0.6.1 → 0.6.2

package/dist/generated/events.d.ts

@@ -228,6 +228,7 @@ export declare const CallStartedSchema: z.ZodObject<{
     from: z.ZodString;
     to: z.ZodString;
     run: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+    persona: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
     caller: z.ZodNullable<z.ZodObject<{
         id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;

package/dist/generated/events.js

@@ -126,6 +126,7 @@ export const CallStartedSchema = z.strictObject({
     from: z.string(),
     to: z.string(),
     run: z.string().nullable().nullish(),
+    persona: z.string().nullable().nullish(),
     caller: ContactSchema.nullable(),
     started_at: z.number(),
     env: EnvSchema.nullish(),

package/dist/generated/registry.d.ts

@@ -152,6 +152,7 @@ export declare const EVENT_SCHEMAS: {
         from: import("zod").ZodString;
         to: import("zod").ZodString;
         run: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNullable<import("zod").ZodString>>>;
+        persona: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNullable<import("zod").ZodString>>>;
         caller: import("zod").ZodNullable<import("zod").ZodObject<{
             id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
             phone: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;

package/dist/generated/rest.d.ts

@@ -2243,9 +2243,11 @@ export declare const KnowledgeUsesSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type KnowledgeUses = z.infer<typeof KnowledgeUsesSchema>;
 /**
- * One synthetic caller of an agent, kept by the gateway: what they want, how they talk, and what
+ * One synthetic caller of an ORG, kept by the gateway: what they want, how they talk, and what
  * they may state about themselves. A model plays them turn by turn — there is no script — for
- * `pinecall simulate` and the console's Simulations.
+ * `pinecall simulate` and the console's Simulations. A caller is a person on the phone, so who
+ * they are does not depend on which of the org's agents answers: every agent of the org calls with
+ * the same list.
  */
 export declare const PersonaSchema: z.ZodObject<{
     name: z.ZodString;
@@ -2258,7 +2260,10 @@ export declare const PersonaSchema: z.ZodObject<{
     set_at: z.ZodNumber;
 }, z.core.$strict>;
 export type Persona = z.infer<typeof PersonaSchema>;
-/** GET /v1/agents/{slug}/personas: every caller written for this agent, by name. */
+/**
+ * GET /v1/personas: every caller the org wrote, by name. The same list for every agent of the org,
+ * and the same one in both worlds.
+ */
 export declare const PersonaListSchema: z.ZodObject<{
     personas: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -2273,8 +2278,8 @@ export declare const PersonaListSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type PersonaList = z.infer<typeof PersonaListSchema>;
 /**
- * PUT /v1/agents/{slug}/personas/{name}, the body: the caller, written whole. A name that exists
- * is replaced; `was` renames the caller it names.
+ * PUT /v1/personas/{name}, the body: the caller, written whole. A name that exists is replaced;
+ * `was` renames the caller it names.
  */
 export declare const PersonaPutSchema: z.ZodObject<{
     about: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -2285,3 +2290,74 @@ export declare const PersonaPutSchema: z.ZodObject<{
     was: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strict>;
 export type PersonaPut = z.infer<typeof PersonaPutSchema>;
+/**
+ * One simulation this caller has run: the call it was, and what the call came to. Read off the
+ * call index, never off a log — the same row the sessions list is drawn from.
+ */
+export declare const PersonaRunSchema: z.ZodObject<{
+    call: z.ZodString;
+    agent: z.ZodString;
+    started_at: z.ZodNumber;
+    ended_at: z.ZodNullable<z.ZodNumber>;
+    turns: z.ZodInt;
+    end_reason: z.ZodNullable<z.ZodEnum<{
+        agent_hung_up: "agent_hung_up";
+        app_detached: "app_detached";
+        busy: "busy";
+        caller_hung_up: "caller_hung_up";
+        dial_failed: "dial_failed";
+        drained: "drained";
+        error: "error";
+        no_answer: "no_answer";
+        supervisor_ended: "supervisor_ended";
+        timeout: "timeout";
+        transferred: "transferred";
+    }>>;
+    outcome: z.ZodNullable<z.ZodString>;
+    cost_eur: z.ZodNullable<z.ZodNumber>;
+    score: z.ZodNullable<z.ZodObject<{
+        held: z.ZodInt;
+        judged: z.ZodInt;
+        passed: z.ZodBoolean;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PersonaRun = z.infer<typeof PersonaRunSchema>;
+/**
+ * Every simulation this caller has run, newest first, a page at a time. GET
+ * /v1/personas/{name}/runs, in the key's own world and corner, paged exactly as the sessions list
+ * is.
+ */
+export declare const PersonaRunListSchema: z.ZodObject<{
+    runs: z.ZodArray<z.ZodObject<{
+        call: z.ZodString;
+        agent: z.ZodString;
+        started_at: z.ZodNumber;
+        ended_at: z.ZodNullable<z.ZodNumber>;
+        turns: z.ZodInt;
+        end_reason: z.ZodNullable<z.ZodEnum<{
+            agent_hung_up: "agent_hung_up";
+            app_detached: "app_detached";
+            busy: "busy";
+            caller_hung_up: "caller_hung_up";
+            dial_failed: "dial_failed";
+            drained: "drained";
+            error: "error";
+            no_answer: "no_answer";
+            supervisor_ended: "supervisor_ended";
+            timeout: "timeout";
+            transferred: "transferred";
+        }>>;
+        outcome: z.ZodNullable<z.ZodString>;
+        cost_eur: z.ZodNullable<z.ZodNumber>;
+        score: z.ZodNullable<z.ZodObject<{
+            held: z.ZodInt;
+            judged: z.ZodInt;
+            passed: z.ZodBoolean;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    total: z.ZodInt;
+    next: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type PersonaRunList = z.infer<typeof PersonaRunListSchema>;

package/dist/generated/rest.js

@@ -832,9 +832,11 @@ export const KnowledgeUsesSchema = z.strictObject({
     bases: z.array(KnowledgeUseSchema),
 });
 /**
- * One synthetic caller of an agent, kept by the gateway: what they want, how they talk, and what
+ * One synthetic caller of an ORG, kept by the gateway: what they want, how they talk, and what
  * they may state about themselves. A model plays them turn by turn — there is no script — for
- * `pinecall simulate` and the console's Simulations.
+ * `pinecall simulate` and the console's Simulations. A caller is a person on the phone, so who
+ * they are does not depend on which of the org's agents answers: every agent of the org calls with
+ * the same list.
  */
 export const PersonaSchema = z.strictObject({
     name: z.string(),
@@ -846,13 +848,16 @@ export const PersonaSchema = z.strictObject({
     author: z.string(),
     set_at: z.number(),
 });
-/** GET /v1/agents/{slug}/personas: every caller written for this agent, by name. */
+/**
+ * GET /v1/personas: every caller the org wrote, by name. The same list for every agent of the org,
+ * and the same one in both worlds.
+ */
 export const PersonaListSchema = z.strictObject({
     personas: z.array(PersonaSchema),
 });
 /**
- * PUT /v1/agents/{slug}/personas/{name}, the body: the caller, written whole. A name that exists
- * is replaced; `was` renames the caller it names.
+ * PUT /v1/personas/{name}, the body: the caller, written whole. A name that exists is replaced;
+ * `was` renames the caller it names.
  */
 export const PersonaPutSchema = z.strictObject({
     about: z.string().nullish(),
@@ -862,3 +867,28 @@ export const PersonaPutSchema = z.strictObject({
     state: z.record(z.string(), z.unknown()).nullish(),
     was: z.string().nullish(),
 });
+/**
+ * One simulation this caller has run: the call it was, and what the call came to. Read off the
+ * call index, never off a log — the same row the sessions list is drawn from.
+ */
+export const PersonaRunSchema = z.strictObject({
+    call: z.string(),
+    agent: z.string(),
+    started_at: z.number(),
+    ended_at: z.number().nullable(),
+    turns: z.int(),
+    end_reason: EndReasonSchema.nullable(),
+    outcome: z.string().nullable(),
+    cost_eur: z.number().nullable(),
+    score: SessionScoreSchema.nullable(),
+});
+/**
+ * Every simulation this caller has run, newest first, a page at a time. GET
+ * /v1/personas/{name}/runs, in the key's own world and corner, paged exactly as the sessions list
+ * is.
+ */
+export const PersonaRunListSchema = z.strictObject({
+    runs: z.array(PersonaRunSchema),
+    total: z.int(),
+    next: z.string().nullable(),
+});

package/package.json

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