@byok-sdk/client 0.12.0 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byok-sdk/client",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "BYOK SDK client daemon: runs on the end user's machine, pairs with a SaaS server, and drives a local coding-agent runtime",
   "type": "module",
   "license": "MIT",
@@ -63,19 +63,20 @@
     "audit:credentials": "node scripts/linux-credential-audit.mjs",
     "clean": "rm -rf dist"
   },
+  "optionalDependencies": {
+    "koffi": "3.2.0"
+  },
   "dependencies": {
-    "@byok-sdk/core": "0.12.0",
-    "@byok-sdk/protocol": "0.12.0",
-    "@earendil-works/pi-coding-agent": "0.84.2",
+    "@byok-sdk/core": "0.14.0",
+    "@byok-sdk/protocol": "0.14.0",
+    "@earendil-works/pi-coding-agent": "0.85.1",
     "@juicesharp/rpiv-todo": "2.8.0",
     "pi-mcp-adapter": "2.27.0",
     "pi-subagents": "0.60.0",
-    "pi-web-access": "0.24.1",
-    "ws": "^8.21.1"
+    "pi-web-access": "0.24.1"
   },
   "devDependencies": {
-    "@types/ws": "^8.18.1",
-    "@byok-sdk/server": "0.12.0",
+    "@byok-sdk/server": "0.14.0",
     "@hono/node-server": "^2.0.10"
   }
 }

package/dist/daemon/ws-transport.d.ts

@@ -1,139 +0,0 @@
-import { type CapabilityFlag, type Envelope, type RuntimeInfo, type ToolsetId } from '@byok-sdk/protocol';
-import { type TransportEndpoint } from './url';
-export type ConnectionState = 'connecting' | 'open' | 'closed' | 'degraded' | 'revoked';
-/**
- * The WS upgrade itself was rejected with a non-101 HTTP status (e.g. 401 for
- * an expired/invalid bearer token). Surfaced via `onConnectOutcome` so
- * `ConnectionManager` can force a reactive token renewal before the next
- * attempt (protocol §6.2, "reactively on 401").
- *
- * Carries the {@link TransportEndpoint} the rejected upgrade was aimed at, so
- * a 401 in a log names WHICH server and path refused it instead of leaving
- * the reader to guess between a stale `serverUrl` and a genuinely expired
- * token. The endpoint's own construction is what keeps the bearer token out
- * of this message — see {@link describeEndpoint}.
- */
-export declare class WsUnexpectedStatusError extends Error {
-    readonly status: number;
-    readonly endpoint: TransportEndpoint;
-    constructor(status: number, endpoint: TransportEndpoint);
-}
-export interface BackoffOptions {
-    baseMs?: number;
-    maxMs?: number;
-    factor?: number;
-}
-export interface LivenessOptions {
-    /** Terminate and reconnect if no data/ping arrives for this long. Default 75s (server pings every 30s per the pinned heartbeat convention). */
-    timeoutMs?: number;
-    /** How often to check for silence. Default: timeoutMs/3, floored at 1s. */
-    checkIntervalMs?: number;
-}
-export interface WsTransportOptions {
-    serverUrl: string;
-    /** Resolves the current valid bearer token; called fresh before every connect attempt (initial and every reconnect) so a proactively-renewed token is always used. */
-    getToken: () => Promise<string>;
-    deviceId: string;
-    productId: string;
-    capabilities: CapabilityFlag[];
-    /** U4a Local Agent release version; the sole client-version authority. */
-    clientVersion?: string;
-    /** Detected runtimes, sent on every `conn.hello` (protocol §10 gap #4/#11). */
-    runtimes?: RuntimeInfo[];
-    /** Reads current sorted logical IDs for every hello; no executable definition crosses the wire. */
-    getConfiguredToolsets?: () => readonly ToolsetId[];
-    /** The redelivery cursor to send as `conn.hello.cursor` (protocol §9) — read fresh on every connect so a value learned mid-connection is used on the next reconnect. */
-    getCursor?: () => number | undefined;
-    onEnvelope: (envelope: Envelope) => void;
-    onStateChange?: (state: ConnectionState) => void;
-    /**
-     * Fired the moment `conn.ack` is processed and the connection becomes
-     * usable — independent of `onConnectOutcome`, which only fires on close (a
-     * healthy, still-open connection never reaches it). Carries the ack's own
-     * `capabilities` (untyped `string[]` on the wire, forward-compat — a
-     * server may advertise a flag this build doesn't recognize yet), so a
-     * caller can learn what the CURRENTLY connected server understands (e.g.
-     * the `approval_resolved` capability flag — see
-     * `ConnectionManager.getServerCapabilities`) instead of it being silently
-     * discarded after the handshake completes.
-     */
-    onAcked?: (capabilities: string[]) => void;
-    /**
-     * Fired once per connection attempt when the socket closes, reporting
-     * whether that attempt ever reached `conn.ack` (`acked`) before closing,
-     * and the causing error when the attempt failed before a socket even
-     * opened (e.g. `getToken()` rejecting). Used by `ConnectionManager` to
-     * count consecutive failures for the long-poll fallback (protocol §8).
-     *
-     * `endpoint` names the route this attempt was aimed at (computed once per
-     * `openSocket()`, so every outcome site reports the same one) — a
-     * consecutive-failure count in a log is only actionable once it says WHICH
-     * server kept refusing.
-     */
-    onConnectOutcome?: (acked: boolean, err: unknown, endpoint: TransportEndpoint) => void;
-    backoff?: BackoffOptions;
-    liveness?: LivenessOptions;
-    /** Deterministic automatic reconnect delay. Manual `connect({auto:false})` never reaches this scheduler. */
-    reconnectDelayMs?: (attempt: number, baseDelayMs: number) => number;
-}
-/**
- * One canonical authenticated capability snapshot for both transports.
- * Long-poll sends this envelope through `POST /byok/messages`; WS sends the
- * same shape as its opening frame. Keeping construction here prevents one
- * transport from silently omitting a newly added daemon capability.
- */
-export declare function createConnectionHelloEnvelope(opts: Pick<WsTransportOptions, 'deviceId' | 'productId' | 'capabilities' | 'clientVersion' | 'runtimes' | 'getConfiguredToolsets' | 'getCursor'>): Envelope;
-/**
- * The daemon's outbound-only WS connection: opens, sends `conn.hello`, waits
- * for `conn.ack`, and reconnects with capped exponential backoff + jitter on
- * drop.
- *
- * Design B (finding N4): this transport is a stateless drainer — it holds no
- * outbound queue of its own. `ConnectionManager` owns the single shared
- * outbox both transports drain from (so a transport switch never strands a
- * queued envelope); `sendNow` just attempts to hand one envelope to the
- * live socket right now and reports back whether that actually happened,
- * leaving all queueing/retry policy to the caller.
- *
- * Auto-reconnect can be paused (`stopAutoReconnect`) and single attempts
- * made on demand (`connect({ auto: false })`) — used by `ConnectionManager`
- * to probe WS recovery every few minutes while long-polling, without this
- * transport's own backoff loop fighting that cadence.
- */
-export declare class WsTransport {
-    private readonly opts;
-    private socket;
-    private closedByUser;
-    private autoReconnect;
-    private acked;
-    private everAckedThisAttempt;
-    private reconnectAttempt;
-    private reconnectTimer;
-    private livenessTimer;
-    private lastActivity;
-    private lastUnexpectedStatus;
-    private ackWaiters;
-    constructor(opts: WsTransportOptions);
-    connect(opts?: {
-        auto?: boolean;
-    }): void;
-    /** Stop scheduling further reconnect attempts (any pending one is cancelled too); the current socket, if any, is left alone. Used when handing retry ownership to a slower external cadence (e.g. the long-poll fallback's periodic WS probe). */
-    stopAutoReconnect(): void;
-    /** Resume normal auto-reconnect-on-close behavior (does not itself trigger a connect — only affects future closes). */
-    resumeAutoReconnect(): void;
-    get isOpen(): boolean;
-    /**
-     * Attempt to send ONE envelope right now; returns whether it actually went
-     * out. `false` means the socket isn't currently open+acked — the caller
-     * (`ConnectionManager.drainOutbox`, Design B/finding N4) owns re-queueing
-     * and retrying later (e.g. on the next `onAcked`), since this transport no
-     * longer buffers anything itself.
-     */
-    sendNow(envelope: Envelope): boolean;
-    waitForAck(timeoutMs?: number): Promise<void>;
-    close(): void;
-    private openSocket;
-    private scheduleReconnect;
-    private startLivenessCheck;
-    private stopLivenessCheck;
-}