@pinecall/protocol 0.6.1 → 0.6.3

package/dist/generated/commands.d.ts

@@ -85,6 +85,9 @@ export declare const AgentConfigureSchema: z.ZodObject<{
                 tenant: "tenant";
             }>;
         }, z.core.$strict>>>>;
+        view: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strict>>>;
         events: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
             name: z.ZodString;
             from: z.ZodArray<z.ZodEnum<{
@@ -359,6 +362,9 @@ export declare const SessionConfigureSchema: z.ZodObject<{
                 tenant: "tenant";
             }>;
         }, z.core.$strict>>>>;
+        view: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strict>>>;
         events: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
             name: z.ZodString;
             from: z.ZodArray<z.ZodEnum<{

package/dist/generated/defs.d.ts

@@ -32,9 +32,9 @@ export type Env = z.infer<typeof EnvSchema>;
  * What a console may ask of the process standing in the agent's directory, relayed by the gateway:
  * a written call to the class mounted there (chat), a simulated caller put on the class it holds,
  * its goldens and a suite of them, its knowledge folder pushed or its golden asked, its memory
- * goldens, a call promoted to a candidate file, the drift of the last two windows, and the
- * reproductions a broken run left on that disk. Everything else a console needs is a door of the
- * gateway.
+ * goldens, the panel it draws beside a conversation (view), a call promoted to a candidate file,
+ * the drift of the last two windows, and the reproductions a broken run left on that disk.
+ * Everything else a console needs is a door of the gateway.
  */
 export declare const DevVerbSchema: z.ZodEnum<{
     "chat.end": "chat.end";
@@ -55,6 +55,7 @@ export declare const DevVerbSchema: z.ZodEnum<{
     "reproductions.read": "reproductions.read";
     "reproductions.roster": "reproductions.roster";
     "simulate.start": "simulate.start";
+    "view.render": "view.render";
 }>;
 export type DevVerb = z.infer<typeof DevVerbSchema>;
 /**
@@ -330,6 +331,7 @@ export type MemoryOp = z.infer<typeof MemoryOpSchema>;
 /** One chunk of the knowledge base that retrieval put in front of the model for this turn. */
 export declare const DocSourceSchema: z.ZodObject<{
     id: z.ZodString;
+    base: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     path: z.ZodString;
     heading: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     score: z.ZodNumber;
@@ -442,6 +444,16 @@ export declare const StateFieldSpecSchema: z.ZodObject<{
     }>;
 }, z.core.$strict>;
 export type StateFieldSpec = z.infer<typeof StateFieldSpecSchema>;
+/**
+ * The panel the agent draws beside a conversation: it is declared here so a console knows the
+ * agent has one before it asks for it, and draws its own about the contact when it has not. What
+ * the panel CONTAINS never comes this way — it is asked for a conversation at a time, through the
+ * view.render dev verb.
+ */
+export declare const ViewSpecSchema: z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strict>;
+export type ViewSpec = z.infer<typeof ViewSpecSchema>;
 /**
  * One outside event the agent accepts, and from whom. An event nobody declared is refused before
  * it touches the log.
@@ -595,6 +607,9 @@ export declare const AgentConfigSchema: z.ZodObject<{
             tenant: "tenant";
         }>;
     }, z.core.$strict>>>>;
+    view: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strict>>>;
     events: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         from: z.ZodArray<z.ZodEnum<{

package/dist/generated/defs.js

@@ -20,11 +20,11 @@ export const EnvSchema = z.enum(["production", "sandbox"]);
  * What a console may ask of the process standing in the agent's directory, relayed by the gateway:
  * a written call to the class mounted there (chat), a simulated caller put on the class it holds,
  * its goldens and a suite of them, its knowledge folder pushed or its golden asked, its memory
- * goldens, a call promoted to a candidate file, the drift of the last two windows, and the
- * reproductions a broken run left on that disk. Everything else a console needs is a door of the
- * gateway.
+ * goldens, the panel it draws beside a conversation (view), a call promoted to a candidate file,
+ * the drift of the last two windows, and the reproductions a broken run left on that disk.
+ * Everything else a console needs is a door of the gateway.
  */
-export const DevVerbSchema = z.enum(["chat.roster", "chat.start", "chat.say", "chat.end", "simulate.start", "goldens.roster", "goldens.run", "knowledge.roster", "knowledge.push", "knowledge.eval", "memory.roster", "memory.eval", "memory.extraction", "promote.roster", "promote.write", "drift.read", "reproductions.roster", "reproductions.read"]);
+export const DevVerbSchema = z.enum(["chat.roster", "chat.start", "chat.say", "chat.end", "view.render", "simulate.start", "goldens.roster", "goldens.run", "knowledge.roster", "knowledge.push", "knowledge.eval", "memory.roster", "memory.eval", "memory.extraction", "promote.roster", "promote.write", "drift.read", "reproductions.roster", "reproductions.read"]);
 /**
  * Why the call is over. Who hung up, what failed before anybody could, drained: the platform took
  * the worker down (a deploy, a stop) with the call still on it, or app_detached: the app holding
@@ -184,6 +184,7 @@ export const MemoryOpSchema = z.strictObject({
 /** One chunk of the knowledge base that retrieval put in front of the model for this turn. */
 export const DocSourceSchema = z.strictObject({
     id: z.string(),
+    base: z.string().nullish(),
     path: z.string(),
     heading: z.string().nullish(),
     score: z.number(),
@@ -250,6 +251,15 @@ export const StateFieldSpecSchema = z.strictObject({
     name: z.string(),
     visibility: VisibilitySchema,
 });
+/**
+ * The panel the agent draws beside a conversation: it is declared here so a console knows the
+ * agent has one before it asks for it, and draws its own about the contact when it has not. What
+ * the panel CONTAINS never comes this way — it is asked for a conversation at a time, through the
+ * view.render dev verb.
+ */
+export const ViewSpecSchema = z.strictObject({
+    name: z.string(),
+});
 /**
  * One outside event the agent accepts, and from whom. An event nobody declared is refused before
  * it touches the log.
@@ -327,5 +337,6 @@ export const AgentConfigSchema = z.strictObject({
     tools: z.array(ToolSpecSchema).nullish(),
     uses_knowledge: z.boolean().nullish(),
     state_fields: z.array(StateFieldSpecSchema).nullish(),
+    view: ViewSpecSchema.nullish(),
     events: z.array(EventSpecSchema).nullish(),
 });

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>>;
@@ -466,6 +467,7 @@ export declare const DevRequestSchema: z.ZodObject<{
         "reproductions.read": "reproductions.read";
         "reproductions.roster": "reproductions.roster";
         "simulate.start": "simulate.start";
+        "view.render": "view.render";
     }>;
     data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$strict>;
@@ -478,6 +480,7 @@ export declare const DocsSourcesSchema: z.ZodObject<{
     query: z.ZodString;
     sources: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
+        base: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         path: z.ZodString;
         heading: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         score: z.ZodNumber;
@@ -877,6 +880,7 @@ export declare const LogGapSchema: z.ZodObject<{
         }, z.core.$strict>>;
         sources: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
+            base: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             path: z.ZodString;
             heading: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             score: z.ZodNumber;

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>>;
@@ -353,6 +354,7 @@ export declare const EVENT_SCHEMAS: {
             "reproductions.read": "reproductions.read";
             "reproductions.roster": "reproductions.roster";
             "simulate.start": "simulate.start";
+            "view.render": "view.render";
         }>;
         data: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
     }, import("zod/v4/core").$strict>;
@@ -360,6 +362,7 @@ export declare const EVENT_SCHEMAS: {
         query: import("zod").ZodString;
         sources: import("zod").ZodArray<import("zod").ZodObject<{
             id: import("zod").ZodString;
+            base: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
             path: import("zod").ZodString;
             heading: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
             score: import("zod").ZodNumber;
@@ -746,6 +749,7 @@ export declare const EVENT_SCHEMAS: {
             }, import("zod/v4/core").$strict>>;
             sources: import("zod").ZodArray<import("zod").ZodObject<{
                 id: import("zod").ZodString;
+                base: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
                 path: import("zod").ZodString;
                 heading: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
                 score: import("zod").ZodNumber;
@@ -1343,6 +1347,9 @@ export declare const COMMAND_SCHEMAS: {
                     tenant: "tenant";
                 }>;
             }, import("zod/v4/core").$strict>>>>;
+            view: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodObject<{
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>>;
             events: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodArray<import("zod").ZodObject<{
                 name: import("zod").ZodString;
                 from: import("zod").ZodArray<import("zod").ZodEnum<{
@@ -1525,6 +1532,9 @@ export declare const COMMAND_SCHEMAS: {
                     tenant: "tenant";
                 }>;
             }, import("zod/v4/core").$strict>>>>;
+            view: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodObject<{
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>>;
             events: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodArray<import("zod").ZodObject<{
                 name: import("zod").ZodString;
                 from: import("zod").ZodArray<import("zod").ZodEnum<{

package/dist/generated/rest.d.ts

@@ -348,6 +348,7 @@ export declare const CallStateSchema: z.ZodObject<{
         }, z.core.$strict>>;
         sources: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
+            base: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             path: z.ZodString;
             heading: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             score: z.ZodNumber;
@@ -857,7 +858,7 @@ export declare const ThreadMessageSchema: z.ZodObject<{
         whatsapp: "whatsapp";
     }>;
     duration_s: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodNumber>>>;
-    answered: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    answered: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodBoolean>>>;
 }, z.core.$strict>;
 export type ThreadMessage = z.infer<typeof ThreadMessageSchema>;
 /** GET /v1/agents/{slug}/threads/{contact}: every call of one contact, merged, oldest first. */
@@ -879,7 +880,7 @@ export declare const ThreadSchema: z.ZodObject<{
             whatsapp: "whatsapp";
         }>;
         duration_s: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodNumber>>>;
-        answered: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        answered: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodBoolean>>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type Thread = z.infer<typeof ThreadSchema>;
@@ -1106,10 +1107,10 @@ export declare const HeldAgentSchema: z.ZodObject<{
         web: "web";
         whatsapp: "whatsapp";
     }>>;
-    holder: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+    holder: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodObject<{
         holder: z.ZodNullable<z.ZodString>;
         name: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>>>;
+    }, z.core.$strict>>>>;
 }, z.core.$strict>;
 export type HeldAgent = z.infer<typeof HeldAgentSchema>;
 /** GET /v1/agents: every agent this fleet is holding right now, as the front page lists them. */
@@ -1121,10 +1122,10 @@ export declare const AgentListSchema: z.ZodObject<{
             web: "web";
             whatsapp: "whatsapp";
         }>>;
-        holder: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        holder: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodObject<{
             holder: z.ZodNullable<z.ZodString>;
             name: z.ZodNullable<z.ZodString>;
-        }, z.core.$strict>>>;
+        }, z.core.$strict>>>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type AgentList = z.infer<typeof AgentListSchema>;
@@ -1192,10 +1193,10 @@ export declare const TheLineSchema: z.ZodObject<{
         sandbox: "sandbox";
     }>;
     held: z.ZodBoolean;
-    holding: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+    holding: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodObject<{
         holder: z.ZodNullable<z.ZodString>;
         name: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>>>;
+    }, z.core.$strict>>>>;
     yours: z.ZodBoolean;
     waiting: z.ZodArray<z.ZodObject<{
         holder: z.ZodNullable<z.ZodString>;
@@ -2243,9 +2244,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 +2261,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 +2279,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 +2291,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

@@ -144,7 +144,7 @@ export const ThreadMessageSchema = z.strictObject({
     call: z.string(),
     channel: ChannelSchema,
     duration_s: z.number().nullable().nullish(),
-    answered: z.boolean().nullish(),
+    answered: z.boolean().nullable().nullish(),
 });
 /** GET /v1/agents/{slug}/threads/{contact}: every call of one contact, merged, oldest first. */
 export const ThreadSchema = z.strictObject({
@@ -334,7 +334,7 @@ export const LineHolderSchema = z.strictObject({
 export const HeldAgentSchema = z.strictObject({
     slug: z.string(),
     channels: z.array(ChannelSchema),
-    holder: LineHolderSchema.nullish(),
+    holder: LineHolderSchema.nullable().nullish(),
 });
 /** GET /v1/agents: every agent this fleet is holding right now, as the front page lists them. */
 export const AgentListSchema = z.strictObject({
@@ -377,7 +377,7 @@ export const TheLineSchema = z.strictObject({
     agent: z.string(),
     env: EnvSchema,
     held: z.boolean(),
-    holding: LineHolderSchema.nullish(),
+    holding: LineHolderSchema.nullable().nullish(),
     yours: z.boolean(),
     waiting: z.array(LineHolderSchema),
     calling: z.array(z.string()),
@@ -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/dist/generated/state.d.ts

@@ -772,6 +772,7 @@ export declare const StateSchema: z.ZodObject<{
     }, z.core.$strict>>;
     sources: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
+        base: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         path: z.ZodString;
         heading: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         score: z.ZodNumber;

package/package.json

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