@cortexkit/subc-client 0.5.0 → 0.8.1

package/src/provider.ts

@@ -7,6 +7,7 @@ import {
   type ReconnectBackoff,
   type RequestOptions,
   type RouteTarget,
+  type SubcCallErrorKind,
 } from "./client.js";
 import { ConnectionFileError, readConnectionFile, type ConnectionInfo } from "./connection-file.js";
 import {
@@ -33,6 +34,7 @@ import {
   SocketWriteNotQueuedError,
   SocketWriteQueuedError,
   SubcSocket,
+  writeBorrowed,
 } from "./socket.js";
 
 const DEFAULT_HANDSHAKE_TIMEOUT_MS = 10_000;
@@ -53,7 +55,6 @@ export type ObservabilityKind = "snapshot" | "stream";
 export type InternalTransport = "bulk";
 export type StorageKind = "sqlite";
 export type StorageScope = "project";
-export type LeaseScope = "project";
 export type HealthStatus = "ok" | "degraded" | "failing";
 
 export interface HealthReport {
@@ -69,7 +70,6 @@ export interface ManifestInput {
   trust_tier: TrustTier;
   provides: ProviderRoleInput[];
   consumes: ConsumerRoleInput[];
-  scheduled_tasks: ScheduledTaskInput[];
   bindings: BindingsInput;
 }
 
@@ -97,6 +97,7 @@ export type ProviderRoleInput =
       config_schema: unknown;
       observability: ObservabilitySurfaceInput[];
       identity_scope: IdentityScope[];
+      concurrency: Concurrency;
     }
   | {
       role: "internal_service";
@@ -133,31 +134,6 @@ export type ConsumerRoleInput =
   | { role: "llm_client"; via: string; auth: string }
   | { role: "service_client"; of: string[] };
 
-export interface ScheduledTaskInput {
-  task_id: string;
-  eligibility: TaskEligibilityInput;
-  lease_scope: LeaseScope;
-  renews_during_calls: boolean;
-  toolset: string[];
-  model_policy: ModelPolicyInput;
-  step_cap: number;
-  circuit_breaker: CircuitBreakerInput;
-}
-
-export interface TaskEligibilityInput {
-  cooldown: string;
-  window: string;
-}
-
-export interface ModelPolicyInput {
-  tier: string;
-  fallback_chain: string[];
-}
-
-export interface CircuitBreakerInput {
-  identical_failures: number;
-}
-
 export interface BindingsInput {
   storage: StorageBindingInput;
   vault_grants: VaultGrantInput[];
@@ -185,6 +161,7 @@ export interface ManagementSurfaceManifestOptions {
   moduleId: string;
   operations: Array<string | ManagementOperationInput>;
   moduleVersion?: string;
+  concurrency?: Concurrency;
 }
 
 /**
@@ -374,6 +351,7 @@ export class SubcProviderError extends Error {
   constructor(
     message: string,
     readonly code?: string,
+    readonly kind: SubcCallErrorKind = "terminal",
   ) {
     super(message);
   }
@@ -398,10 +376,10 @@ export function managementSurfaceManifest(opts: ManagementSurfaceManifestOptions
         config_schema: { type: "object" },
         observability: [],
         identity_scope: [],
+        concurrency: opts.concurrency ?? "module_managed",
       },
     ],
     consumes: [],
-    scheduled_tasks: [],
     bindings: {
       storage: {
         kind: "sqlite",
@@ -545,22 +523,22 @@ export class SubcProvider {
 
   cancel(handle: RouteHandle, corr: bigint): void {
     this.assertLiveHandle(handle);
-    void this.sendOn(
+    this.sendOn(
       this.sock,
       this.generation,
       buildFrame(FrameType.Cancel, controlFlags(), handle.channel, handle.epoch, corr, new Uint8Array(0)),
-    );
+    ).catch(() => undefined);
   }
 
   closeRoute(handle: RouteHandle): void {
     this.assertLiveHandle(handle);
     this.liveRoutes.delete(handle.channel);
     this.abortHandle(handle);
-    void this.sendOn(
+    this.sendOn(
       this.sock,
       this.generation,
       buildFrame(FrameType.Goodbye, controlFlags(), handle.channel, handle.epoch, 0n, new Uint8Array(0)),
-    );
+    ).catch(() => undefined);
   }
 
   /** Read the connection file, authenticate as a client, register the manifest with HELLO, and serve frames. */
@@ -888,8 +866,15 @@ export class SubcProvider {
     const releasePermit = await (this.requestGate ?? new AsyncPermitPool(DEFAULT_PROVIDER_HANDLER_CAPACITY)).acquire();
     const dataFlags = buildFlags(false, Priority.Interactive, false);
     try {
+      if (controller.signal.aborted) {
+        await this.sendError(frame, "cancelled", "request cancelled", dataFlags, sock, generation);
+        return;
+      }
       const body = await this.opts.handler(handle, frame.body, context);
-      if (controller.signal.aborted) return;
+      if (controller.signal.aborted) {
+        await this.sendError(frame, "cancelled", "request cancelled", dataFlags, sock, generation);
+        return;
+      }
       this.assertLiveHandle(handle);
       if (body === undefined) {
         await this.sendOn(
@@ -923,7 +908,11 @@ export class SubcProvider {
         throw new SubcProviderError("provider handler must return a Uint8Array or void", "invalid_handler_response");
       }
     } catch (error) {
-      if (error instanceof StaleRouteHandleError || controller.signal.aborted) return;
+      if (error instanceof StaleRouteHandleError) return;
+      if (controller.signal.aborted) {
+        await this.sendError(frame, "cancelled", "request cancelled", dataFlags, sock, generation);
+        return;
+      }
       await this.sendError(
         frame,
         error instanceof SubcProviderError && error.code ? error.code : "handler_error",
@@ -988,6 +977,10 @@ export class SubcProvider {
     sock: SubcSocket,
     generation: number,
   ): Promise<void> {
+    if (frame.header.channel !== 0) {
+      const handle = this.liveRoutes.get(frame.header.channel);
+      if (!handle || handle.epoch !== frame.header.epoch || !this.isLiveHandle(handle)) return;
+    }
     await this.sendOn(
       sock,
       generation,
@@ -1230,7 +1223,11 @@ function routeKey(handle: RouteHandle, corr: bigint): string {
 function providerErrorFromFrame(frame: Frame): SubcProviderError {
   try {
     const body = parseJson(frame.body) as { code?: string; message?: string };
-    return new SubcProviderError(body.message ?? "subc error", body.code);
+    return new SubcProviderError(
+      body.message ?? "subc error",
+      body.code,
+      body.code === "stale_route_epoch" || body.code === "unknown_channel" ? "not_sent" : "terminal",
+    );
   } catch {
     return new SubcProviderError(Buffer.from(frame.body).toString("utf8") || "subc error");
   }
@@ -1324,7 +1321,7 @@ function controlFlags(): number {
 }
 
 async function sendFrame(sock: SubcSocket, frame: Frame): Promise<void> {
-  await sock.write(encodeFrame(frame), Date.now() + WRITE_TIMEOUT_MS);
+  await writeBorrowed(sock, encodeFrame(frame), Date.now() + WRITE_TIMEOUT_MS);
 }
 
 async function expectHelloAck(sock: SubcSocket, deadline: number): Promise<ModuleHelloAckBody> {
@@ -1387,7 +1384,6 @@ function normalizeManifest(manifest: ManifestInput): ManifestInput {
     trust_tier: manifest.trust_tier,
     provides: manifest.provides.map(normalizeProviderRole),
     consumes: manifest.consumes.map(normalizeConsumerRole),
-    scheduled_tasks: manifest.scheduled_tasks.map(normalizeScheduledTask),
     bindings: {
       storage: {
         kind: manifest.bindings.storage.kind,
@@ -1448,6 +1444,7 @@ function normalizeProviderRole(role: ProviderRoleInput): ProviderRoleInput {
           kind: surface.kind,
         })),
         identity_scope: [...role.identity_scope],
+        concurrency: role.concurrency,
       };
     case "internal_service":
       return {
@@ -1471,23 +1468,3 @@ function normalizeConsumerRole(role: ConsumerRoleInput): ConsumerRoleInput {
   }
 }
 
-function normalizeScheduledTask(task: ScheduledTaskInput): ScheduledTaskInput {
-  return {
-    task_id: task.task_id,
-    eligibility: {
-      cooldown: task.eligibility.cooldown,
-      window: task.eligibility.window,
-    },
-    lease_scope: task.lease_scope,
-    renews_during_calls: task.renews_during_calls,
-    toolset: [...task.toolset],
-    model_policy: {
-      tier: task.model_policy.tier,
-      fallback_chain: [...task.model_policy.fallback_chain],
-    },
-    step_cap: task.step_cap,
-    circuit_breaker: {
-      identical_failures: task.circuit_breaker.identical_failures,
-    },
-  };
-}

package/src/socket.ts

@@ -44,6 +44,28 @@ export interface SocketWriteResult {
   completed: Promise<void>;
 }
 
+export function toWriteBuffer(bytes: Uint8Array): Buffer {
+  // Internal frame writes pass encodeFrame's fresh, single-use Uint8Array.
+  // Authentication writes likewise use fresh prefix/JSON storage and await each
+  // write without mutating it, so this view remains stable while Node drains it.
+  return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+
+const WRITE_BORROWED = Symbol("subc.socket.writeBorrowed");
+const WRITE_TRACKED_BORROWED = Symbol("subc.socket.writeTrackedBorrowed");
+
+/** @internal Write fresh, single-use internal storage without copying it. */
+export function writeBorrowed(socket: SubcSocket, bytes: Uint8Array, deadlineMs: number): Promise<void> {
+  const borrowed = socket[WRITE_BORROWED];
+  return borrowed ? borrowed.call(socket, bytes, deadlineMs) : socket.write(bytes, deadlineMs);
+}
+
+/** @internal Track a write of fresh, single-use internal storage without copying it. */
+export function writeTrackedBorrowed(socket: SubcSocket, bytes: Uint8Array, deadlineMs: number): SocketWriteResult {
+  const borrowed = socket[WRITE_TRACKED_BORROWED];
+  return borrowed ? borrowed.call(socket, bytes, deadlineMs) : socket.writeTracked(bytes, deadlineMs);
+}
+
 interface Waiter {
   need: number;
   resolve: (bytes: Uint8Array) => void;
@@ -174,8 +196,24 @@ export class SubcSocket {
   }
 
   async write(bytes: Uint8Array, deadlineMs: number): Promise<void> {
+    await this.writeBuffer(Buffer.from(bytes), deadlineMs);
+  }
+
+  writeTracked(bytes: Uint8Array, deadlineMs: number): SocketWriteResult {
+    return this.writeTrackedBuffer(Buffer.from(bytes), deadlineMs);
+  }
+
+  async [WRITE_BORROWED](bytes: Uint8Array, deadlineMs: number): Promise<void> {
+    await this.writeBuffer(toWriteBuffer(bytes), deadlineMs);
+  }
+
+  [WRITE_TRACKED_BORROWED](bytes: Uint8Array, deadlineMs: number): SocketWriteResult {
+    return this.writeTrackedBuffer(toWriteBuffer(bytes), deadlineMs);
+  }
+
+  private async writeBuffer(buffer: Buffer, deadlineMs: number): Promise<void> {
     try {
-      await this.writeTracked(bytes, deadlineMs).completed;
+      await this.writeTrackedBuffer(buffer, deadlineMs).completed;
     } catch (err) {
       if (err instanceof SocketWriteNotQueuedError || err instanceof SocketWriteQueuedError) {
         throw err.cause ?? err;
@@ -184,7 +222,7 @@ export class SubcSocket {
     }
   }
 
-  writeTracked(bytes: Uint8Array, deadlineMs: number): SocketWriteResult {
+  private writeTrackedBuffer(buffer: Buffer, deadlineMs: number): SocketWriteResult {
     if (this.closedErr) {
       return {
         queued: false,
@@ -230,7 +268,7 @@ export class SubcSocket {
       }, remaining);
 
       try {
-        this.sock.write(Buffer.from(bytes), (err) => {
+        this.sock.write(buffer, (err) => {
           settle(() => {
             if (err) {
               reject(