@finalai/agent-provider 0.1.0

package/README.md

@@ -0,0 +1,12 @@
+# @finalai/agent-provider
+
+Contracts for custom harnesses, sandboxes, channels, and credential policies, plus
+RPC/MCP projections and conformance tools for integration authors.
+
+Implement the public provider interfaces and use `/conformance` to exercise them.
+Use leaf entrypoints for sandbox wire clients, servers, MCP adapters, and local
+channel sockets. These helpers adapt your integration to the provider contracts.
+
+`/conformance` provides harness and sandbox checks, profiles, and a reference harness.
+`/conformance/scripted-model` provides deterministic model handlers for exercising
+your integration. The `final-agents conformance` CLI runs the harness checks.

package/dist/modules/channel-context.d.mts

@@ -0,0 +1,102 @@
+import type { ContentBlock } from '@agentclientprotocol/sdk/experimental/v2';
+import * as z from 'zod';
+import { TurnPolicy, type ChannelPlatformIface } from "./channel.mjs";
+import type { JsonObject, JsonValue } from "./json.mjs";
+export declare enum ChannelPrincipalType {
+    User = "user",
+    Service = "service"
+}
+export interface ChannelAuthIface extends JsonObject {
+    principalId: string;
+    principalType: ChannelPrincipalType | `${ChannelPrincipalType}`;
+    authenticator: string;
+    attributes: JsonObject;
+}
+export declare const channelAuthSchema: z.ZodObject<{
+    principalId: z.ZodString;
+    principalType: z.ZodEnum<typeof ChannelPrincipalType>;
+    authenticator: z.ZodString;
+    attributes: z.ZodDefault<z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>>;
+}, z.core.$strip>;
+export declare const channelPrincipalMatches: (first: JsonObject | null, second: JsonObject | null) => boolean;
+export interface ChannelSendInputIface {
+    content: ContentBlock[];
+    idempotencyKey: string;
+    auth: JsonObject | null;
+    context?: string[];
+    title?: string;
+    turnPolicy?: TurnPolicy | `${TurnPolicy}`;
+}
+export interface ChannelResponseInputIface {
+    pendingId: string;
+    outcome: JsonValue;
+    auth: JsonObject | null;
+}
+export interface ChannelSessionTargetIface {
+    address?: string;
+    sessionId?: string;
+}
+export interface ChannelSessionSnapshotIface {
+    sessionId: string;
+    conversationId: string | null;
+}
+export interface ChannelCancelInputIface {
+    reason?: string;
+    throughMessageSeq?: number;
+}
+export interface ChannelSessionOperationsIface {
+    inspect(target: ChannelSessionTargetIface): Promise<ChannelSessionSnapshotIface | null>;
+    resolve(target: ChannelSessionTargetIface): Promise<string | null>;
+    send(target: ChannelSessionTargetIface, input: ChannelSendInputIface): Promise<{
+        sessionId: string;
+        turnId: string;
+        messageId: string;
+    }>;
+    respond(target: ChannelSessionTargetIface, input: ChannelResponseInputIface): Promise<{
+        resolved: boolean;
+    }>;
+    cancel(target: ChannelSessionTargetIface, input?: ChannelCancelInputIface): Promise<{
+        accepted: boolean;
+    }>;
+    close(target: ChannelSessionTargetIface): Promise<void>;
+    observe(target: ChannelSessionTargetIface, input: {
+        content: ContentBlock[];
+        idempotencyKey: string;
+    }): Promise<void>;
+    setConfigOption(target: ChannelSessionTargetIface, input: {
+        configId: string;
+        value: JsonValue;
+    }): Promise<void>;
+    park(target: ChannelSessionTargetIface): Promise<void>;
+    getState(target: ChannelSessionTargetIface): Promise<JsonObject>;
+    setState(target: ChannelSessionTargetIface, state: JsonObject): Promise<void>;
+    handoff(channel: string, target: JsonValue, input: ChannelSendInputIface): Promise<void>;
+}
+export interface ChannelSessionHandleIface {
+    inspect(): Promise<ChannelSessionSnapshotIface | null>;
+    resolveSession(): Promise<string | null>;
+    send(input: ChannelSendInputIface): ReturnType<ChannelSessionOperationsIface['send']>;
+    respond(input: ChannelResponseInputIface): ReturnType<ChannelSessionOperationsIface['respond']>;
+    cancel(input?: ChannelCancelInputIface): ReturnType<ChannelSessionOperationsIface['cancel']>;
+    close(): Promise<void>;
+    observe(input: {
+        content: ContentBlock[];
+        idempotencyKey: string;
+    }): Promise<void>;
+    setConfigOption(input: {
+        configId: string;
+        value: JsonValue;
+    }): Promise<void>;
+    park(): Promise<void>;
+    getState(): Promise<JsonObject>;
+    setState(state: JsonObject): Promise<void>;
+}
+export interface ChannelAddressContextIface {
+    from(address: string): ChannelSessionHandleIface;
+    resolveSession(address: string): Promise<string | null>;
+    attachSession(id: string): ChannelSessionHandleIface;
+    to(channel: string, target: JsonValue): {
+        send(input: ChannelSendInputIface): Promise<void>;
+    };
+}
+export declare const channelAccessors: (platform: Pick<ChannelPlatformIface, "channelSessions">) => ChannelAddressContextIface;

package/dist/modules/channel-context.mjs

@@ -0,0 +1,52 @@
+import * as z from "zod";
+import { TurnPolicy } from "./channel.mjs";
+import { jsonObjectSchema } from "./json.mjs";
+var ChannelPrincipalType = /* @__PURE__ */ ((ChannelPrincipalType2) => {
+  ChannelPrincipalType2["User"] = "user";
+  ChannelPrincipalType2["Service"] = "service";
+  return ChannelPrincipalType2;
+})(ChannelPrincipalType || {});
+const channelAuthSchema = z.object({
+  principalId: z.string().min(1),
+  principalType: z.nativeEnum(ChannelPrincipalType),
+  authenticator: z.string().min(1),
+  attributes: jsonObjectSchema.default({})
+});
+const channelPrincipalMatches = (first, second) => {
+  if (first == null || second == null) return first == null && second == null;
+  const a = channelAuthSchema.parse(first), b = channelAuthSchema.parse(second);
+  return a.principalId === b.principalId && a.principalType === b.principalType && a.authenticator === b.authenticator;
+};
+const channelAccessors = (platform) => {
+  const operations = () => {
+    if (platform.channelSessions == null)
+      throw new Error("channel session operations are unavailable");
+    return platform.channelSessions;
+  };
+  const handle = (target) => ({
+    inspect: () => operations().inspect(target),
+    resolveSession: () => operations().resolve(target),
+    send: (input) => operations().send(target, input),
+    respond: (input) => operations().respond(target, input),
+    cancel: (input) => operations().cancel(target, input),
+    close: () => operations().close(target),
+    observe: (input) => operations().observe(target, input),
+    setConfigOption: (input) => operations().setConfigOption(target, input),
+    park: () => operations().park(target),
+    getState: () => operations().getState(target),
+    setState: (state) => operations().setState(target, state)
+  });
+  return {
+    from: (address) => handle({ address }),
+    resolveSession: (address) => operations().resolve({ address }),
+    attachSession: (sessionId) => handle({ sessionId }),
+    to: (channel, target) => ({ send: (input) => operations().handoff(channel, target, input) })
+  };
+};
+export {
+  ChannelPrincipalType,
+  channelAccessors,
+  channelAuthSchema,
+  channelPrincipalMatches
+};
+//# sourceMappingURL=channel-context.mjs.map

package/dist/modules/channel-context.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/channel-context.ts"],
+  "sourcesContent": ["import type { ContentBlock } from '@agentclientprotocol/sdk/experimental/v2';\nimport * as z from 'zod';\nimport { TurnPolicy, type ChannelPlatformIface } from \"./channel.mjs\";\nimport type { JsonObject, JsonValue } from \"./json.mjs\";\nimport { jsonObjectSchema } from \"./json.mjs\";\n\nexport enum ChannelPrincipalType {\n  User = 'user',\n  Service = 'service',\n}\nexport interface ChannelAuthIface extends JsonObject {\n  principalId: string;\n  principalType: ChannelPrincipalType | `${ChannelPrincipalType}`;\n  authenticator: string;\n  attributes: JsonObject;\n}\nexport const channelAuthSchema = z.object({\n  principalId: z.string().min(1),\n  principalType: z.nativeEnum(ChannelPrincipalType),\n  authenticator: z.string().min(1),\n  attributes: jsonObjectSchema.default({}),\n});\nexport const channelPrincipalMatches = (\n  first: JsonObject | null,\n  second: JsonObject | null,\n): boolean => {\n  if (first == null || second == null) return first == null && second == null;\n  const a = channelAuthSchema.parse(first),\n    b = channelAuthSchema.parse(second);\n  return (\n    a.principalId === b.principalId &&\n    a.principalType === b.principalType &&\n    a.authenticator === b.authenticator\n  );\n};\n\nexport interface ChannelSendInputIface {\n  content: ContentBlock[];\n  idempotencyKey: string;\n  auth: JsonObject | null;\n  context?: string[];\n  title?: string;\n  turnPolicy?: TurnPolicy | `${TurnPolicy}`;\n}\n\nexport interface ChannelResponseInputIface {\n  pendingId: string;\n  outcome: JsonValue;\n  auth: JsonObject | null;\n}\n\nexport interface ChannelSessionTargetIface {\n  address?: string;\n  sessionId?: string;\n}\n\nexport interface ChannelSessionSnapshotIface {\n  sessionId: string;\n  conversationId: string | null;\n}\n\nexport interface ChannelCancelInputIface {\n  reason?: string;\n  throughMessageSeq?: number;\n}\n\nexport interface ChannelSessionOperationsIface {\n  inspect(target: ChannelSessionTargetIface): Promise<ChannelSessionSnapshotIface | null>;\n  resolve(target: ChannelSessionTargetIface): Promise<string | null>;\n  send(\n    target: ChannelSessionTargetIface,\n    input: ChannelSendInputIface,\n  ): Promise<{ sessionId: string; turnId: string; messageId: string }>;\n  respond(\n    target: ChannelSessionTargetIface,\n    input: ChannelResponseInputIface,\n  ): Promise<{ resolved: boolean }>;\n  cancel(\n    target: ChannelSessionTargetIface,\n    input?: ChannelCancelInputIface,\n  ): Promise<{ accepted: boolean }>;\n  close(target: ChannelSessionTargetIface): Promise<void>;\n  observe(\n    target: ChannelSessionTargetIface,\n    input: { content: ContentBlock[]; idempotencyKey: string },\n  ): Promise<void>;\n  setConfigOption(\n    target: ChannelSessionTargetIface,\n    input: { configId: string; value: JsonValue },\n  ): Promise<void>;\n  park(target: ChannelSessionTargetIface): Promise<void>;\n  getState(target: ChannelSessionTargetIface): Promise<JsonObject>;\n  setState(target: ChannelSessionTargetIface, state: JsonObject): Promise<void>;\n  handoff(channel: string, target: JsonValue, input: ChannelSendInputIface): Promise<void>;\n}\n\nexport interface ChannelSessionHandleIface {\n  inspect(): Promise<ChannelSessionSnapshotIface | null>;\n  resolveSession(): Promise<string | null>;\n  send(input: ChannelSendInputIface): ReturnType<ChannelSessionOperationsIface['send']>;\n  respond(input: ChannelResponseInputIface): ReturnType<ChannelSessionOperationsIface['respond']>;\n  cancel(input?: ChannelCancelInputIface): ReturnType<ChannelSessionOperationsIface['cancel']>;\n  close(): Promise<void>;\n  observe(input: { content: ContentBlock[]; idempotencyKey: string }): Promise<void>;\n  setConfigOption(input: { configId: string; value: JsonValue }): Promise<void>;\n  park(): Promise<void>;\n  getState(): Promise<JsonObject>;\n  setState(state: JsonObject): Promise<void>;\n}\n\nexport interface ChannelAddressContextIface {\n  from(address: string): ChannelSessionHandleIface;\n  resolveSession(address: string): Promise<string | null>;\n  attachSession(id: string): ChannelSessionHandleIface;\n  to(channel: string, target: JsonValue): { send(input: ChannelSendInputIface): Promise<void> };\n}\n\n// Handles resolve at operation time. Only attachSession captures a session ID.\nexport const channelAccessors = (\n  platform: Pick<ChannelPlatformIface, 'channelSessions'>,\n): ChannelAddressContextIface => {\n  const operations = () => {\n    if (platform.channelSessions == null)\n      throw new Error('channel session operations are unavailable');\n    return platform.channelSessions;\n  };\n  const handle = (target: ChannelSessionTargetIface): ChannelSessionHandleIface => ({\n    inspect: () => operations().inspect(target),\n    resolveSession: () => operations().resolve(target),\n    send: (input) => operations().send(target, input),\n    respond: (input) => operations().respond(target, input),\n    cancel: (input) => operations().cancel(target, input),\n    close: () => operations().close(target),\n    observe: (input) => operations().observe(target, input),\n    setConfigOption: (input) => operations().setConfigOption(target, input),\n    park: () => operations().park(target),\n    getState: () => operations().getState(target),\n    setState: (state) => operations().setState(target, state),\n  });\n  return {\n    from: (address) => handle({ address }),\n    resolveSession: (address) => operations().resolve({ address }),\n    attachSession: (sessionId) => handle({ sessionId }),\n    to: (channel, target) => ({ send: (input) => operations().handoff(channel, target, input) }),\n  };\n};\n"],
+  "mappings": "AACA,YAAY,OAAO;AACnB,SAAS,kBAA6C;AAEtD,SAAS,wBAAwB;AAE1B,IAAK,uBAAL,kBAAKA,0BAAL;AACL,EAAAA,sBAAA,UAAO;AACP,EAAAA,sBAAA,aAAU;AAFA,SAAAA;AAAA,GAAA;AAUL,MAAM,oBAAoB,EAAE,OAAO;AAAA,EACxC,aAAa,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EAC7B,eAAe,EAAE,WAAW,oBAAoB;AAAA,EAChD,eAAe,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EAC/B,YAAY,iBAAiB,QAAQ,CAAC,CAAC;AACzC,CAAC;AACM,MAAM,0BAA0B,CACrC,OACA,WACY;AACZ,MAAI,SAAS,QAAQ,UAAU,KAAM,QAAO,SAAS,QAAQ,UAAU;AACvE,QAAM,IAAI,kBAAkB,MAAM,KAAK,GACrC,IAAI,kBAAkB,MAAM,MAAM;AACpC,SACE,EAAE,gBAAgB,EAAE,eACpB,EAAE,kBAAkB,EAAE,iBACtB,EAAE,kBAAkB,EAAE;AAE1B;AAoFO,MAAM,mBAAmB,CAC9B,aAC+B;AAC/B,QAAM,aAAa,MAAM;AACvB,QAAI,SAAS,mBAAmB;AAC9B,YAAM,IAAI,MAAM,4CAA4C;AAC9D,WAAO,SAAS;AAAA,EAClB;AACA,QAAM,SAAS,CAAC,YAAkE;AAAA,IAChF,SAAS,MAAM,WAAW,EAAE,QAAQ,MAAM;AAAA,IAC1C,gBAAgB,MAAM,WAAW,EAAE,QAAQ,MAAM;AAAA,IACjD,MAAM,CAAC,UAAU,WAAW,EAAE,KAAK,QAAQ,KAAK;AAAA,IAChD,SAAS,CAAC,UAAU,WAAW,EAAE,QAAQ,QAAQ,KAAK;AAAA,IACtD,QAAQ,CAAC,UAAU,WAAW,EAAE,OAAO,QAAQ,KAAK;AAAA,IACpD,OAAO,MAAM,WAAW,EAAE,MAAM,MAAM;AAAA,IACtC,SAAS,CAAC,UAAU,WAAW,EAAE,QAAQ,QAAQ,KAAK;AAAA,IACtD,iBAAiB,CAAC,UAAU,WAAW,EAAE,gBAAgB,QAAQ,KAAK;AAAA,IACtE,MAAM,MAAM,WAAW,EAAE,KAAK,MAAM;AAAA,IACpC,UAAU,MAAM,WAAW,EAAE,SAAS,MAAM;AAAA,IAC5C,UAAU,CAAC,UAAU,WAAW,EAAE,SAAS,QAAQ,KAAK;AAAA,EAC1D;AACA,SAAO;AAAA,IACL,MAAM,CAAC,YAAY,OAAO,EAAE,QAAQ,CAAC;AAAA,IACrC,gBAAgB,CAAC,YAAY,WAAW,EAAE,QAAQ,EAAE,QAAQ,CAAC;AAAA,IAC7D,eAAe,CAAC,cAAc,OAAO,EAAE,UAAU,CAAC;AAAA,IAClD,IAAI,CAAC,SAAS,YAAY,EAAE,MAAM,CAAC,UAAU,WAAW,EAAE,QAAQ,SAAS,QAAQ,KAAK,EAAE;AAAA,EAC5F;AACF;",
+  "names": ["ChannelPrincipalType"]
+}

package/dist/modules/channel-socket.d.mts

@@ -0,0 +1,65 @@
+import * as z from 'zod';
+import type { WebSocketChannelRouteDefinitionIface } from "./channel.mjs";
+import { type JsonValue } from "./json.mjs";
+export declare const CHANNEL_SOCKET_MAX_MESSAGE_BYTES: number;
+export declare const CHANNEL_SOCKET_MAX_LINE_BYTES: number;
+export declare enum ChannelSocketCommandKind {
+    Message = "message",
+    Close = "close",
+    Context = "context"
+}
+export declare enum ChannelSocketActionKind {
+    Accept = "accept",
+    Message = "message",
+    Close = "close",
+    Reject = "reject"
+}
+export declare const validChannelSocketClose: (code: number) => boolean;
+export declare const channelSocketCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    data: z.ZodString;
+    binary: z.ZodBoolean;
+    kind: z.ZodLiteral<ChannelSocketCommandKind.Message>;
+}, z.core.$strip>, z.ZodObject<{
+    code: z.ZodOptional<z.ZodNumber>;
+    reason: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<ChannelSocketCommandKind.Close>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<ChannelSocketCommandKind.Context>;
+    token: z.ZodString;
+}, z.core.$strip>], "kind">;
+export declare const channelSocketActionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<ChannelSocketActionKind.Accept>;
+    protocol: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+}, z.core.$strip>, z.ZodObject<{
+    data: z.ZodString;
+    binary: z.ZodBoolean;
+    kind: z.ZodLiteral<ChannelSocketActionKind.Message>;
+}, z.core.$strip>, z.ZodObject<{
+    code: z.ZodOptional<z.ZodNumber>;
+    reason: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<ChannelSocketActionKind.Close>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<ChannelSocketActionKind.Reject>;
+    status: z.ZodNumber;
+    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+    body: z.ZodString;
+}, z.core.$strip>], "kind">;
+export type ChannelSocketCommand = z.infer<typeof channelSocketCommandSchema>;
+export type ChannelSocketAction = z.infer<typeof channelSocketActionSchema>;
+export declare const channelSocketMessage: (data: string | Uint8Array) => {
+    data: string;
+    binary: boolean;
+};
+export declare const channelSocketData: (message: {
+    data: string;
+    binary: boolean;
+}) => string | Uint8Array;
+export declare const runChannelSocketHandler: (args: {
+    handler: WebSocketChannelRouteDefinitionIface["handler"];
+    context: Omit<Parameters<WebSocketChannelRouteDefinitionIface["handler"]>[0], "socket">;
+    messages: AsyncIterable<string | Uint8Array>;
+    signal: AbortSignal;
+    emit: (action: ChannelSocketAction) => void;
+}) => Promise<void>;
+export declare function readChannelSocketLines(body: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncGenerator<JsonValue>;

package/dist/modules/channel-socket.mjs

@@ -0,0 +1,188 @@
+import * as z from "zod";
+import { jsonValueSchema } from "./json.mjs";
+import { base64ToBytes, bytesToBase64 } from "./sandbox/bytes.mjs";
+const CHANNEL_SOCKET_MAX_MESSAGE_BYTES = 1024 * 1024;
+const CHANNEL_SOCKET_MAX_LINE_BYTES = 8 * 1024 * 1024;
+var ChannelSocketCommandKind = /* @__PURE__ */ ((ChannelSocketCommandKind2) => {
+  ChannelSocketCommandKind2["Message"] = "message";
+  ChannelSocketCommandKind2["Close"] = "close";
+  ChannelSocketCommandKind2["Context"] = "context";
+  return ChannelSocketCommandKind2;
+})(ChannelSocketCommandKind || {});
+var ChannelSocketActionKind = /* @__PURE__ */ ((ChannelSocketActionKind2) => {
+  ChannelSocketActionKind2["Accept"] = "accept";
+  ChannelSocketActionKind2["Message"] = "message";
+  ChannelSocketActionKind2["Close"] = "close";
+  ChannelSocketActionKind2["Reject"] = "reject";
+  return ChannelSocketActionKind2;
+})(ChannelSocketActionKind || {});
+const messageFields = { data: z.string(), binary: z.boolean() };
+const validChannelSocketClose = (code) => code === 1e3 || code === 1001 || code === 1002 || code === 1003 || code >= 1007 && code <= 1014 || code >= 3e3 && code <= 4999;
+const closeFields = {
+  code: z.number().int().refine(validChannelSocketClose).optional(),
+  reason: z.string().refine((value) => new TextEncoder().encode(value).byteLength <= 123).optional()
+};
+const channelSocketCommandSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("message" /* Message */), ...messageFields }),
+  z.object({ kind: z.literal("close" /* Close */), ...closeFields }),
+  z.object({ kind: z.literal("context" /* Context */), token: z.string() })
+]);
+const channelSocketActionSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("accept" /* Accept */),
+    protocol: z.string().optional(),
+    metadata: jsonValueSchema.optional()
+  }),
+  z.object({ kind: z.literal("message" /* Message */), ...messageFields }),
+  z.object({ kind: z.literal("close" /* Close */), ...closeFields }),
+  z.object({
+    kind: z.literal("reject" /* Reject */),
+    status: z.number().int().min(200).max(599),
+    headers: z.record(z.string(), z.string()),
+    body: z.string()
+  })
+]);
+const channelSocketMessage = (data) => {
+  const size = data instanceof Uint8Array ? data.byteLength : new TextEncoder().encode(data).byteLength;
+  if (size > CHANNEL_SOCKET_MAX_MESSAGE_BYTES)
+    throw new Error("Channel socket message exceeds 1 MiB");
+  return data instanceof Uint8Array ? { data: bytesToBase64(data), binary: true } : { data, binary: false };
+};
+const channelSocketData = (message) => {
+  const data = message.binary ? base64ToBytes(message.data) : message.data;
+  channelSocketMessage(data);
+  return data;
+};
+const runChannelSocketHandler = async (args) => {
+  args.signal.throwIfAborted();
+  let accepted = false;
+  let closed = false;
+  const socket = {
+    signal: args.signal,
+    messages: args.messages,
+    accept: (options) => {
+      args.signal.throwIfAborted();
+      if (accepted || closed) throw new Error("Channel socket already accepted or closed");
+      const protocol = options?.protocol;
+      if (protocol != null && (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(protocol) || !(args.context.request.headers.get("sec-websocket-protocol") ?? "").split(",").map((part) => part.trim()).includes(protocol)))
+        throw new Error("Channel socket selected a protocol the caller did not offer");
+      accepted = true;
+      args.emit(
+        protocol == null ? { kind: "accept" /* Accept */ } : { kind: "accept" /* Accept */, protocol }
+      );
+    },
+    send: (data) => {
+      args.signal.throwIfAborted();
+      if (!accepted || closed) throw new Error("Channel socket is not open");
+      args.emit({ kind: "message" /* Message */, ...channelSocketMessage(data) });
+    },
+    close: (code = 1e3, reason = "") => {
+      if (closed || args.signal.aborted) return;
+      if (!accepted) throw new Error("Reject the handshake with an HTTP response before accepting");
+      if (!validChannelSocketClose(code) || new TextEncoder().encode(reason).byteLength > 123)
+        throw new Error("Invalid channel socket close");
+      closed = true;
+      args.emit({ kind: "close" /* Close */, code, reason });
+    }
+  };
+  try {
+    const response = await args.handler({ ...args.context, socket });
+    if (args.signal.aborted) return;
+    if (!accepted) {
+      const rejected = response ?? new Response("No channel socket accepted", { status: 400 });
+      args.emit({
+        kind: "reject" /* Reject */,
+        status: rejected.status,
+        headers: Object.fromEntries(rejected.headers),
+        body: bytesToBase64(await readRejectionBody(rejected))
+      });
+    } else socket.close();
+  } catch {
+    if (args.signal.aborted) return;
+    if (accepted) socket.close(1011, "Channel socket failed");
+    else
+      args.emit({
+        kind: "reject" /* Reject */,
+        status: 500,
+        headers: {},
+        body: bytesToBase64(new TextEncoder().encode("Channel socket failed"))
+      });
+  }
+};
+const readRejectionBody = async (response) => {
+  if (response.body == null) return new Uint8Array();
+  const reader = response.body.getReader();
+  const chunks = [];
+  let length = 0;
+  try {
+    for (; ; ) {
+      const item = await reader.read();
+      if (item.done) break;
+      length += item.value.byteLength;
+      if (length > CHANNEL_SOCKET_MAX_MESSAGE_BYTES)
+        throw new Error("Channel socket rejection exceeds 1 MiB");
+      chunks.push(item.value);
+    }
+    const body = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+      body.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return body;
+  } finally {
+    await reader.cancel().catch(() => void 0);
+    reader.releaseLock();
+  }
+};
+async function* readChannelSocketLines(body, signal) {
+  const reader = body.getReader();
+  const cancel = () => {
+    void reader.cancel().catch(() => void 0);
+  };
+  signal?.addEventListener("abort", cancel, { once: true });
+  if (signal?.aborted === true) cancel();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  const encoder = new TextEncoder();
+  let buffer = "";
+  try {
+    for (; ; ) {
+      const item = await reader.read();
+      if (item.done) break;
+      buffer += decoder.decode(item.value, { stream: true });
+      let newline = buffer.indexOf("\n");
+      while (newline >= 0) {
+        if (encoder.encode(buffer.slice(0, newline)).byteLength > CHANNEL_SOCKET_MAX_LINE_BYTES)
+          throw new Error("Channel socket line exceeds its limit");
+        const line = buffer.slice(0, newline);
+        buffer = buffer.slice(newline + 1);
+        if (line.length > 0) yield jsonValueSchema.parse(JSON.parse(line));
+        newline = buffer.indexOf("\n");
+      }
+      if (encoder.encode(buffer).byteLength > CHANNEL_SOCKET_MAX_LINE_BYTES)
+        throw new Error("Channel socket line exceeds its limit");
+    }
+    buffer += decoder.decode();
+    if (encoder.encode(buffer).byteLength > CHANNEL_SOCKET_MAX_LINE_BYTES)
+      throw new Error("Channel socket line exceeds its limit");
+    if (buffer.length > 0) yield jsonValueSchema.parse(JSON.parse(buffer));
+  } finally {
+    signal?.removeEventListener("abort", cancel);
+    await reader.cancel().catch(() => void 0);
+    reader.releaseLock();
+  }
+}
+export {
+  CHANNEL_SOCKET_MAX_LINE_BYTES,
+  CHANNEL_SOCKET_MAX_MESSAGE_BYTES,
+  ChannelSocketActionKind,
+  ChannelSocketCommandKind,
+  channelSocketActionSchema,
+  channelSocketCommandSchema,
+  channelSocketData,
+  channelSocketMessage,
+  readChannelSocketLines,
+  runChannelSocketHandler,
+  validChannelSocketClose
+};
+//# sourceMappingURL=channel-socket.mjs.map

package/dist/modules/channel-socket.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/channel-socket.ts"],
+  "sourcesContent": ["import * as z from 'zod';\nimport type { ChannelSocketIface, WebSocketChannelRouteDefinitionIface } from \"./channel.mjs\";\nimport { jsonValueSchema, type JsonValue } from \"./json.mjs\";\nimport { base64ToBytes, bytesToBase64 } from \"./sandbox/bytes.mjs\";\n\nexport const CHANNEL_SOCKET_MAX_MESSAGE_BYTES = 1024 * 1024;\nexport const CHANNEL_SOCKET_MAX_LINE_BYTES = 8 * 1024 * 1024;\n\nexport enum ChannelSocketCommandKind {\n  Message = 'message',\n  Close = 'close',\n  Context = 'context',\n}\n\nexport enum ChannelSocketActionKind {\n  Accept = 'accept',\n  Message = 'message',\n  Close = 'close',\n  Reject = 'reject',\n}\n\nconst messageFields = { data: z.string(), binary: z.boolean() };\nexport const validChannelSocketClose = (code: number): boolean =>\n  code === 1000 ||\n  code === 1001 ||\n  code === 1002 ||\n  code === 1003 ||\n  (code >= 1007 && code <= 1014) ||\n  (code >= 3000 && code <= 4999);\n\nconst closeFields = {\n  code: z.number().int().refine(validChannelSocketClose).optional(),\n  reason: z\n    .string()\n    .refine((value) => new TextEncoder().encode(value).byteLength <= 123)\n    .optional(),\n};\nexport const channelSocketCommandSchema = z.discriminatedUnion('kind', [\n  z.object({ kind: z.literal(ChannelSocketCommandKind.Message), ...messageFields }),\n  z.object({ kind: z.literal(ChannelSocketCommandKind.Close), ...closeFields }),\n  z.object({ kind: z.literal(ChannelSocketCommandKind.Context), token: z.string() }),\n]);\nexport const channelSocketActionSchema = z.discriminatedUnion('kind', [\n  z.object({\n    kind: z.literal(ChannelSocketActionKind.Accept),\n    protocol: z.string().optional(),\n    metadata: jsonValueSchema.optional(),\n  }),\n  z.object({ kind: z.literal(ChannelSocketActionKind.Message), ...messageFields }),\n  z.object({ kind: z.literal(ChannelSocketActionKind.Close), ...closeFields }),\n  z.object({\n    kind: z.literal(ChannelSocketActionKind.Reject),\n    status: z.number().int().min(200).max(599),\n    headers: z.record(z.string(), z.string()),\n    body: z.string(),\n  }),\n]);\nexport type ChannelSocketCommand = z.infer<typeof channelSocketCommandSchema>;\nexport type ChannelSocketAction = z.infer<typeof channelSocketActionSchema>;\n\nexport const channelSocketMessage = (\n  data: string | Uint8Array,\n): { data: string; binary: boolean } => {\n  const size =\n    data instanceof Uint8Array ? data.byteLength : new TextEncoder().encode(data).byteLength;\n  if (size > CHANNEL_SOCKET_MAX_MESSAGE_BYTES)\n    throw new Error('Channel socket message exceeds 1 MiB');\n  return data instanceof Uint8Array\n    ? { data: bytesToBase64(data), binary: true }\n    : { data, binary: false };\n};\nexport const channelSocketData = (message: {\n  data: string;\n  binary: boolean;\n}): string | Uint8Array => {\n  const data = message.binary ? base64ToBytes(message.data) : message.data;\n  channelSocketMessage(data);\n  return data;\n};\n\nexport const runChannelSocketHandler = async (args: {\n  handler: WebSocketChannelRouteDefinitionIface['handler'];\n  context: Omit<Parameters<WebSocketChannelRouteDefinitionIface['handler']>[0], 'socket'>;\n  messages: AsyncIterable<string | Uint8Array>;\n  signal: AbortSignal;\n  emit: (action: ChannelSocketAction) => void;\n}): Promise<void> => {\n  args.signal.throwIfAborted();\n  let accepted = false;\n  let closed = false;\n  const socket: ChannelSocketIface = {\n    signal: args.signal,\n    messages: args.messages,\n    accept: (options) => {\n      args.signal.throwIfAborted();\n      if (accepted || closed) throw new Error('Channel socket already accepted or closed');\n      const protocol = options?.protocol;\n      if (\n        protocol != null &&\n        (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(protocol) ||\n          !(args.context.request.headers.get('sec-websocket-protocol') ?? '')\n            .split(',')\n            .map((part) => part.trim())\n            .includes(protocol))\n      )\n        throw new Error('Channel socket selected a protocol the caller did not offer');\n      accepted = true;\n      args.emit(\n        protocol == null\n          ? { kind: ChannelSocketActionKind.Accept }\n          : { kind: ChannelSocketActionKind.Accept, protocol },\n      );\n    },\n    send: (data) => {\n      args.signal.throwIfAborted();\n      if (!accepted || closed) throw new Error('Channel socket is not open');\n      args.emit({ kind: ChannelSocketActionKind.Message, ...channelSocketMessage(data) });\n    },\n    close: (code = 1000, reason = '') => {\n      if (closed || args.signal.aborted) return;\n      if (!accepted) throw new Error('Reject the handshake with an HTTP response before accepting');\n      if (!validChannelSocketClose(code) || new TextEncoder().encode(reason).byteLength > 123)\n        throw new Error('Invalid channel socket close');\n      closed = true;\n      args.emit({ kind: ChannelSocketActionKind.Close, code, reason });\n    },\n  };\n  try {\n    const response = await args.handler({ ...args.context, socket });\n    if (args.signal.aborted) return;\n    if (!accepted) {\n      const rejected = response ?? new Response('No channel socket accepted', { status: 400 });\n      args.emit({\n        kind: ChannelSocketActionKind.Reject,\n        status: rejected.status,\n        headers: Object.fromEntries(rejected.headers),\n        body: bytesToBase64(await readRejectionBody(rejected)),\n      });\n    } else socket.close();\n  } catch {\n    if (args.signal.aborted) return;\n    if (accepted) socket.close(1011, 'Channel socket failed');\n    else\n      args.emit({\n        kind: ChannelSocketActionKind.Reject,\n        status: 500,\n        headers: {},\n        body: bytesToBase64(new TextEncoder().encode('Channel socket failed')),\n      });\n  }\n};\n\nconst readRejectionBody = async (response: Response): Promise<Uint8Array> => {\n  if (response.body == null) return new Uint8Array();\n  const reader = response.body.getReader();\n  const chunks: Uint8Array[] = [];\n  let length = 0;\n  try {\n    for (;;) {\n      const item = await reader.read();\n      if (item.done) break;\n      length += item.value.byteLength;\n      if (length > CHANNEL_SOCKET_MAX_MESSAGE_BYTES)\n        throw new Error('Channel socket rejection exceeds 1 MiB');\n      chunks.push(item.value);\n    }\n    const body = new Uint8Array(length);\n    let offset = 0;\n    for (const chunk of chunks) {\n      body.set(chunk, offset);\n      offset += chunk.byteLength;\n    }\n    return body;\n  } finally {\n    await reader.cancel().catch(() => undefined);\n    reader.releaseLock();\n  }\n};\n\n// Byte streams can cross Worker RPC. Each bounded line keeps one socket message intact.\nexport async function* readChannelSocketLines(\n  body: ReadableStream<Uint8Array>,\n  signal?: AbortSignal,\n): AsyncGenerator<JsonValue> {\n  const reader = body.getReader();\n  const cancel = () => {\n    void reader.cancel().catch(() => undefined);\n  };\n  signal?.addEventListener('abort', cancel, { once: true });\n  if (signal?.aborted === true) cancel();\n  const decoder = new TextDecoder('utf-8', { fatal: true });\n  const encoder = new TextEncoder();\n  let buffer = '';\n  try {\n    for (;;) {\n      const item = await reader.read();\n      if (item.done) break;\n      buffer += decoder.decode(item.value, { stream: true });\n      let newline = buffer.indexOf('\\n');\n      while (newline >= 0) {\n        if (encoder.encode(buffer.slice(0, newline)).byteLength > CHANNEL_SOCKET_MAX_LINE_BYTES)\n          throw new Error('Channel socket line exceeds its limit');\n        const line = buffer.slice(0, newline);\n        buffer = buffer.slice(newline + 1);\n        if (line.length > 0) yield jsonValueSchema.parse(JSON.parse(line));\n        newline = buffer.indexOf('\\n');\n      }\n      if (encoder.encode(buffer).byteLength > CHANNEL_SOCKET_MAX_LINE_BYTES)\n        throw new Error('Channel socket line exceeds its limit');\n    }\n    buffer += decoder.decode();\n    if (encoder.encode(buffer).byteLength > CHANNEL_SOCKET_MAX_LINE_BYTES)\n      throw new Error('Channel socket line exceeds its limit');\n    if (buffer.length > 0) yield jsonValueSchema.parse(JSON.parse(buffer));\n  } finally {\n    signal?.removeEventListener('abort', cancel);\n    await reader.cancel().catch(() => undefined);\n    reader.releaseLock();\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["ChannelSocketCommandKind", "ChannelSocketActionKind"]
+}