@jeffusion/bungee-core 5.19.0 → 5.21.0

package/dist/config-worker/private-transport.d.ts

@@ -17,6 +17,8 @@ export interface TrustedDataIdentity {
 export declare const INTERNAL_DATA_IDENTITY_HEADER = "x-bungee-internal-data-identity";
 export declare const INTERNAL_DATA_IDENTITY_MAC_HEADER = "x-bungee-internal-data-identity-mac";
 export declare function getTrustedDataIdentity(request: Request): TrustedDataIdentity | null;
+/** Core-only derivation: external headers cannot mint a logical generation identity. */
+export declare function deriveWorkerRequestIdentity(source: Request, derived: Request, requestId: string): void;
 export declare function signDataIdentity(identity: string, method: string, url: string, secret: string): string;
 export declare function generateWorkerTransportSecret(): string;
 export declare function parseWorkerTransportSecret(value: unknown): string;

package/dist/data-admission/errors.d.ts

@@ -1,10 +1,15 @@
+export interface DataAdmissionErrorDetails {
+    message?: string;
+    param?: string;
+}
 /** Shared inert error contract; importing it never loads admission runtime modules. */
 export declare class DataAdmissionError extends Error {
     readonly status: number;
     readonly code: string;
     readonly retryAfter?: number | undefined;
     readonly name = "DataAdmissionError";
-    constructor(status: number, code: string, retryAfter?: number | undefined);
+    readonly details?: DataAdmissionErrorDetails;
+    constructor(status: number, code: string, retryAfter?: number | undefined, details?: DataAdmissionErrorDetails);
 }
 /** Plugin bundles have their own class identity; normalize their explicit error contract. */
 export declare function normalizeAdmissionError(error: unknown): DataAdmissionError | null;

package/dist/gateway/contracts.d.ts

@@ -30,15 +30,23 @@ export interface GatewayDispatchTarget {
 }
 export interface DispatchRequestInput {
     readonly context: import('../hooks').MutableRequestContext;
-    readonly targets: readonly (GatewayDispatchTarget & {
-        readonly protocol?: LLMProtocol;
-    })[];
+    readonly targets: readonly GatewayDispatchTarget[];
     readonly principal?: import('../plugin-extensions').DataPrincipal;
     readonly signal: AbortSignal;
     readonly servingRevision?: number;
 }
+export interface DispatchConversionDiagnostic {
+    readonly param: string;
+    readonly action: 'mapped' | 'omitted';
+    readonly reason: string;
+}
 export interface DispatchRequestDecision {
     readonly target: GatewayDispatchTarget;
+    readonly protocol?: LLMProtocol;
+    readonly requiredUpstreamId?: string;
+    readonly adapter?: import('../plugin.types').Plugin; /** Canonical logical input after a protocol conversion; absent for native passthrough. */
+    readonly canonicalInput?: readonly unknown[];
+    readonly diagnostics?: readonly DispatchConversionDiagnostic[];
 }
 export interface GatewayDispatchInput extends Omit<DispatchRequestInput, 'targets'> {
     readonly config: AppConfig;
@@ -50,6 +58,11 @@ export interface GatewayDispatchDecision {
     readonly context: import('../hooks').MutableRequestContext;
     readonly entryRouteId?: string;
     readonly target?: GatewayDispatchTarget;
+    readonly requiredUpstreamId?: string;
+    readonly protocol?: LLMProtocol;
+    readonly adapter?: import('../plugin.types').Plugin;
+    readonly canonicalInput?: readonly unknown[];
+    readonly diagnostics?: readonly DispatchConversionDiagnostic[];
 }
 export interface GatewayRouteInput {
     readonly request: Request;

package/dist/gateway/forward-plugin.d.ts

@@ -30,6 +30,8 @@ export interface ProxyRequestResult {
     transportFailureCode?: () => string | undefined;
 }
 export interface ProxyAttemptOptions {
+    readonly nativeWebSocket?: boolean;
+    readonly websocketBridge?: import('../websocket').WebSocketBridge;
     readonly requestOverride?: GatewayRequestOverride;
     readonly servingRevision?: number;
     readonly attemptId: string;

package/dist/gateway/plugin.js

@@ -320,6 +320,7 @@ var init_impl = __esm(() => {
 function createPluginHooks() {
   return {
     onGatewayWebSocket: new AsyncSeriesBailHook("onGatewayWebSocket"),
+    onWebSocketSessionMode: new AsyncSeriesBailHook("onWebSocketSessionMode"),
     onWebSocketHandshake: new AsyncSeriesWaterfallHook("onWebSocketHandshake"),
     onWebSocketObservation: new WebSocketObservationHook("onWebSocketObservation"),
     onGatewayBody: new SyncBailHook("onGatewayBody"),
@@ -405,6 +406,13 @@ var init_plugin_extensions = __esm(() => {
 });
 
 // src/data-admission/errors.ts
+function safeDetails(details) {
+  if (!details)
+    return;
+  const message = typeof details.message === "string" && details.message.length <= 512 && !/[\x00-\x1f\x7f]/.test(details.message) ? details.message : undefined;
+  const param = typeof details.param === "string" && details.param.length <= 256 && /^[a-zA-Z_$][\w.$\[\]-]*$/.test(details.param) ? details.param : undefined;
+  return message === undefined && param === undefined ? undefined : Object.freeze({ message, param });
+}
 function normalizeAdmissionError(error) {
   if (error instanceof DataAdmissionError)
     return error;
@@ -413,7 +421,7 @@ function normalizeAdmissionError(error) {
   const value = error;
   if (typeof value.status !== "number" || ![401, 403, 409, 422, 429, 503].includes(value.status) || typeof value.code !== "string" || !/^[a-zA-Z0-9_.-]{1,128}$/.test(value.code) || value.retryAfter !== undefined && (typeof value.retryAfter !== "number" || !Number.isFinite(value.retryAfter) || value.retryAfter < 0))
     return null;
-  return new DataAdmissionError(value.status, value.code, value.retryAfter);
+  return new DataAdmissionError(value.status, value.code, value.retryAfter, value.details);
 }
 var DataAdmissionError;
 var init_errors = __esm(() => {
@@ -422,11 +430,13 @@ var init_errors = __esm(() => {
     code;
     retryAfter;
     name = "DataAdmissionError";
-    constructor(status, code, retryAfter) {
+    details;
+    constructor(status, code, retryAfter, details) {
       super(code);
       this.status = status;
       this.code = code;
       this.retryAfter = retryAfter;
+      this.details = safeDetails(details);
     }
   };
 });

package/dist/gateway/request-plugin.d.ts

@@ -4,6 +4,12 @@ import type { ExpressionContext } from '../expression-engine';
 import type { EffectiveRouteConfig, RuntimeUpstream } from '../worker/types';
 export interface HandleRequestRuntimeContext {
     servingRevision?: number;
+    /** Host-only session context, never accepted from client fields. */
+    transport?: 'websocket';
+    websocketBridge?: import('../websocket').WebSocketBridge;
+    skipEntryRate?: boolean;
+    /** Host session receives the codec's logical history without re-reading the request body. */
+    onCanonicalInput?: (input: readonly unknown[]) => void;
     logging?: RequestLoggerDependencies;
 }
 type UpstreamSelector = (upstreams: RuntimeUpstream[], route?: EffectiveRouteConfig, context?: ExpressionContext) => RuntimeUpstream | undefined;

package/dist/gateway/responses-websocket-session.d.ts

@@ -0,0 +1,18 @@
+import type { GatewayWebSocketInput, WebSocketMessageView } from './websocket-contracts';
+import type { ManagedWebSocketSession } from '../websocket';
+import type { PluginHooks } from '../hooks';
+/** One connection owns one active logical generation; the transport owns all queues. */
+export declare class ResponsesWebSocketSession {
+    private readonly input;
+    private readonly hooks;
+    private active;
+    private readonly history;
+    private readonly historyLease;
+    private historyBytes;
+    constructor(input: GatewayWebSocketInput, hooks: PluginHooks);
+    dispose(): void;
+    private remember;
+    private error;
+    onMessage(session: ManagedWebSocketSession, message: WebSocketMessageView): void | Promise<void>;
+    private generate;
+}

package/dist/gateway/runtime.d.ts

@@ -8,6 +8,7 @@ export declare function registerGatewayBuiltins(hooks: PluginHooks, plugins?: re
 export declare function validateGatewayProviders(hooks: PluginHooks): void;
 export declare function createGatewayHooks(plugins?: readonly Plugin[]): PluginHooks;
 export declare function gatewayHooks(): PluginHooks;
+export declare function runWithGatewayHooks<T>(hooks: PluginHooks, run: () => T): T;
 export declare function initializeGateway(): void;
 export declare function requireGatewayResult<T>(value: T | undefined, stage: string): T;
 export declare const runGatewayRequest: typeof executeHttpRequest;

package/dist/gateway/websocket-contracts.d.ts

@@ -54,6 +54,7 @@ export interface GatewayWebSocketInput {
     readonly bridge: import('../websocket').WebSocketBridge;
     readonly config: import('@jeffusion/bungee-types').AppConfig;
     readonly servingRevision: number;
+    readonly logging?: import('../logger/request-logger').RequestLoggerDependencies;
     /** Host shutdown barrier; retains observer/credential owners until close cleanup. */
     readonly retain: (completion: Promise<void>) => void;
 }

package/dist/hooks/plugin-hooks.d.ts

@@ -184,6 +184,7 @@ export interface PluginScopeInfo {
 export interface PluginInitContext {
     /** Host-controlled, dependency-restricted public service facade. */
     readonly services?: PluginServices;
+    readonly dispatchTargets?: readonly import('../gateway/contracts').GatewayDispatchTarget[];
     /** 插件配置 */
     config: Record<string, any>;
     /** 插件存储 */
@@ -226,6 +227,7 @@ export declare function createPluginHooks(): PluginHooks;
  */
 export interface PluginHooks {
     onGatewayWebSocket: AsyncSeriesBailHook<[GatewayWebSocketInput], GatewayWebSocketResult>;
+    onWebSocketSessionMode: AsyncSeriesBailHook<[URL], 'responses'>;
     onWebSocketHandshake: AsyncSeriesWaterfallHook<WebSocketHandshakeContext>;
     onWebSocketObservation: WebSocketObservationHook;
     onGatewayBody: SyncBailHook<GatewayBodyArguments, BodySource>;

package/dist/logger/access-log-writer.d.ts

@@ -100,8 +100,8 @@ export declare const accessLogWriter: {
     getDatabase: () => Database;
     updateResponseBodyId: (requestId: string, respBodyId: string) => void;
     updateBodyId: (requestId: string, type: "request" | "response" | "original-request", bodyId: string) => void;
-    updateProtocolOutcome: (requestId: string, outcome: "incomplete" | "cancelled" | "failed" | "completed", success: boolean, code?: string | undefined, diagnosticMessage?: string | undefined) => void;
-    updateTransportOutcome: (requestId: string, outcome: "cancelled" | "unknown" | "failed" | "pending" | "completed", code?: string | undefined) => void;
+    updateProtocolOutcome: (requestId: string, outcome: "completed" | "failed" | "cancelled" | "incomplete", success: boolean, code?: string | undefined, diagnosticMessage?: string | undefined) => void;
+    updateTransportOutcome: (requestId: string, outcome: "unknown" | "completed" | "failed" | "cancelled" | "pending", code?: string | undefined) => void;
     flush: () => Promise<void>;
     close: () => Promise<void>;
 };