@byok-sdk/cloud-do 0.0.0-stage → 0.25.0-rc.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ancienttwo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,134 @@
-# Temporary Holding Version
+# @byok-sdk/cloud-do
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+This package hosts a pi-durable session in a Cloudflare Durable Object.
+It provides native SQLite storage, inline tools, wake and inbox processing,
+usage limits, settlement hooks, and transcript reads.
+
+The current source candidate is the prerelease 0.25.0-rc.1, in the nine-package
+release set with keys 0.10.0-rc.1, under the npm dist-tag `rc`. `latest` stays
+0.24.0. npm publication of the candidate is pending; source preparation does not
+establish registry or live-Host acceptance. See the
+[release notes](../../docs/releases/v0.25.0.md#version-set-and-channel).
+The package needs Node 24.15.0 or later for build tooling.
+
+## Install and subclass
+
+The following install example names the current source version, which is pending
+publication. Install an exact approved version only after registry readback, or
+use verified accepted CI tarballs for pre-publication integration. Do not use a
+workspace source import as installed-package acceptance evidence.
+
+~~~sh
+npm install @byok-sdk/cloud-do@0.25.0-rc.1
+npm install --save-dev @cloudflare/workers-types
+~~~
+
+The package is ESM. Its root entry imports cloudflare:workers.
+Run it in workerd. It cannot load in a Node process.
+
+~~~ts
+import { AgentDO, getAgentObject, getSessionObject } from '@byok-sdk/cloud-do';
+
+export class ProductAgentDO extends AgentDO {
+  protected instructions(): string {
+    return 'Use the configured platform tools.';
+  }
+}
+
+export default {
+  fetch(): Response {
+    return new Response('Not found', { status: 404 });
+  },
+};
+~~~
+
+Configure the subclass binding and SQLite migration in wrangler.jsonc:
+
+~~~json
+{
+  "name": "product-agent",
+  "main": "src/index.ts",
+  "compatibility_date": "2026-08-18",
+  "compatibility_flags": ["no_nodejs_compat", "no_nodejs_compat_v2"],
+  "durable_objects": {
+    "bindings": [{ "name": "AGENTS", "class_name": "ProductAgentDO" }]
+  },
+  "migrations": [
+    { "tag": "v1", "new_sqlite_classes": ["ProductAgentDO"] }
+  ]
+}
+~~~
+
+Consumers need @cloudflare/workers-types to resolve the ambient Workers
+module and the Durable Object types. Use ES2022 and Bundler module resolution.
+The installed-package smoke uses skipLibCheck: true, as the SDK does.
+Node compatibility is off in the tested configuration. A consumer with other
+flags must verify its complete Worker graph.
+
+## Identity and caller access
+
+The platform must authorize the tenant, workspace, agent, and session before
+it calls getSessionObject(). It must authorize the three agent identity
+fields before it calls getAgentObject().
+
+Names route storage. They do not authorize callers. The helper names use
+SHA-256 over JSON identity tuples. One session owns one named Durable Object.
+Public HTTP routing and caller access checks belong to the consumer.
+The default Worker returns HTTP 404.
+
+## Platform keys and execution
+
+Set AIPHABEE_ZAI_API_KEY and AIPHABEE_DEEPSEEK_API_KEY as Worker secrets
+for the profiles your platform uses. Each environment has its own secrets
+and Durable Object namespace. Never put key values in source or request data.
+
+The supported profiles are zai_openai and deepseek_direct. The model URLs
+and model names are fixed in this package. Cloud execution uses platform keys.
+Local BYOK keys do not enter this runtime.
+
+Configure the session and supply a dispatcher before tool execution.
+The subclass can supply instructions, createDispatcher, admitWake,
+renew, settleRun, projectInvocation, and onInvocationSettled hooks.
+The platform owns entitlement checks, billing, and external settlement.
+A terminal run precedes the settlement hook. Failed settlement is retried
+through the Durable Object alarm. The consumer must make settlement idempotent.
+
+The provider transport guards text before it enters durable storage.
+Keys are used only in auth headers. The transport rejects redirects.
+The guard checks exact keys and defined encodings. It cannot detect every
+obfuscation or short fragment. Do not treat it as caller authorization.
+
+## Storage and the public types
+
+DurableObjectSqliteDatabase adapts the Durable Object SQLite connection.
+openDurableObjectStorage has the local structural factory type
+(location: DurableObjectStorage) => Promise<Storage>.
+Storage is pi-durable's native interface. The package does not import client
+source or keys types. Its three runtime dependencies are pi-durable, pi-ai,
+and chord, each pinned to 1.0.4.
+
+The Durable Object owns the physical connection. Closing the adapter
+invalidates that adapter. It does not close the Durable Object database.
+
+This follows the async adapter in [Cloudflare Agents d6656161](https://github.com/cloudflare/agents/blob/d6656161/packages/agents/src/harness/pi/session-store.ts).
+Current upstream uses a different synchronous pi contract. Pinned pi 1.0.4 takes
+async callbacks, so `transactionSync()` cannot host its transaction callback.
+Cloudflare documents async SQL transactions on the
+[SQLite storage API](https://developers.cloudflare.com/durable-objects/api/sqlite-storage-api/).
+
+RunRow and InboxRow are public as they are. They include internal state,
+revision, admission, settlement, usage, and text-handoff fields. The API
+golden locks these types. A later breaking type cut requires a MINOR release
+under the SDK's pre-1.0 policy.
+
+## Package checks
+
+The library build emits dist/index.js and a local declaration closure.
+The dist check rejects Node builtins, missing or escaped declaration paths,
+and undeclared external type imports. A separate Wrangler dry run writes
+dist-worker. That Worker output is not in the npm package.
+
+Release verification installs a real tarball in a temporary consumer.
+It typechecks the subclass, bundles it with Wrangler, and runs its hook,
+Durable Object RPC, identity helper, and SQLite adapter in real workerd.
+The same smoke runs in the Linux, macOS, and Windows release-pack jobs.

package/dist/admission.d.ts

@@ -0,0 +1,9 @@
+import { type PlatformProfileId } from './platform-credentials';
+export interface CloudSubmission {
+    readonly instruction: string;
+    readonly profile: PlatformProfileId;
+}
+/** Best effort, not a claim that arbitrary or obfuscated keys can be recognized. */
+export declare function hasUserKeyShape(text: string): boolean;
+/** Frozen schema for the only 4b operation. No open metadata/config bags, no stripping. */
+export declare function admitCloudSubmission(input: unknown): CloudSubmission;

package/dist/agent-do.d.ts

@@ -0,0 +1,86 @@
+import { DurableObject } from 'cloudflare:workers';
+import { type PlatformProfileId } from './platform-credentials';
+import { SessionRuntime, type CloudRenewRequest, type CloudRenewResult, type CloudRunSettlement } from './session-runtime';
+import type { CloudToolDispatcher } from './tools';
+import type { InvocationTerminalState, InvocationRow } from './invocation-ledger';
+import { type AdmissionIdentity, type InboxRow, type TranscriptCursor, type TranscriptRun } from './cloud-state';
+import { type CloudWakeAdmission } from './wake-runner';
+export { CLOUD_HARNESS_SETTINGS } from './session-runtime';
+/** One named DO owns one Harness; 4b adds platform-only text model submissions. */
+export declare class AgentDO extends DurableObject<Record<string, unknown>> {
+    #private;
+    /** The consuming Worker supplies trusted code. No executable function is persisted. */
+    protected createDispatcher(_id: string): CloudToolDispatcher | undefined;
+    /** Post-commit notification. Consumer failures never change the invocation outcome. */
+    protected onInvocationSettled(_id: string, _state: InvocationTerminalState): void | Promise<void>;
+    protected projectInvocation(_row: InvocationRow): {
+        key: string;
+        dataJson: string;
+    } | undefined;
+    /** The consumer owns billing truth and fences every pending admission key on release. */
+    protected admitWake(_items: readonly InboxRow[], _signal: AbortSignal, _key: string, _admission: AdmissionIdentity): CloudWakeAdmission | Promise<CloudWakeAdmission>;
+    protected instructions(_profile: PlatformProfileId): string | undefined;
+    protected renew(_request: CloudRenewRequest, _signal: AbortSignal): CloudRenewResult | Promise<CloudRenewResult>;
+    protected settleRun(_run: CloudRunSettlement, _signal: AbortSignal): void | Promise<void>;
+    protected sessionRuntime(): SessionRuntime;
+    configureSession(input: unknown): Promise<Response>;
+    readInvocation(id: string): Promise<InvocationRow | undefined>;
+    enqueue(input: unknown): Promise<Response>;
+    /** The platform supplies retryCount. This handler never replaces a live owner. */
+    alarm(info?: AlarmInvocationInfo): Promise<void>;
+    events(input?: {
+        after?: number;
+    }): Promise<Response>;
+    readSnapshot(): Promise<{
+        highWater: number;
+        trimmedThrough: number;
+        inbox: InboxRow[];
+        runs: import("./cloud-state").RunRow[];
+        invocations: Array<Pick<InvocationRow, 'seq' | 'invocationId' | 'toolName' | 'state' | 'errorCode'>>;
+    }>;
+    readRuns(input?: {
+        after?: number;
+        limit?: number;
+    }): Promise<import("./cloud-state").RunRow[]>;
+    readInbox(input?: {
+        after?: number;
+        limit?: number;
+    }): Promise<InboxRow[]>;
+    readInvocations(input?: {
+        after?: number;
+        limit?: number;
+    }): Promise<Pick<InvocationRow, "errorCode" | "invocationId" | "seq" | "state" | "toolName">[]>;
+    readTranscript(input?: {
+        after?: TranscriptCursor;
+        limit?: number;
+    }): Promise<{
+        runs: TranscriptRun[];
+        items: import("./cloud-state").TranscriptItem[];
+        next: TranscriptCursor;
+    }>;
+    readRunOutput(conversationId: number, input?: {
+        entryId?: number;
+        offset?: number;
+    }): Promise<{
+        entryId: import("@earendil-works/pi-durable").EntryId;
+        offset: number;
+        nextOffset: number;
+        done: boolean;
+        text: string;
+    }>;
+    cancelActiveRun(): Promise<Response>;
+    cancelInboxItem(seq: number): Promise<Response>;
+    open(): Promise<{
+        scheduling: "closing" | "paused" | "running";
+    }>;
+    /** D1: every call allocates a new ownerless conversation, including after a restart. */
+    openExecution(): Promise<{
+        conversationId: number;
+    }>;
+    /** Passive native pi entries prove storage without starting a model or tool task. */
+    appendExecution(conversationId: number, text: string): Promise<void>;
+    readExecution(conversationId: number): Promise<string[]>;
+    /** Binding/RPC-only. The consumer authorizes identity before obtaining this stub.
+     * Errors are structured Responses so the same code/status survive DO RPC. */
+    submit(input: unknown): Promise<Response>;
+}

package/dist/cloud-state.d.ts

@@ -0,0 +1,231 @@
+import { type CloudDoErrorCode } from './errors';
+import { type CloudInboxAdmission, type InboxSource } from './inbox-admission';
+import type { CloudOperationGuard } from './input-guard';
+import type { ExecutionRow, InvocationRow } from './invocation-ledger';
+import type { PlatformProfileId } from './platform-credentials';
+export type InboxState = 'queued' | 'running' | 'done' | 'failed' | 'interrupted' | 'cancelled' | 'expired';
+export interface InboxRow {
+    seq: number;
+    dedupKey: string;
+    payloadDigest: string;
+    source: InboxSource;
+    profile: PlatformProfileId;
+    payloadJson: string | null;
+    availableAt: number;
+    expiresAt: number;
+    state: InboxState;
+    runId: number | null;
+    attempts: number;
+    errorCode: CloudDoErrorCode | null;
+    createdAt: number;
+    settledAt: number | null;
+    inputDurable: number;
+    revision: number | null;
+}
+export interface RunRow extends ExecutionRow {
+    trigger: 'submit' | 'wake';
+    requestId: string | null;
+    submissionId: number | null;
+    state: 'starting' | 'running' | 'completed' | 'failed' | 'interrupted';
+    errorCode: CloudDoErrorCode | null;
+    startedAt: number | null;
+    settledAt: number | null;
+    reservation: 'none' | 'pending' | 'held' | 'released';
+    eligibilityJson: string | null;
+    admissionDigest: string | null;
+    admittedSeqs: string | null;
+    settlementAck: number | null;
+    revision: number | null;
+    membershipPending: number | null;
+}
+export interface TranscriptCursor {
+    horizon: number;
+    run: number | null;
+    item: number | null;
+}
+export interface TranscriptTurn {
+    seq: number;
+    runId: number | null;
+    state: InboxState | null;
+    errorCode: CloudDoErrorCode | null;
+    revision: number | null;
+    text: string | null;
+}
+export interface TranscriptItem {
+    seq: number;
+    dedupKey: string;
+    state: InboxState;
+    errorCode: CloudDoErrorCode | null;
+    runId: number | null;
+    attempts: number;
+    revision: number | null;
+    text: string | null;
+}
+export interface TranscriptInvocation {
+    invocationId: string;
+    toolName: string;
+    state: InvocationRow['state'];
+    errorCode: CloudDoErrorCode | null;
+    revision: number | null;
+}
+export interface TranscriptRun {
+    nativeRunId: number;
+    revision: number | null;
+    state: RunRow['state'];
+    errorCode: CloudDoErrorCode | null;
+    trigger: RunRow['trigger'];
+    settlementAck: boolean;
+    claimedSeqs: number[];
+    turns: TranscriptTurn[];
+    text?: string;
+    truncated?: boolean;
+    invocations: TranscriptInvocation[];
+}
+export interface TranscriptPlan {
+    runs: Array<{
+        run: RunRow;
+        turns: TranscriptTurn[];
+        invocations: TranscriptInvocation[];
+    }>;
+    items: TranscriptItem[];
+    next: TranscriptCursor;
+}
+export interface AdmissionIdentity {
+    digest: string;
+    seqs: number[];
+}
+export interface CloudEventRow {
+    seq: number;
+    eventKey: string;
+    type: string;
+    conversationId: number | null;
+    ref: string | null;
+    dataJson: string;
+    createdAt: number;
+}
+export interface CloudEventInput {
+    eventKey: string;
+    type: string;
+    conversationId?: number;
+    ref?: string;
+    data: Record<string, unknown>;
+    createdAt?: number;
+}
+export interface CloudEventMeta {
+    trimmedThrough: number;
+    highWater: number;
+}
+export interface SchedulingState {
+    busy?: boolean;
+    repairRetrying?: boolean;
+}
+export interface RunSettlement {
+    state: 'completed' | 'failed' | 'interrupted';
+    errorCode?: CloudDoErrorCode;
+    text?: string;
+    entryId?: number;
+    /** The caller derives this only from the durable pre-recovery eligibility snapshot. */
+    requeue?: boolean;
+}
+export interface RunHistory {
+    input: unknown;
+    reply: string;
+}
+export interface InboxInput {
+    seq: number;
+    source: InboxSource;
+    text: string;
+}
+export type InvocationProjection = (row: InvocationRow) => {
+    key: string;
+    dataJson: string;
+} | undefined;
+export declare const CLOUD_CONTEXT_BYTES = 48000;
+export declare function inboxInput(rows: readonly InboxRow[]): InboxInput[];
+export declare function admissionIdentity(rows: readonly InboxRow[]): AdmissionIdentity;
+/** Accept only the committed native wake input shape. */
+export declare function runInputSeqs(entries: readonly unknown[]): number[];
+/** Fit inbox first. Add the newest history prefix, then emit it in chronological order. */
+export declare function composeCloudInput(rows: readonly InboxRow[], historyNewestFirst?: readonly RunHistory[]): string;
+export declare function utf8Prefix(text: string, maxBytes: number): string;
+/** Visible SQL state. Sync helpers can participate in the caller's transaction. */
+export declare class CloudState {
+    private readonly storage;
+    private scheduling;
+    constructor(storage: DurableObjectStorage);
+    private rows;
+    ensureSchema(): void;
+    private migrate;
+    readInboxItem(seq: number): InboxRow | undefined;
+    run(conversationId: number): RunRow | undefined;
+    unsettledRuns(): RunRow[];
+    completedRuns(): RunRow[];
+    invocationRowsForRun(id: number): InvocationRow[];
+    private stamp;
+    claimedSeqs(id: number): number[];
+    markInputDurable(id: number, seqs: readonly number[]): void;
+    pendingBackfills(before?: number): RunRow[];
+    applyBackfill(id: number, seqs: readonly number[]): void;
+    unackedRuns(): RunRow[];
+    ackSettlement(id: number, guard: CloudOperationGuard, now?: number): boolean;
+    /** Read-only preflight also works before this DO has initialized its schema. */
+    validateEnqueue(input: CloudInboxAdmission, guard: CloudOperationGuard, now?: number): void;
+    private enqueueIdentity;
+    enqueue(input: CloudInboxAdmission, guard: CloudOperationGuard, now?: number, options?: SchedulingState): Promise<{
+        accepted: boolean;
+        row: InboxRow;
+    }>;
+    /** Selection never skips another profile or a prefix item that exceeds the budget. */
+    selectBatch(now?: number, guard?: CloudOperationGuard): InboxRow[];
+    startRun(id: number, trigger: 'submit' | 'wake', deadlineAt: number, guard: CloudOperationGuard, now?: number): RunRow;
+    markRunning(id: number, guard: CloudOperationGuard, now?: number): void;
+    recordSubmission(id: number, submissionId: number): void;
+    markReservation(id: number, reservation: RunRow['reservation'], guard: CloudOperationGuard, now?: number, admission?: AdmissionIdentity): void;
+    captureEligibility(originalStale?: ReadonlySet<number>): RunRow[];
+    claim(id: number, seqs: readonly number[], profile: PlatformProfileId, guard: CloudOperationGuard, now?: number): InboxRow[];
+    private settleItem;
+    failQueued(seqs: readonly number[], code: CloudDoErrorCode, guard: CloudOperationGuard, now?: number): void;
+    cancelQueued(seq: number, guard: CloudOperationGuard, now?: number): InboxRow | undefined;
+    expireQueued(guard: CloudOperationGuard, now?: number): number;
+    settleRun(id: number, outcome: RunSettlement, guard: CloudOperationGuard, now?: number): RunRow | undefined;
+    /** The caller must wrap this and its state write in one transaction. */
+    appendEvent(event: CloudEventInput, guard: CloudOperationGuard): CloudEventRow;
+    eventMeta(): CloudEventMeta;
+    eventPage(after: number, limit?: number): CloudEventRow[];
+    private pageLimit;
+    /** Capture ownership and payloads before any asynchronous pi context read. */
+    planTranscript(after: TranscriptCursor | undefined, limit: number): TranscriptPlan;
+    readRun(id: number): RunRow | undefined;
+    readRuns(options?: {
+        after?: number;
+        limit?: number;
+    }): RunRow[];
+    readInbox(options?: {
+        after?: number;
+        limit?: number;
+    }): InboxRow[];
+    readInvocations(options?: {
+        after?: number;
+        limit?: number;
+    }): Array<Pick<InvocationRow, 'seq' | 'invocationId' | 'toolName' | 'state' | 'errorCode'>>;
+    private pageAfter;
+    snapshot(): {
+        highWater: number;
+        trimmedThrough: number;
+        inbox: InboxRow[];
+        runs: RunRow[];
+        invocations: Array<Pick<InvocationRow, 'seq' | 'invocationId' | 'toolName' | 'state' | 'errorCode'>>;
+    };
+    setDelivery(id: string, state: 'delivered' | 'undelivered', taskId: number | null, entryId: number | null, guard: CloudOperationGuard, now?: number): void;
+    projectInvocation(row: InvocationRow, project: InvocationProjection | undefined, guard: CloudOperationGuard, now?: number): void;
+    private projectionFailed;
+    private trimPrefix;
+    retention(now?: number): {
+        events: number;
+        inbox: number;
+    };
+    setSchedulingState(options: SchedulingState): void;
+    nextAlarm(now?: number, busy?: boolean): number | null;
+    /** This is the only alarm mutation path. Async enqueue calls it inside its storage transaction. */
+    rearmAlarm(options?: SchedulingState, now?: number): Promise<void>;
+}

package/dist/errors.d.ts

@@ -0,0 +1,41 @@
+declare const status: {
+    readonly CLOUD_REQUEST_INVALID: 400;
+    readonly CLOUD_INBOX_FULL: 429;
+    readonly CLOUD_INBOX_CONFLICT: 409;
+    readonly CLOUD_INBOX_EXPIRED: 409;
+    readonly CLOUD_INBOX_TOO_LARGE: 400;
+    readonly CLOUD_WAKE_EXHAUSTED: 409;
+    readonly CLOUD_WAKE_EMPTY: 409;
+    readonly CLOUD_EVENT_CURSOR_EXPIRED: 410;
+    readonly CLOUD_EVENTS_BUSY: 429;
+    readonly CLOUD_USER_CREDENTIAL_REJECTED: 400;
+    readonly CLOUD_MODEL_CREDENTIAL_UNAVAILABLE: 503;
+    readonly CLOUD_MODEL_RESPONSE_REJECTED: 502;
+    readonly CLOUD_MODEL_REQUEST_FAILED: 502;
+    readonly CLOUD_SESSION_CONFLICT: 409;
+    readonly CLOUD_TOOL_NOT_AVAILABLE: 400;
+    readonly CLOUD_TOOL_INVOCATION_CONFLICT: 409;
+    readonly CLOUD_TOOL_ARGUMENT_INVALID: 400;
+    readonly CLOUD_TOOL_LIMIT: 400;
+    readonly CLOUD_STEP_LIMIT: 400;
+    readonly CLOUD_BUDGET_EXCEEDED: 400;
+    readonly CLOUD_TOOL_RESULT_LIMIT: 502;
+    readonly CLOUD_TOOL_USAGE_INVALID: 502;
+    readonly CLOUD_TOOL_BUSY: 409;
+    readonly CLOUD_TOOL_TIMEOUT: 504;
+    readonly CLOUD_EXECUTION_TIMEOUT: 504;
+    readonly CLOUD_EXECUTION_INTERRUPTED: 409;
+    readonly CLOUD_EXECUTION_ABORTED: 409;
+    readonly CLOUD_TOOL_FAILED: 502;
+};
+export type CloudDoErrorCode = keyof typeof status;
+/** Never attach an upstream exception, request, response, env, or credential. */
+export declare class CloudDoError extends Error {
+    readonly code: CloudDoErrorCode;
+    readonly status: number;
+    readonly retryable = false;
+    constructor(code: CloudDoErrorCode);
+}
+export declare function safeCloudError(error: unknown): CloudDoError;
+export declare function cloudErrorResponse(error: unknown): Response;
+export {};

package/dist/event-stream.d.ts

@@ -0,0 +1,15 @@
+import type { CloudState } from './cloud-state';
+/** A doorbell is advisory. Every delivery reads the durable SQL cursor again. */
+export declare class CloudEventDoorbell {
+    private generation;
+    private listeners;
+    ring(): void;
+    get version(): number;
+    wait(version: number, signal: AbortSignal, duration?: number): Promise<void>;
+}
+export declare class CloudEventStreams {
+    private readonly bell;
+    private readers;
+    constructor(bell: CloudEventDoorbell);
+    open(state: CloudState, after: number | undefined, waitUntil: (work: Promise<unknown>) => void): Response;
+}

package/dist/identity.d.ts

@@ -0,0 +1,15 @@
+import type { AgentDO } from './agent-do';
+export interface AgentIdentity {
+    readonly tenantId: string;
+    readonly workspaceId: string;
+    readonly agentId: string;
+}
+export interface SessionIdentity extends AgentIdentity {
+    readonly sessionId: string;
+}
+export declare function agentObjectName(identity: AgentIdentity): Promise<string>;
+/** Call only after the platform has authorized the tenant/workspace/agent identity. */
+export declare function getAgentObject(namespace: DurableObjectNamespace<AgentDO>, identity: AgentIdentity): Promise<DurableObjectStub<AgentDO>>;
+export declare function sessionObjectName(identity: SessionIdentity): Promise<string>;
+/** The consuming platform authorizes all four identity fields before this lookup. */
+export declare function getSessionObject(namespace: DurableObjectNamespace<AgentDO>, identity: SessionIdentity): Promise<DurableObjectStub<AgentDO>>;

package/dist/inbox-admission.d.ts

@@ -0,0 +1,13 @@
+import { type PlatformProfileId } from './platform-credentials';
+export type InboxSource = 'message' | 'schedule' | 'invocation';
+export interface CloudInboxAdmission {
+    readonly dedupKey: string;
+    readonly source: InboxSource;
+    readonly text: string;
+    readonly profile: PlatformProfileId;
+    readonly availableAt?: number;
+    readonly expiresAt?: number;
+}
+export declare const INBOX_DAY = 86400000;
+/** Freeze the wire schema before credential reads or storage writes. */
+export declare function admitCloudInbox(input: unknown, now?: number): CloudInboxAdmission;

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { AgentDO } from './agent-do';
+export type { CloudWakeAdmission } from './wake-runner';
+export type { InboxRow, RunRow, CloudEventRow, CloudEventMeta } from './cloud-state';
+export type { TranscriptCursor, TranscriptRun, TranscriptTurn, TranscriptItem } from './cloud-state';
+export type { CloudRenewRequest, CloudRenewResult, CloudRunSettlement } from './session-runtime';
+export { agentObjectName, getAgentObject, type AgentIdentity } from './identity';
+export { sessionObjectName, getSessionObject, type SessionIdentity } from './identity';
+export { CLOUD_SAFE_REPLAY_TOOLS, CLOUD_LIVE_IPO_TOOLS, type CloudToolResult, type CloudToolDefinition, type CloudToolDispatcher, type CloudDispatchContext, type CloudToolCallContext } from './tools';
+export { DurableObjectSqliteDatabase, openDurableObjectStorage } from './storage';
+declare const _default: {
+    fetch: () => Response;
+};
+export default _default;