@substrat-run/engine-assistant 0.0.0-stage → 0.1.27

package/dist/operations.js

@@ -0,0 +1,106 @@
+/**
+ * The assistant engine's declared operation surface.
+ *
+ * Two audiences, and the line between them is the point of the engine.
+ *
+ * **A person** (`assistant:use`) opens threads, reads their own, says something, approves or
+ * denies what the assistant proposes, and closes a thread. Every one of those acts on the
+ * caller's own threads: none takes a principal as input to act as, so holding the key never
+ * reaches anybody else's conversation. `assistant:audit` adds reading another principal's
+ * threads, never writing to them.
+ *
+ * **The assistant host** (`assistant:run`) takes the lease on a thread, appends what the
+ * assistant said and did, and claims a gated tool's execution. This key is held by the
+ * host's principal ONLY and by no role a person has. If a person held it they could append
+ * `text-delta` events to their own thread and have the record say the assistant wrote them,
+ * or mark a tool call done that never ran. The split is what makes the record evidence.
+ *
+ * Node checks only: a thread is its owner's, which is a comparison of principals the
+ * handlers make, not a per-entity grant somebody else could hold. No `http`: an engine owns
+ * no URL shape; a composing vertical binds these with `defineEngineRoutes`.
+ */
+import { defineOperations } from '@substrat-run/contracts';
+import { assistantEntities } from './entities.js';
+import { acquireRunInput, acquiredRun, appendEventsInput, appendedEvents, claimExecutionInput, claimedExecution, createThreadInput, eventsPage, listThreadsInput, readEventsInput, releaseRunInput, releasedRun, resolveApprovalInput, resolvedApproval, sendMessageInput, sentMessage, thread, threadIdInput, } from './shapes.js';
+/** The keys these operations check. Mirrors `ASSISTANT_PERM` in index.ts. */
+export const ASSISTANT_PERMISSIONS = ['assistant:use', 'assistant:audit', 'assistant:run'];
+export const assistantOperations = defineOperations(assistantEntities, ASSISTANT_PERMISSIONS)({
+    'assistant/create-thread': {
+        summary: 'Open a thread for the caller',
+        permission: 'assistant:use',
+        input: createThreadInput,
+        inputOptional: true,
+        output: thread,
+    },
+    'assistant/list-threads': {
+        summary: "The caller's threads, most recently active first (another principal's, with audit)",
+        permission: 'assistant:use',
+        input: listThreadsInput,
+        inputOptional: true,
+        output: thread,
+        // Handler-composed: a thread is a projection of its row, and the read narrows to the
+        // caller's own before it pages. The order and the cursor are (last_event_at, id).
+        paged: { sortKey: 'lastEventAt' },
+    },
+    'assistant/get-thread': {
+        summary: 'One thread',
+        permission: 'assistant:use',
+        input: threadIdInput,
+        output: thread,
+    },
+    'assistant/read-events': {
+        summary: "A thread's events after a cursor — how a client resumes",
+        permission: 'assistant:use',
+        input: readEventsInput,
+        output: eventsPage,
+    },
+    'assistant/send-message': {
+        summary: 'Send text or uploaded files in a thread, which begins a turn',
+        permission: 'assistant:use',
+        input: sendMessageInput,
+        output: sentMessage,
+    },
+    'assistant/authorize-file-upload': {
+        summary: 'Authorize a host to upload a file to the caller’s own open thread',
+        permission: 'assistant:use',
+        input: threadIdInput,
+        output: thread,
+    },
+    'assistant/resolve-approval': {
+        summary: 'Approve or deny a gated tool call, bound to the input shown',
+        permission: 'assistant:use',
+        input: resolveApprovalInput,
+        output: resolvedApproval,
+    },
+    'assistant/close-thread': {
+        summary: 'Close a thread; nothing more is appended',
+        permission: 'assistant:use',
+        input: threadIdInput,
+        output: thread,
+    },
+    'assistant/acquire-run': {
+        summary: 'Take the single-writer lease on a thread (host only)',
+        permission: 'assistant:run',
+        input: acquireRunInput,
+        output: acquiredRun,
+    },
+    'assistant/release-run': {
+        summary: 'Give the lease back when a run comes to rest (host only)',
+        permission: 'assistant:run',
+        input: releaseRunInput,
+        output: releasedRun,
+    },
+    'assistant/append-events': {
+        summary: "Append the assistant's events to a thread, fenced by the lease (host only)",
+        permission: 'assistant:run',
+        input: appendEventsInput,
+        output: appendedEvents,
+    },
+    'assistant/claim-execution': {
+        summary: 'Claim the one execution of an approved tool call (host only)',
+        permission: 'assistant:run',
+        input: claimExecutionInput,
+        output: claimedExecution,
+    },
+});
+//# sourceMappingURL=operations.js.map

package/dist/operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.js","sourceRoot":"","sources":["../src/operations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EACL,eAAe,EACf,WAAW,EACX,iBAAiB,EACjB,cAAc,EACd,mBAAmB,EACnB,gBAAgB,EAChB,iBAAiB,EACjB,UAAU,EACV,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,WAAW,EACX,oBAAoB,EACpB,gBAAgB,EAChB,gBAAgB,EAChB,WAAW,EACX,MAAM,EACN,aAAa,GACd,MAAM,aAAa,CAAC;AAErB,6EAA6E;AAC7E,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,eAAe,EAAE,iBAAiB,EAAE,eAAe,CAAU,CAAC;AAEpG,MAAM,CAAC,MAAM,mBAAmB,GAAG,gBAAgB,CAAC,iBAAiB,EAAE,qBAAqB,CAAC,CAAC;IAC5F,yBAAyB,EAAE;QACzB,OAAO,EAAE,8BAA8B;QACvC,UAAU,EAAE,eAAe;QAC3B,KAAK,EAAE,iBAAiB;QACxB,aAAa,EAAE,IAAI;QACnB,MAAM,EAAE,MAAM;KACf;IAED,wBAAwB,EAAE;QACxB,OAAO,EAAE,oFAAoF;QAC7F,UAAU,EAAE,eAAe;QAC3B,KAAK,EAAE,gBAAgB;QACvB,aAAa,EAAE,IAAI;QACnB,MAAM,EAAE,MAAM;QACd,qFAAqF;QACrF,kFAAkF;QAClF,KAAK,EAAE,EAAE,OAAO,EAAE,aAAa,EAAE;KAClC;IAED,sBAAsB,EAAE;QACtB,OAAO,EAAE,YAAY;QACrB,UAAU,EAAE,eAAe;QAC3B,KAAK,EAAE,aAAa;QACpB,MAAM,EAAE,MAAM;KACf;IAED,uBAAuB,EAAE;QACvB,OAAO,EAAE,yDAAyD;QAClE,UAAU,EAAE,eAAe;QAC3B,KAAK,EAAE,eAAe;QACtB,MAAM,EAAE,UAAU;KACnB;IAED,wBAAwB,EAAE;QACxB,OAAO,EAAE,8DAA8D;QACvE,UAAU,EAAE,eAAe;QAC3B,KAAK,EAAE,gBAAgB;QACvB,MAAM,EAAE,WAAW;KACpB;IAED,iCAAiC,EAAE;QACjC,OAAO,EAAE,mEAAmE;QAC5E,UAAU,EAAE,eAAe;QAC3B,KAAK,EAAE,aAAa;QACpB,MAAM,EAAE,MAAM;KACf;IAED,4BAA4B,EAAE;QAC5B,OAAO,EAAE,6DAA6D;QACtE,UAAU,EAAE,eAAe;QAC3B,KAAK,EAAE,oBAAoB;QAC3B,MAAM,EAAE,gBAAgB;KACzB;IAED,wBAAwB,EAAE;QACxB,OAAO,EAAE,0CAA0C;QACnD,UAAU,EAAE,eAAe;QAC3B,KAAK,EAAE,aAAa;QACpB,MAAM,EAAE,MAAM;KACf;IAED,uBAAuB,EAAE;QACvB,OAAO,EAAE,sDAAsD;QAC/D,UAAU,EAAE,eAAe;QAC3B,KAAK,EAAE,eAAe;QACtB,MAAM,EAAE,WAAW;KACpB;IAED,uBAAuB,EAAE;QACvB,OAAO,EAAE,0DAA0D;QACnE,UAAU,EAAE,eAAe;QAC3B,KAAK,EAAE,eAAe;QACtB,MAAM,EAAE,WAAW;KACpB;IAED,yBAAyB,EAAE;QACzB,OAAO,EAAE,4EAA4E;QACrF,UAAU,EAAE,eAAe;QAC3B,KAAK,EAAE,iBAAiB;QACxB,MAAM,EAAE,cAAc;KACvB;IAED,2BAA2B,EAAE;QAC3B,OAAO,EAAE,8DAA8D;QACvE,UAAU,EAAE,eAAe;QAC3B,KAAK,EAAE,mBAAmB;QAC1B,MAAM,EAAE,gBAAgB;KACzB;CACF,CAAC,CAAC"}

package/dist/seam.d.ts

@@ -0,0 +1,5 @@
+/** How this engine names itself in a seam failure. */
+export declare const columnsOf: (schema: {
+    readonly shape: Readonly<Record<string, unknown>>;
+}) => string, returns: <T>(schema: import("zod").ZodType<T>, surface: string, value: unknown) => T;
+//# sourceMappingURL=seam.d.ts.map

package/dist/seam.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seam.d.ts","sourceRoot":"","sources":["../src/seam.ts"],"names":[],"mappings":"AAaA,sDAAsD;AACtD,eAAO,MAAQ,SAAS;;cAAE,OAAO,6EAAmC,CAAC"}

package/dist/seam.js

@@ -0,0 +1,15 @@
+/**
+ * The engine seam (#771) for engine-assistant — the NAME, and nothing else.
+ *
+ * `returns(schema, surface, value)` and `columnsOf(schema)` live in `@substrat-run/contracts`
+ * (#970); an engine supplies only the name it answers under.
+ *
+ * What is specific here: a stored `body` is parsed back through the stream protocol's own
+ * schema before it reaches a client, and a stored `state` decides what a tool call may do
+ * next. A row that drifted would otherwise reach a screen as a half-formed event, or let a
+ * gated write through a state the engine thinks it cannot be in.
+ */
+import { engineSeam } from '@substrat-run/contracts';
+/** How this engine names itself in a seam failure. */
+export const { columnsOf, returns } = engineSeam('engine-assistant');
+//# sourceMappingURL=seam.js.map

package/dist/seam.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"seam.js","sourceRoot":"","sources":["../src/seam.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAErD,sDAAsD;AACtD,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,GAAG,UAAU,CAAC,kBAAkB,CAAC,CAAC"}

package/dist/shapes.d.ts

@@ -0,0 +1,413 @@
+/**
+ * The published shapes and the declared inputs of engine-assistant, in one place so the
+ * in-scope functions in `index.ts` and the declared operations in `operations.ts` read the
+ * same definition rather than two that drift.
+ *
+ * Published shapes are camelCase projections; the stored rows (snake_case) are in
+ * `entities.ts`. A caller never sees a row.
+ */
+import { z } from '@substrat-run/contracts';
+/**
+ * The longest an event body may serialise to, in UTF-8 bytes: the Durable Object row limit
+ * is in bytes. A large tool result belongs in the operation that produced it, by id.
+ */
+export declare const MAX_EVENT_BYTES: number;
+/**
+ * The longest a user's message may be, in UTF-8 bytes of its text AS SERIALISED (escapes
+ * included). Half the event bound, so a message that passes the input schema always fits in
+ * its `user-message` event: a message is refused as a message, at the boundary, never as an
+ * oversized event further in.
+ */
+export declare const MAX_MESSAGE_BYTES: number;
+/** UTF-8 byte length of a string, without a platform encoder (module code has none in its types). */
+export declare function utf8Length(s: string): number;
+/** One thread, projected. */
+export declare const thread: z.ZodObject<{
+    id: z.ZodString;
+    subject: z.ZodString;
+    title: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        closed: "closed";
+        open: "open";
+    }>;
+    createdAt: z.ZodString;
+    lastEventAt: z.ZodString;
+    closedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type Thread = z.infer<typeof thread>;
+export declare const createThreadInput: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CreateThreadInput = z.infer<typeof createThreadInput>;
+export declare const listThreadsInput: z.ZodObject<{
+    subject: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        closed: "closed";
+        open: "open";
+    }>>;
+}, z.core.$strip>;
+export type ListThreadsInput = z.infer<typeof listThreadsInput>;
+export declare const threadIdInput: z.ZodObject<{
+    threadId: z.ZodString;
+}, z.core.$strip>;
+export type ThreadIdInput = z.infer<typeof threadIdInput>;
+/** A bounded read of the record, by the cursor a client resumes after. */
+export declare const readEventsInput: z.ZodObject<{
+    threadId: z.ZodString;
+    after: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type ReadEventsInput = z.input<typeof readEventsInput>;
+export declare const eventsPage: z.ZodObject<{
+    events: z.ZodArray<z.ZodIntersection<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        t: z.ZodLiteral<"user-message">;
+        text: z.ZodString;
+        files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            filename: z.ZodString;
+            contentType: z.ZodString;
+            size: z.ZodNumber;
+            sha256: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"turn-start">;
+        v: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"turn-finish">;
+        reason: z.ZodEnum<{
+            "awaiting-approval": "awaiting-approval";
+            budget: "budget";
+            done: "done";
+            stopped: "stopped";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"turn-error">;
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"step-start">;
+        step: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"step-end">;
+        step: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"step-restart">;
+        step: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        pid: z.ZodString;
+        t: z.ZodLiteral<"text-start">;
+    }, z.core.$strip>, z.ZodObject<{
+        pid: z.ZodString;
+        t: z.ZodLiteral<"text-delta">;
+        delta: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        pid: z.ZodString;
+        t: z.ZodLiteral<"text-end">;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"tool-input">;
+        callId: z.ZodString;
+        tool: z.ZodString;
+        input: z.ZodUnknown;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"tool-output">;
+        callId: z.ZodString;
+        tool: z.ZodString;
+        output: z.ZodOptional<z.ZodUnknown>;
+        ref: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"tool-error">;
+        callId: z.ZodString;
+        tool: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"approval-request">;
+        callId: z.ZodString;
+        step: z.ZodString;
+        tool: z.ZodString;
+        operation: z.ZodString;
+        version: z.ZodString;
+        input: z.ZodUnknown;
+        expiresAt: z.core.$ZodBranded<z.ZodString, "Instant", "out">;
+        nonce: z.ZodString;
+        digest: z.ZodString;
+        preview: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"approval-resolved">;
+        callId: z.ZodString;
+        approved: z.ZodBoolean;
+        approver: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+        digest: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"source">;
+        sid: z.ZodString;
+        title: z.ZodString;
+        url: z.ZodOptional<z.ZodString>;
+        ref: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"data-provenance">;
+        producedAt: z.core.$ZodBranded<z.ZodString, "Instant", "out">;
+        model: z.ZodOptional<z.ZodString>;
+        sources: z.ZodOptional<z.ZodNumber>;
+        query: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"budget-notice">;
+        exhausted: z.ZodBoolean;
+        resetsAt: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Instant", "out">>;
+    }, z.core.$strip>], "t">, z.ZodObject<{
+        id: z.ZodNumber;
+    }, z.core.$strip>>>;
+    lastSeq: z.ZodNumber;
+}, z.core.$strip>;
+export type EventsPage = z.infer<typeof eventsPage>;
+export declare const sendMessageInput: z.ZodObject<{
+    threadId: z.ZodString;
+    text: z.ZodDefault<z.ZodString>;
+    attachmentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type SendMessageInput = z.input<typeof sendMessageInput>;
+export declare const sentMessage: z.ZodObject<{
+    firstSeq: z.ZodNumber;
+    lastSeq: z.ZodNumber;
+}, z.core.$strip>;
+export type SentMessage = z.infer<typeof sentMessage>;
+export declare const resolveApprovalInput: z.ZodObject<{
+    threadId: z.ZodString;
+    callId: z.ZodString;
+    digest: z.ZodString;
+    approved: z.ZodBoolean;
+    version: z.ZodString;
+}, z.core.$strip>;
+export type ResolveApprovalInput = z.infer<typeof resolveApprovalInput>;
+export declare const resolvedApproval: z.ZodObject<{
+    seq: z.ZodNumber;
+}, z.core.$strip>;
+export declare const acquireRunInput: z.ZodObject<{
+    threadId: z.ZodString;
+    runId: z.ZodString;
+    staleMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type AcquireRunInput = z.infer<typeof acquireRunInput>;
+export declare const acquiredRun: z.ZodObject<{
+    tookOver: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const releaseRunInput: z.ZodObject<{
+    threadId: z.ZodString;
+    runId: z.ZodString;
+}, z.core.$strip>;
+export type ReleaseRunInput = z.infer<typeof releaseRunInput>;
+export declare const releasedRun: z.ZodObject<{
+    released: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const appendEventsInput: z.ZodObject<{
+    threadId: z.ZodString;
+    runId: z.ZodString;
+    events: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        t: z.ZodLiteral<"user-message">;
+        text: z.ZodString;
+        files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            filename: z.ZodString;
+            contentType: z.ZodString;
+            size: z.ZodNumber;
+            sha256: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"turn-start">;
+        v: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"turn-finish">;
+        reason: z.ZodEnum<{
+            "awaiting-approval": "awaiting-approval";
+            budget: "budget";
+            done: "done";
+            stopped: "stopped";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"turn-error">;
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"step-start">;
+        step: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"step-end">;
+        step: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"step-restart">;
+        step: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        pid: z.ZodString;
+        t: z.ZodLiteral<"text-start">;
+    }, z.core.$strip>, z.ZodObject<{
+        pid: z.ZodString;
+        t: z.ZodLiteral<"text-delta">;
+        delta: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        pid: z.ZodString;
+        t: z.ZodLiteral<"text-end">;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"tool-input">;
+        callId: z.ZodString;
+        tool: z.ZodString;
+        input: z.ZodUnknown;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"tool-output">;
+        callId: z.ZodString;
+        tool: z.ZodString;
+        output: z.ZodOptional<z.ZodUnknown>;
+        ref: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"tool-error">;
+        callId: z.ZodString;
+        tool: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"approval-request">;
+        callId: z.ZodString;
+        step: z.ZodString;
+        tool: z.ZodString;
+        operation: z.ZodString;
+        version: z.ZodString;
+        input: z.ZodUnknown;
+        expiresAt: z.core.$ZodBranded<z.ZodString, "Instant", "out">;
+        nonce: z.ZodString;
+        digest: z.ZodString;
+        preview: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"approval-resolved">;
+        callId: z.ZodString;
+        approved: z.ZodBoolean;
+        approver: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+        digest: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"source">;
+        sid: z.ZodString;
+        title: z.ZodString;
+        url: z.ZodOptional<z.ZodString>;
+        ref: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"data-provenance">;
+        producedAt: z.core.$ZodBranded<z.ZodString, "Instant", "out">;
+        model: z.ZodOptional<z.ZodString>;
+        sources: z.ZodOptional<z.ZodNumber>;
+        query: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"budget-notice">;
+        exhausted: z.ZodBoolean;
+        resetsAt: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Instant", "out">>;
+    }, z.core.$strip>], "t">>;
+}, z.core.$strip>;
+export type AppendEventsInput = z.input<typeof appendEventsInput>;
+export declare const appendedEvents: z.ZodObject<{
+    events: z.ZodArray<z.ZodIntersection<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        t: z.ZodLiteral<"user-message">;
+        text: z.ZodString;
+        files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            filename: z.ZodString;
+            contentType: z.ZodString;
+            size: z.ZodNumber;
+            sha256: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"turn-start">;
+        v: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"turn-finish">;
+        reason: z.ZodEnum<{
+            "awaiting-approval": "awaiting-approval";
+            budget: "budget";
+            done: "done";
+            stopped: "stopped";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"turn-error">;
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"step-start">;
+        step: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"step-end">;
+        step: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"step-restart">;
+        step: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        pid: z.ZodString;
+        t: z.ZodLiteral<"text-start">;
+    }, z.core.$strip>, z.ZodObject<{
+        pid: z.ZodString;
+        t: z.ZodLiteral<"text-delta">;
+        delta: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        pid: z.ZodString;
+        t: z.ZodLiteral<"text-end">;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"tool-input">;
+        callId: z.ZodString;
+        tool: z.ZodString;
+        input: z.ZodUnknown;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"tool-output">;
+        callId: z.ZodString;
+        tool: z.ZodString;
+        output: z.ZodOptional<z.ZodUnknown>;
+        ref: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"tool-error">;
+        callId: z.ZodString;
+        tool: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"approval-request">;
+        callId: z.ZodString;
+        step: z.ZodString;
+        tool: z.ZodString;
+        operation: z.ZodString;
+        version: z.ZodString;
+        input: z.ZodUnknown;
+        expiresAt: z.core.$ZodBranded<z.ZodString, "Instant", "out">;
+        nonce: z.ZodString;
+        digest: z.ZodString;
+        preview: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"approval-resolved">;
+        callId: z.ZodString;
+        approved: z.ZodBoolean;
+        approver: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+        digest: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"source">;
+        sid: z.ZodString;
+        title: z.ZodString;
+        url: z.ZodOptional<z.ZodString>;
+        ref: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"data-provenance">;
+        producedAt: z.core.$ZodBranded<z.ZodString, "Instant", "out">;
+        model: z.ZodOptional<z.ZodString>;
+        sources: z.ZodOptional<z.ZodNumber>;
+        query: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        t: z.ZodLiteral<"budget-notice">;
+        exhausted: z.ZodBoolean;
+        resetsAt: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "Instant", "out">>;
+    }, z.core.$strip>], "t">, z.ZodObject<{
+        id: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type AppendedEvents = z.infer<typeof appendedEvents>;
+export declare const claimExecutionInput: z.ZodObject<{
+    threadId: z.ZodString;
+    runId: z.ZodString;
+    callId: z.ZodString;
+    operation: z.ZodString;
+    version: z.ZodString;
+    input: z.ZodUnknown;
+}, z.core.$strip>;
+export type ClaimExecutionInput = z.infer<typeof claimExecutionInput>;
+export declare const claimedExecution: z.ZodObject<{
+    claimed: z.ZodLiteral<true>;
+}, z.core.$strip>;
+//# sourceMappingURL=shapes.d.ts.map

package/dist/shapes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shapes.d.ts","sourceRoot":"","sources":["../src/shapes.ts"],"names":[],"mappings":"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"}