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

package/dist/files.js

@@ -0,0 +1,69 @@
+/**
+ * HOST code, separate from the in-scope engine. Bind `caller` to the authenticated
+ * person and `storage` to the assistant host's system principal, in the SAME scope.
+ * Never expose `storage` itself to a browser or model tool.
+ */
+import { substratError, uploadLinkFilename } from '@substrat-run/contracts';
+export const ASSISTANT_FILE_MAX_BYTES = 10 * 1024 * 1024;
+const XLSX = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+/** A browser need not guess a spreadsheet's MIME type; the supported suffix fixes it. */
+function contentType(filename) {
+    const dot = filename.lastIndexOf('.');
+    const extension = dot < 0 ? '' : filename.slice(dot + 1).toLowerCase();
+    if (extension === 'xlsx')
+        return XLSX;
+    if (extension === 'csv')
+        return 'text/csv';
+    if (extension === 'tsv')
+        return 'text/tab-separated-values';
+    throw substratError('validation_failed', 'upload a .csv, .tsv or .xlsx file; save older Excel files as .xlsx first');
+}
+/**
+ * A host mounts these methods on its own authenticated routes. Bytes bypass invoke;
+ * ownership and audit checks go through the engine's real operation handlers.
+ * There is intentionally no automatic import: the host's tools preview a diff and
+ * use the existing approval/claim flow before changing domain entities.
+ */
+export function assistantFiles(caller, storage) {
+    const entity = (threadId) => ({ entityType: 'assistant-thread', entityId: threadId });
+    const list = async (threadId) => {
+        await caller.invoke('assistant/get-thread', { threadId });
+        return storage.list(entity(threadId));
+    };
+    return {
+        async upload(input) {
+            const filename = uploadLinkFilename.parse(input.filename);
+            const type = contentType(filename);
+            if (!input.body.byteLength || input.body.byteLength > ASSISTANT_FILE_MAX_BYTES) {
+                throw substratError('validation_failed', `a file must contain between 1 and ${ASSISTANT_FILE_MAX_BYTES} bytes`);
+            }
+            await caller.invoke('assistant/authorize-file-upload', { threadId: input.threadId });
+            return storage.upload({
+                entity: entity(input.threadId), filename, contentType: type, body: input.body, visibility: 'internal',
+            });
+        },
+        list,
+        async open(threadId, attachmentId) {
+            // Authorize and match the id BEFORE opening any bytes with the host's key.
+            const record = (await list(threadId)).find((file) => file.id === attachmentId);
+            if (!record)
+                throw substratError('not_found', `file not found in thread: ${attachmentId}`);
+            const opened = await storage.open(attachmentId);
+            if (!opened)
+                throw substratError('not_found', `file not found in thread: ${attachmentId}`);
+            return opened;
+        },
+    };
+}
+/**
+ * Trusted host lifecycle hook: remove blobs BEFORE erasing a thread's owner. The
+ * kernel's subject erasure deletes engine rows, but does not shred attachment blobs.
+ * Repeatable; failed blob deletions follow the platform's orphan-sweep policy.
+ * Do not expose as an unauthenticated route.
+ */
+export async function purgeAssistantThreadFiles(storage, threadId) {
+    for (const file of await storage.list({ entityType: 'assistant-thread', entityId: threadId })) {
+        await storage.remove(file.id);
+    }
+}
+//# sourceMappingURL=files.js.map

package/dist/files.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,356 @@
+/**
+ * engine-assistant — composed **by call**, not by event.
+ *
+ * The record of a chat between a person and an assistant. It owns the invariants of that
+ * record and nothing about the model that speaks for it: it never talks to a model, a
+ * network or a clock of its own. A host (the platform's assistant host, or a vertical that
+ * composes it) runs the loop, and calls these functions to write what happened.
+ *
+ * What the engine guarantees, each of which a test pins:
+ *
+ *   1. **The record is append-only and numbered.** Events are rows `(thread, seq)`, `seq`
+ *      from 1, never updated or removed. `seq` is the cursor a client resumes after.
+ *   2. **Only the lease holder writes the assistant's side.** `acquireRun` takes a
+ *      single-writer lease; `appendEvents` is fenced by it, so a holder that was replaced
+ *      while still running (a zombie) cannot write. A holder that stopped beating can be
+ *      replaced.
+ *   3. **A gated tool runs once, with the input the user saw.** A tool call that asks for
+ *      approval is bound to `approvalDigest` of the tagged tuple (deployed version, approver,
+ *      thread, step, call, operation, expiry, nonce, input; docs/rfc/assistant.md §6.0 point
+ *      3), and the bindings are stored beside it. `resolveApproval` RECOMPUTES that digest
+ *      with the principal who answered and the version the answer arrived under, so an
+ *      approval from anyone but the thread's subject, for another thread, call or operation,
+ *      under another deploy, or after the expiry, does not match. `claimExecution` recomputes
+ *      it with the operation and input the host is about to run, before the expiry. Both
+ *      moves are conditional writes (`… WHERE state = ? AND digest = ?`, one row changed or
+ *      refused), so single use is the record's own, not a read that came before it. A
+ *      `tool-output` for a gated call is refused unless it was claimed. The model cannot
+ *      change the arguments after the user said yes.
+ *   4. **The two sides of the record are written by different keys.** What the user did
+ *      (`user-message`, `turn-start`, `approval-resolved`) is written by `sendMessage` and
+ *      `resolveApproval` under `assistant:use`, as the owner. What the assistant did is
+ *      written by `appendEvents` under `assistant:run`, which is held by a SYSTEM principal
+ *      (the assistant host's) and by no role a person has — the manifest declares it
+ *      `holder: 'system'`, and `lint:permissions` refuses a role or entity grant shape that
+ *      grants it (tools/reserved-keys.mts). Even the run key writes only
+ *      inside a turn the user opened: with no turn open, `appendEvents` is `no_turn_open`,
+ *      so a run cannot keep a resting thread busy and lock its owner out.
+ *   5. **An event is bounded.** A body over `MAX_EVENT_BYTES` is refused: a large tool
+ *      result belongs in the operation that produced it, referred to by id, not copied into
+ *      a Durable Object row.
+ *
+ * `appendEvents` and the per-delta rows do not emit a platform event each. Forty text deltas
+ * make one answer, and an outbox row apiece would be the record written twice. The platform
+ * learns the milestones (`events.ts`).
+ *
+ * Deferred, and stated so an absence reads as intent: message branches (regenerate, edit and
+ * resend), participants other than the owner and the assistant (a human agent), the support
+ * handoff, and memory. Each is additive: a column, an event type, a table.
+ */
+import { z } from 'zod';
+import { type ModuleRegistration, type OperationContext } from '@substrat-run/kernel';
+import { threadRow } from './entities.js';
+import { type AcquireRunInput, type AppendEventsInput, type AppendedEvents, type ClaimExecutionInput, type CreateThreadInput, type EventsPage, type ListThreadsInput, type ReadEventsInput, type ReleaseRunInput, type ResolveApprovalInput, type SendMessageInput, type SentMessage, type Thread, type ThreadIdInput } from './shapes.js';
+export { MAX_EVENT_BYTES, MAX_MESSAGE_BYTES } from './shapes.js';
+export type { AcquireRunInput, AppendEventsInput, AppendedEvents, ClaimExecutionInput, CreateThreadInput, EventsPage, ListThreadsInput, ReadEventsInput, ReleaseRunInput, ResolveApprovalInput, SendMessageInput, SentMessage, Thread, ThreadIdInput, } from './shapes.js';
+export { assistantEntities, threadRow, eventRow, runRow, toolCallRow } from './entities.js';
+export { assistantOperations, ASSISTANT_PERMISSIONS } from './operations.js';
+export { type AssistantEvents, type AssistantEventType, type AssistantThreadCreatedPayload, type AssistantTurnStartedPayload, type AssistantTurnFinishedPayload, type AssistantApprovalRequestedPayload, type AssistantApprovalResolvedPayload, type AssistantThreadClosedPayload, } from './events.js';
+/**
+ * The conflict reasons this engine raises, narrowing the platform's `conflict` code (#113).
+ * Additive only: new reasons may appear, existing ones do not change spelling.
+ */
+export declare const ASSISTANT_CONFLICT_REASONS: readonly ['thread_closed', 'turn_in_progress', 'approval_pending', 'no_approval_pending', 'run_in_progress', 'run_fenced', 'not_a_run_event', 'call_state', 'approval_required', 'approval_denied', 'execution_not_claimed', 'already_executed', 'already_resolved', 'digest_mismatch', 'approval_expired', 'no_turn_open'];
+export type AssistantConflictReason = (typeof ASSISTANT_CONFLICT_REASONS)[number];
+export declare const ASSISTANT_PERM: {
+    use: string & z.$brand<"PermissionKey">;
+    audit: string & z.$brand<"PermissionKey">;
+    run: string & z.$brand<"PermissionKey">;
+};
+export declare const assistantManifest: {
+    id: string & z.$brand<"ModuleId">;
+    version: string;
+    kernelContract: string;
+    permissions: {
+        key: string & z.$brand<"PermissionKey">;
+        description: string;
+        holder?: "system" | undefined;
+    }[];
+    events: {
+        emits: {
+            type: string;
+            schemaVersion: number;
+        }[];
+        consumes: {
+            type: string;
+            schemaVersion: number;
+            from?: string | undefined;
+        }[];
+        exports?: {
+            type: string;
+            schemaVersion: number;
+            readPermission: string & z.$brand<"PermissionKey">;
+        }[] | undefined;
+    };
+    migrations: {
+        journalDir: string;
+        compatibleFrom: string;
+    };
+    attachmentTargets: {
+        entityType: string;
+        readPermission: string & z.$brand<"PermissionKey">;
+        writePermission?: (string & z.$brand<"PermissionKey">) | undefined;
+        uploadLinks?: {
+            maxBytes: number;
+            contentTypes?: string[] | undefined;
+        } | undefined;
+    }[];
+    liveTargets?: {
+        entityType: string;
+        readPermission: string & z.$brand<"PermissionKey">;
+    }[] | undefined;
+    entityRelations?: {
+        entityType: string;
+        parentType: string;
+    }[] | undefined;
+    guards?: {
+        before: string;
+        predicate: string;
+        config: Record<string, unknown>;
+    }[] | undefined;
+    schedules?: {
+        operation: string;
+        cadence: {
+            everyMinutes: number;
+        };
+        input?: Record<string, unknown> | undefined;
+        permissions: (string & z.$brand<"PermissionKey">)[];
+        purge?: {
+            entityType: string;
+        } | undefined;
+    }[] | undefined;
+    peers?: {
+        vertical: string;
+        operations: string[];
+        permissions: (string & z.$brand<"PermissionKey">)[];
+    }[] | undefined;
+    connections?: {
+        provider: string;
+        operation: string;
+        permission: string & z.$brand<"PermissionKey">;
+        options?: Record<string, unknown> | undefined;
+        bind?: "every-install" | "on-request" | undefined;
+    }[] | undefined;
+    freshness?: {
+        eventType: string;
+        within: {
+            hours: number;
+        };
+    }[] | undefined;
+    withdraws?: string[] | undefined;
+    entitlementKey: string;
+    envSpec?: {
+        key: string;
+        label?: string | undefined;
+        description: string;
+        placeholder?: string | undefined;
+        kind?: "model" | undefined;
+        required: boolean;
+        secret: boolean;
+        previewCarry?: boolean | undefined;
+        default?: string | undefined;
+        group?: string | undefined;
+    }[] | undefined;
+    ownerGrants?: (string & z.$brand<"PermissionKey">)[] | undefined;
+    entitlements?: string[] | undefined;
+    provides?: string[] | undefined;
+    requires?: string[] | undefined;
+    api?: string | undefined;
+    searchables?: {
+        entityType: string;
+        fields: string[];
+        table?: string | undefined;
+        idColumn?: string | undefined;
+        tokenizer?: "prefix" | "substring" | undefined;
+    }[] | undefined;
+    lists?: {
+        entityType: string;
+        sortable: string[];
+        filterable?: string[] | undefined;
+        table?: string | undefined;
+        idColumn?: string | undefined;
+    }[] | undefined;
+    entityStates?: {
+        archivePermission?: (string & z.$brand<"PermissionKey">) | undefined;
+        trashPermission?: (string & z.$brand<"PermissionKey">) | undefined;
+        purgeAfterDays?: number | undefined;
+        purgeEarly?: boolean | undefined;
+        table?: string | undefined;
+        idColumn?: string | undefined;
+        entityType: string;
+    }[] | undefined;
+    erasure?: {
+        tables: string[];
+        entities: {
+            entityType: string;
+            table: string;
+            mode: "blank" | "custom" | "delete" | "unreached";
+            subjects?: string[] | undefined;
+            fields: {
+                name: string;
+                blank: "" | null;
+            }[];
+        }[];
+    } | undefined;
+    updatedStamps?: {
+        table: string;
+        idColumn: string;
+        at?: string | undefined;
+        by?: string | undefined;
+        entityType: string;
+    }[] | undefined;
+    ui?: {
+        routes?: {
+            path: string;
+            screen: string;
+            permission: string & z.$brand<"PermissionKey">;
+        }[] | undefined;
+        nav?: {
+            label: string;
+            icon?: string | undefined;
+            to: string;
+            permission: string & z.$brand<"PermissionKey">;
+        }[] | undefined;
+        entityViews?: {
+            entityType: string;
+            view: string;
+        }[] | undefined;
+        widgets?: {
+            slot: string;
+            component: string;
+            permission: string & z.$brand<"PermissionKey">;
+        }[] | undefined;
+        settingsPanels?: {
+            label: string;
+            component: string;
+            permission: string & z.$brand<"PermissionKey">;
+        }[] | undefined;
+    } | undefined;
+};
+export declare const assistantMigrations: {
+    version: string;
+    sql: string;
+}[];
+type ThreadRow = z.infer<typeof threadRow>;
+/**
+ * Open a thread for the caller. The caller's principal is the subject: a thread is created
+ * for yourself, never on someone else's behalf.
+ */
+export declare function createThread(ctx: OperationContext, rawInput?: CreateThreadInput): Thread;
+/** One thread. The CALLER decides who may see it; see `assertThreadVisible`. */
+export declare function getThread(ctx: OperationContext, rawInput: ThreadIdInput): Thread;
+/**
+ * The thread, if the caller may see it: the owner, or someone holding `assistant:audit`.
+ * `not_found` otherwise, so a thread's existence is not probed.
+ */
+export declare function assertThreadVisible(ctx: OperationContext, threadId: string): Promise<ThreadRow>;
+/** Threads for one principal, most recently active first. Unpaged: a vertical folding them. */
+export declare function listThreads(ctx: OperationContext, rawInput?: ListThreadsInput & {
+    subject: string;
+}): Thread[];
+/** The record after a cursor. The CALLER decides who may read it. */
+export declare function readEvents(ctx: OperationContext, rawInput: ReadEventsInput): EventsPage;
+/**
+ * The user says something, which begins a turn. As the owner, under `assistant:use`.
+ *
+ * Refused while a turn is running (the host is mid-answer) and while an approval is waiting
+ * (the user must answer it, or deny it, first), so the record never holds two turns at once.
+ */
+export declare function sendMessage(ctx: OperationContext, rawInput: SendMessageInput): SentMessage;
+/** Ownership is required even when the caller can audit other people's threads. */
+export declare function authorizeFileUpload(ctx: OperationContext, rawInput: ThreadIdInput): Thread;
+/**
+ * The user approves or denies a gated tool call. As the owner, under `assistant:use`.
+ *
+ * An APPROVAL must carry the stored digest (the one the request showed), and that digest must
+ * equal the one RECOMPUTED from the stored bindings with the principal who is answering as
+ * the approver and `input.version` (the deployed version the host serves the answer under)
+ * as the version: an approval of anything else — another input, call, thread or operation,
+ * another approver, another deploy — is `digest_mismatch`, never a quiet approval of what is
+ * stored. One that arrives at or after the request's expiry is `approval_expired`.
+ *
+ * A DENIAL needs only the digest the user was shown, with no version or expiry: saying no
+ * runs nothing, and it is how the owner clears a request that lapsed or that a deploy made
+ * stale, which would otherwise refuse every message (`approval_pending`) for ever. A denial
+ * does not end the turn: `approval-resolved` resumes it, like an approval, and the turn stays
+ * open (`turn_in_progress` for the owner) until the host writes `turn-finish` or
+ * `turn-error`. The owner has no way to end a turn without a run; a host that does not come
+ * back leaves closing the thread as the owner's only way out, so a host must run after every
+ * answer, a denial included.
+ *
+ * Single use is the write itself: `UPDATE … WHERE state = 'awaiting-approval' AND digest = ?`,
+ * refused unless it changed exactly one row, whatever was read before it.
+ *
+ * Not fenced by the lease: a run that asked for approval has come to rest, and the user
+ * acts between runs. The host starts the next run after this returns.
+ */
+export declare function resolveApproval(ctx: OperationContext, rawInput: ResolveApprovalInput): Promise<{
+    seq: number;
+}>;
+/** Close a thread. As the owner. Nothing is appended to a closed thread. */
+export declare function closeThread(ctx: OperationContext, rawInput: ThreadIdInput): Thread;
+/**
+ * Take the single-writer lease on a thread. A holder that has beaten within `staleMs` keeps
+ * it (`run_in_progress`); one that has not can be replaced, and `tookOver` says so. The same
+ * run asking again simply refreshes its beat.
+ */
+export declare function acquireRun(ctx: OperationContext, rawInput: AcquireRunInput): {
+    tookOver: boolean;
+};
+/** Give the lease back. A run that no longer holds it releases nothing. */
+export declare function releaseRun(ctx: OperationContext, rawInput: ReleaseRunInput): {
+    released: boolean;
+};
+/**
+ * Append what the assistant said and did, fenced by the lease, and enforce the tool-call
+ * state machine on the way in.
+ *
+ *   tool-input        → `running` (a repeat of a running call is a step restart, and allowed)
+ *   approval-request  → `awaiting-approval`, with its bindings stored; the digest must be
+ *                       `approvalDigest` of those bindings with the thread's subject as the
+ *                       approver, and the expiry still ahead
+ *   tool-output       → `done`; for a gated call only from `executing`, i.e. after
+ *                       `claimExecution`
+ *   tool-error        → `failed`
+ *   turn-finish       → `awaiting-approval` only with an approval waiting, `done` only without
+ *
+ * Every event is refused (`no_turn_open`) unless a turn is open: the last event is not a
+ * resting one (`turn-finish`, `turn-error`), and the thread has at least one.
+ *
+ * `tool-error` may also fail an `approved` call that was never claimed: the host could not
+ * run it (the operation refused, the credential ended). That is the host's word, which is why
+ * the run key is a system principal's.
+ *
+ * The whole batch is in the caller's transaction: a refusal anywhere leaves none of it.
+ */
+export declare function appendEvents(ctx: OperationContext, rawInput: AppendEventsInput): Promise<AppendedEvents>;
+/**
+ * Claim the one execution of an approved tool call, with the operation, the deployed version
+ * and the input about to be run.
+ *
+ * This is the gate in front of a write: the host calls it BEFORE invoking the operation, and
+ * runs the operation only if it returns. The digest is recomputed from the stored bindings
+ * with the claim's operation, version and input and the principal who approved, and must be
+ * the one the user approved (`digest_mismatch` otherwise: the model, or a bug, changed the
+ * input, or the host is about to run another operation or under another deploy). The call
+ * must be approved (not waiting, not denied), the request's expiry still ahead
+ * (`approval_expired`: an approval is spent when it is claimed, and one not spent in time
+ * runs nothing), and not already claimed (`already_executed`), so a restarted loop cannot run
+ * a write twice — that last is the conditional write itself, `… WHERE state = 'approved'`.
+ * Fenced by the lease.
+ */
+export declare function claimExecution(ctx: OperationContext, rawInput: ClaimExecutionInput): Promise<{
+    claimed: true;
+}>;
+export declare const assistantModule: ModuleRegistration;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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