@byok-sdk/client 0.11.0 → 0.12.0

package/dist/daemon/agent-egress-controller.d.ts

@@ -46,6 +46,8 @@ export declare class AgentEgressController {
     private readonly options;
     private readonly latest;
     private readonly spools;
+    private readonly spoolOpens;
+    private reliableAppendTail;
     private readonly latestStatus;
     private readonly reliableStatus;
     private readonly drops;
@@ -74,6 +76,8 @@ export declare class AgentEgressController {
     /** Missing ack capability holds records in their reliable lane; it never makes them lossy. */
     retryableReliableRecords(serverCapabilities: readonly string[]): readonly AgentReliableEgressRecord[];
     private spoolFor;
+    private bindSpool;
     private tenantPendingBytes;
+    private withAppendTail;
     private noteDrop;
 }

package/dist/daemon/auth-manager.d.ts

@@ -9,6 +9,15 @@ import type { DeviceCredentialStore, InMemoryDeviceCredentialStore } from './dev
 export declare class DeviceRevokedError extends Error {
     constructor(message?: string);
 }
+/**
+ * Thrown when the local AuthManager deadline or shutdown cancels its own
+ * in-flight request. This is deliberately distinct from `DeviceRevokedError`:
+ * only an actual challenge/token HTTP 401 is server authority for revocation.
+ */
+export declare class AuthRequestAbortedError extends Error {
+    readonly reason: 'deadline' | 'stopped';
+    constructor(reason: 'deadline' | 'stopped');
+}
 export interface AuthManagerOptions {
     serverUrl: string;
     store: DeviceStore;
@@ -23,6 +32,8 @@ export interface AuthManagerOptions {
      * permission to supersede this machine's prior active device rows.
      */
     machineId?: () => Promise<string | undefined>;
+    /** Upper bound for one pair/challenge/token fetch plus its response-body read. */
+    authRequestDeadlineMs?: number;
     /** Called once revocation is detected, so a caller (ConnectionManager) can stop retrying and surface the state instead of looping. */
     onRevoked?: () => void;
 }
@@ -42,7 +53,10 @@ export declare class AuthManager {
     private stopped;
     private pairing;
     private credentialMutationTail;
+    /** The sole cancellation authority for the request currently inside the serialized credential mutation. */
+    private activeRequest;
     private readonly credentials;
+    private readonly requestDeadlineMs;
     constructor(opts: AuthManagerOptions);
     get deviceId(): string | undefined;
     isRevoked(): boolean;
@@ -62,6 +76,12 @@ export declare class AuthManager {
     /** Always throws — `never` return type lets call sites use `if (x === 401) this.markRevoked();` without an explicit `return`/`throw` of their own. */
     private markRevoked;
     private scheduleProactiveRenewal;
+    /**
+     * Bounds one complete auth exchange rather than fetch alone. Keeping the
+     * controller active through `json()`/`text()` makes a non-cooperative or
+     * partial response body cancellable by the same authority that owns fetch.
+     */
+    private runRequest;
     private runCredentialMutation;
     /** Read the current paired authority afresh; metadata without its OS secret is re-pair required. */
     private loadRecord;

package/dist/daemon/blob-client.d.ts

@@ -1,9 +1,25 @@
 import type { BlobRef } from '@byok-sdk/protocol';
 import type { AuthManager } from './auth-manager';
+export type BlobRequestAbortReason = 'deadline' | 'cancelled';
+/** A blob request/body read did not complete before its deadline or its owner cancelled it. */
+export declare class BlobRequestAbortedError extends Error {
+    readonly reason: BlobRequestAbortReason;
+    constructor(reason: BlobRequestAbortReason);
+}
+export interface BlobClientOptions {
+    /** Bound for each individual HTTP request and response-body read. Default: 15 seconds. */
+    requestDeadlineMs?: number;
+    /** Daemon lifecycle authority; aborting it stops all in-flight blob I/O. */
+    signal?: AbortSignal;
+}
+export interface BlobRequestOptions {
+    /** Task lifecycle authority; aborting it stops this transfer before finalization. */
+    signal?: AbortSignal;
+}
 /** Seam `TaskRunner` depends on, so tests can substitute a fake without spinning up real HTTP endpoints. */
 export interface BlobResolver {
-    resolveInstruction(blobRef: BlobRef): Promise<string>;
-    uploadArtifact(content: string | Uint8Array, contentType: string, options?: {
+    resolveInstruction(blobRef: BlobRef, options?: BlobRequestOptions): Promise<string>;
+    uploadArtifact(content: string | Uint8Array, contentType: string, options?: BlobRequestOptions & {
         readonly idempotencyKey?: string;
     }): Promise<BlobRef>;
 }
@@ -16,11 +32,13 @@ export declare class BlobClient implements BlobResolver {
     #private;
     private readonly serverUrl;
     private readonly auth;
-    constructor(serverUrl: string, auth: AuthManager);
+    private readonly options;
+    private readonly requestDeadlineMs;
+    constructor(serverUrl: string, auth: AuthManager, options?: BlobClientOptions);
     /** `blobRef` -> `GET /byok/blobs/:id/url` -> fetch the presigned download URL -> text content. Always resolves fresh rather than trusting any inlined `BlobRef.url`, per docs/protocol.md §7. */
-    resolveInstruction(blobRef: BlobRef): Promise<string>;
-    /** `POST /byok/blobs` (declares size/contentType/contentHash) -> PUT the bytes to the presigned upload URL -> a `BlobRef` for `task.artifact.blobRef`. */
-    uploadArtifact(content: string | Uint8Array, contentType: string, options?: {
+    resolveInstruction(blobRef: BlobRef, options?: BlobRequestOptions): Promise<string>;
+    /** `POST /byok/blobs` -> PUT the bytes to the presigned URL -> finalize into a `BlobRef`. */
+    uploadArtifact(content: string | Uint8Array, contentType: string, options?: BlobRequestOptions & {
         readonly idempotencyKey?: string;
     }): Promise<BlobRef>;
 }

package/dist/daemon/connection-manager.d.ts

@@ -2,8 +2,10 @@ import { type CapabilityFlag, type Envelope, type RuntimeInfo, type ToolsetId }
 import { AuthManager } from './auth-manager';
 import type { CursorStore } from './cursor-store';
 import { type FleetJitter } from './deterministic-jitter';
+import { ReplayCursorTooOldError } from './replay-cursor';
 import { type BackoffOptions, type ConnectionState, type LivenessOptions } from './ws-transport';
 export type { ConnectionState } from './ws-transport';
+export { ReplayCursorTooOldError } from './replay-cursor';
 export interface ConnectionManagerOptions {
     serverUrl: string;
     deviceId: string;
@@ -35,6 +37,7 @@ export interface ConnectionManagerOptions {
     longPollIdleDelayMs?: number;
     fleetJitter?: FleetJitter;
     onOperationalOutcome?: (outcome: 'success' | 'failure', source: 'reconnect' | 'upload') => void;
+    onTerminalError?: (error: ReplayCursorTooOldError) => void;
 }
 /**
  * Owns the daemon's one logical connection to the server, which may be
@@ -119,6 +122,7 @@ export declare class ConnectionManager {
     private draining;
     private stopped;
     private revoked;
+    private terminalError;
     private settledWaiters;
     private pendingCursorSave;
     /**
@@ -249,6 +253,8 @@ export declare class ConnectionManager {
      * advertisement, and cleared across disconnect/switch boundaries.
      */
     getServerCapabilities(): readonly string[];
+    getTerminalError(): ReplayCursorTooOldError | undefined;
+    getMode(): 'ws' | 'long-poll';
     isConnected(): boolean;
     isRevoked(): boolean;
     /**
@@ -496,6 +502,7 @@ export declare class ConnectionManager {
     private onWsOutcome;
     private notifySettled;
     private enterLongPoll;
+    private enterReplayCursorTooOld;
     private exitLongPoll;
     private scheduleWsProbe;
     private enterRevoked;

package/dist/daemon/create-daemon.d.ts

@@ -91,6 +91,8 @@ export interface DaemonConfig {
     productName: string;
     productId: string;
     serverUrl: string;
+    /** Bounds one AuthManager pair/challenge/token exchange, including response-body reads. */
+    authRequestDeadlineMs?: number;
     deviceName?: string;
     /**
      * Optional override for the client-hashed physical machine identity sent

package/dist/daemon/device-credential-store.d.ts

@@ -16,6 +16,18 @@ export interface DeviceMetadata {
  * from one pairing response with metadata from another.
  */
 export type DeviceRecord = DeviceMetadata & DeviceCredentials;
+/**
+ * The one durable authority allowed before a first pairing response is
+ * received. It keeps the generated key immutable across a lost response, so
+ * an exact server-side retry can prove the same public-key binding.
+ */
+export interface FirstPairingAttempt {
+    readonly kind: 'first-pairing-attempt-v1';
+    readonly deviceName: string;
+    readonly devicePublicKey: string;
+    readonly devicePrivateKeyPem: string;
+    readonly machineId?: string;
+}
 export interface DeviceCommandResult {
     readonly exitCode: number;
     readonly stdout: string;
@@ -44,6 +56,8 @@ export declare class DeviceCredentialStore {
     #private;
     constructor(options: DeviceCredentialStoreOptions);
     read(): Promise<DeviceRecord | undefined>;
+    readFirstPairingAttempt(): Promise<FirstPairingAttempt | undefined>;
+    saveFirstPairingAttempt(attempt: FirstPairingAttempt): Promise<void>;
     replace(record: DeviceRecord): Promise<void>;
     /** Returns true only after the sole secret authority is confirmed absent. */
     clear(): Promise<boolean>;
@@ -52,6 +66,8 @@ export declare class DeviceCredentialStore {
 export declare class InMemoryDeviceCredentialStore {
     #private;
     read(): Promise<DeviceRecord | undefined>;
+    readFirstPairingAttempt(): Promise<FirstPairingAttempt | undefined>;
+    saveFirstPairingAttempt(attempt: FirstPairingAttempt): Promise<void>;
     replace(record: DeviceRecord): Promise<void>;
     clear(): Promise<boolean>;
 }

package/dist/daemon/long-poll-transport.d.ts

@@ -1,5 +1,6 @@
 import { type Envelope } from '@byok-sdk/protocol';
 import { AuthManager } from './auth-manager';
+import { ReplayCursorTooOldError } from './replay-cursor';
 import { type TransportEndpoint } from './url';
 /**
  * A long-poll request failed in a way that today told the caller only
@@ -41,6 +42,8 @@ export interface LongPollClientOptions {
     onServerCapabilities?: (capabilities: string[]) => void;
     /** Called once the device is found to be revoked (401 surfaced through {@link AuthManager}) — the loop stops itself rather than retrying. */
     onRevoked?: () => void;
+    /** Called when the server cannot replay the durable cursor supplied to this poll. */
+    onReplayCursorTooOld?: (error: ReplayCursorTooOldError) => void;
     /**
      * M4 Phase 4 (version-negotiation drill fix), scope narrowed by finding F1:
      * called ONLY for a batch entry that failed to parse because its `type`

package/dist/daemon/replay-cursor.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The server retained no contiguous replay history after the cursor the
+ * daemon acknowledged. This is terminal for the current device enrollment:
+ * retrying the same cursor can only repeat the loss condition.
+ */
+export declare class ReplayCursorTooOldError extends Error {
+    readonly recoverableFrom?: number | undefined;
+    constructor(recoverableFrom?: number | undefined);
+}

package/dist/daemon/task-runner.d.ts

@@ -421,6 +421,7 @@ export declare class TaskRunner {
     private readonly deps;
     private readonly tasks;
     private readonly pendingMessageTasks;
+    private readonly messageOutboxesByHome;
     private readonly messageContextByToken;
     private readonly messageContextByTask;
     private readonly memoryContextByToken;
@@ -481,6 +482,8 @@ export declare class TaskRunner {
      * costs nothing.
      */
     private readonly inFlightOffers;
+    /** Blob I/O before an offer becomes an active task still belongs to that offer's cancellation authority. */
+    private readonly inFlightBlobAborts;
     /**
      * Finding P2 (Fix 2c): taskIds that have reached a terminal outcome
      * (Complete/Failed/Cancelled) this session — populated in `finish()`.
@@ -592,6 +595,7 @@ export declare class TaskRunner {
     }>;
     /** Restore activated, unaccepted message drafts before transport admission on daemon restart. */
     recoverAgentMessageOutboxes(agentsRoot: string): Promise<void>;
+    private agentMessageOutbox;
     /** Retry stable recovered records after a transport handshake/re-handshake. */
     retryRecoveredAgentMessages(): void;
     private sendAgentMessageRecord;

package/dist/daemon/url.d.ts

@@ -23,6 +23,12 @@ export interface TransportEndpoint {
 }
 /** The single construction site for {@link TransportEndpoint} — see that interface's own doc comment for why it is the only one. */
 export declare function describeEndpoint(transport: TransportEndpoint['transport'], url: string | URL): TransportEndpoint;
+/**
+ * The only URL projection used by validation errors. Reading from the parsed
+ * structure means userinfo, query, and fragment never enter the diagnostic.
+ */
+/** The sole secret-safe projection for a configured server URL diagnostic. */
+export declare function formatServerUrl(value: string | URL): string;
 /**
  * M5: thrown by {@link assertServerUrlAllowed} — see that function's own doc
  * comment for the full allow/deny rule this names. Deliberately ONE error
@@ -68,7 +74,7 @@ export interface AssertServerUrlAllowedOptions {
  *    `localhost` or any `*.localhost` subdomain, an IPv4 literal in
  *    `127.0.0.0/8`, or the IPv6 loopback `::1` — see {@link isLoopbackHostname}.
  *  - `http:`/`ws:` to any other host — refused with a clear, typed
- *    {@link InsecureServerUrlError} naming the offending URL and the fix
+ *    {@link InsecureServerUrlError} naming the redacted scheme/host/path and the fix
  *    (use `wss:`/`https:`, or pass `dangerouslyAllowInsecureRemote: true` if
  *    this is a deliberate, understood exception) — UNLESS
  *    `opts.dangerouslyAllowInsecureRemote` is `true`.

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export type { AgentRef } from './agent-home';
 export { AgentHomeError, AgentRefValidationError, AgentHomeResolutionError, AgentHomeCollisionError, AgentHomeBusyError, AgentHomeLeaseCorruptError, AgentHomeLayout, AgentHomeLeaseManager, AgentHomeManager, createAgentHomeProjection, createAgentHomeProjectionConsumer, AGENT_HOME_PROJECTION_STATE_FILE, stableAgentHomeOwnerId, validateAgentRef, } from './agent-home';
 export { AgentSessionHandoffStore, AgentSessionHandoffStoreError, AgentSessionHandoffCorruptError, AgentSessionHandoffMismatchError, } from './daemon/agent-session-handoff-store';
 export type { AgentSessionHandoff, AgentSessionHandoffMatch, AgentTaskTerminalEvidence, AgentTaskTerminalMatch, AgentTerminalCause, } from './daemon/agent-session-handoff-store';
-export type { AgentHomeResolution, AgentHomeProjection, AgentHomeProjectionInput, AgentHomeProjectionApplyInput, AgentHomeProjectionFunction, AgentHomeProjectionApplyFunction, AgentHomeLease, AgentHomeBinding, } from './agent-home';
+export type { AgentHomeResolution, AgentHomeProjection, AgentHomeProjectionInput, AgentHomeProjectionApplyInput, AgentHomeProjectionFunction, AgentHomeProjectionApplyFunction, AgentHomeLease, AgentHomeBinding, AgentHomeExecutionLease, AgentHomeExecutionBinding, } from './agent-home';
 export { localStateRelocation, LocalStateRelocationError, LocalStateRelocationBusyError, LocalStateRelocationIntegrityError, } from './local-state-relocation';
 export type { LocalStateRelocationInput, LocalStateRelocationLease, } from './local-state-relocation';
 export { PolicyUnsupportedError, SteerUnsupportedError, freezeRuntimeAdapterDescriptor, sealRuntimeOperationManifest } from './types';
@@ -62,8 +62,9 @@ export type { InstallSkillPacksOptions, InstalledSkillPack, ProjectedSkillPack,
 export { TruthMemoryClient, TruthMemoryClientError } from './daemon/truth-memory-client';
 export type { LocalMemoryFilter, MemorySelector, TruthManifestQueryInput, TruthManifestRecord, TruthMemoryClientErrorCode, TruthMemoryClientOptions, TruthMemoryMetric, TruthSnapshotCandidateInput, TruthSnapshotWriteInput, TruthTerminalWriteInput, TruthWriteBody, TruthWriteResult, VerifiedTruthRecord, } from './daemon/truth-memory-client';
 export type { ConnectionState } from './daemon/ws-transport';
-export { BlobClient } from './daemon/blob-client';
-export type { BlobResolver } from './daemon/blob-client';
+export { ReplayCursorTooOldError } from './daemon/replay-cursor';
+export { BlobClient, BlobRequestAbortedError } from './daemon/blob-client';
+export type { BlobClientOptions, BlobRequestAbortReason, BlobRequestOptions, BlobResolver } from './daemon/blob-client';
 export { DaemonObserver } from './daemon/observer';
 export type { DaemonEvent, DaemonEventKind, DaemonEventListener, DaemonTaskInfo, Unsubscribe } from './daemon/observer';
 export { createServiceLifecycle, UnsupportedServicePlatformError } from './lifecycle/create-service-lifecycle';