@sayknow-cli/ai 0.3.16 → 0.4.0

package/src/utils/validation.ts

@@ -967,13 +967,18 @@ export function validateToolCall(tools: Tool[], toolCall: ToolCall): ToolCall["a
  */
 export function validateToolArguments(tool: Tool, toolCall: ToolCall): ToolCall["arguments"] {
 	const originalArgs = toolCall.arguments;
+	const rawValidation = tool.rawArgumentValidation?.(originalArgs);
+	if (rawValidation?.outcome === "reject") {
+		throw new Error(`Validation failed for tool "${toolCall.name}": raw arguments rejected before coercion`);
+	}
+	const rawArgs = rawValidation?.outcome === "accept" ? rawValidation.arguments : originalArgs;
 	const ctx = getValidationContext(tool);
 	const { json } = ctx;
 
 	// Always normalize first — strip null and string "null" from optional
 	// fields and substitute defaults. Handles LLM outputting string "null"
 	// to mean "no value" even when validation would otherwise pass.
-	let normalizedArgs: unknown = originalArgs;
+	let normalizedArgs: unknown = rawArgs;
 	let changed = false;
 	const initialNormalization = normalizeOptionalNullsForSchema(json, normalizedArgs);
 	if (initialNormalization.changed) {

package/src/utils.ts

@@ -119,22 +119,131 @@ export function sanitizeOpenAIResponsesHistoryItemsForReplay(items: Array<Record
 		return sanitized ? [sanitized] : [];
 	});
 }
+const RESERVED_CONTROL_TOKEN_RE =
+	/<\|(?=(?:[A-Za-z0-9_]+|(?:system|developer|user|assistant|tool)[ \t]+to=[^\s<>|]+)\|>)/g;
+/**
+ * Neutralize leaked OpenAI Harmony / control tokens (`<|channel|>`, `<|message|>`,
+ * `<|call|>`, `<|constrain|>`, `<|recipient|>`, `<|content|>`, ...) in replayed
+ * history text. A subagent whose tool-call channel degenerates can dump raw
+ * control-token scaffolding into its reply text; once that poisoned text lands in
+ * history the Codex / Responses endpoint rejects every subsequent request with
+ * `Request blocked (code=invalid_prompt)`, permanently wedging the session because
+ * the offending item is re-sent on each turn. Insert a zero-width space after `<`
+ * so the delimiter can no longer be tokenized as a reserved control token while the
+ * text stays human-readable.
+ *
+ * The pattern matches the two control-token shapes only, so ordinary text and pipe
+ * syntax is left untouched:
+ *   - simple form `<|ident|>` — a leading run of identifier chars then `|>`; and
+ *   - header form `<|role to=recipient|>` — a known Harmony role
+ *     (`system`/`developer`/`user`/`assistant`/`tool`) followed by a single
+ *     recipient assignment `to=<recipient>` whose value is an unbounded run of
+ *     non-delimiter, non-whitespace chars (so long MCP/custom tool recipients like
+ *     `to=functions.<long.name>` are covered).
+ * The header branch is deliberately scoped to the known role + `to=` recipient
+ * grammar rather than an arbitrary `key=value`, so request-boundary sanitization
+ * never rewrites non-control delimiter text such as `<|foo bar=baz|>`. A single-line
+ * body (no `\n`) and the required leading identifier char also leave compact
+ * pipe/operator syntax alone — e.g. F# `value <| f |> g` (space after `<|`),
+ * `sum<|a+b|>c` (punctuation body), and `<|foo bar|>` (no assignment) never match.
+ * The simple branch is a strict superset of the original identifier-only pattern:
+ * every marker the old regex caught still matches.
+ */
+export function neutralizeReservedControlTokens(text: string): string {
+	if (!text.includes("<|")) return text;
+	return text.replace(RESERVED_CONTROL_TOKEN_RE, "<\u200b|");
+}
+
+/**
+ * Shape-tolerant classifier for the poisoned-history rejection that wedges
+ * gpt-5.6 sessions: `Request blocked (code=invalid_prompt)`. Accepts a raw
+ * provider error, an assistant message, or any object carrying a
+ * `providerCode` / `transportFailure` / `errorMessage` field, and returns true
+ * when the failure is the deterministic `invalid_prompt` content fault rather
+ * than a transient upstream error. This is the single shared contract the
+ * provider transports and the session-level circuit breaker key on so the
+ * classification is explicit (not inferred from a catch-all bucket) and
+ * uniformly testable across transports.
+ */
+export function isInvalidPromptError(input: unknown): boolean {
+	if (!input) return false;
+	if (typeof input === "string") return INVALID_PROMPT_MESSAGE_RE.test(input);
+	if (typeof input !== "object") return false;
+	const value = input as {
+		providerCode?: unknown;
+		code?: unknown;
+		errorMessage?: unknown;
+		message?: unknown;
+		transportFailure?: { providerCode?: unknown; code?: unknown };
+		error?: { code?: unknown };
+	};
+	const code =
+		asLowerString(value.providerCode) ??
+		asLowerString(value.code) ??
+		asLowerString(value.transportFailure?.providerCode) ??
+		asLowerString(value.transportFailure?.code) ??
+		asLowerString(value.error?.code);
+	if (code === "invalid_prompt") return true;
+	const message =
+		typeof value.errorMessage === "string"
+			? value.errorMessage
+			: typeof value.message === "string"
+				? value.message
+				: undefined;
+	return message !== undefined && INVALID_PROMPT_MESSAGE_RE.test(message);
+}
+
+const INVALID_PROMPT_MESSAGE_RE = /code=invalid[_ -]prompt|request blocked[^\n]*invalid[_ -]prompt/i;
+
+function asLowerString(value: unknown): string | undefined {
+	return typeof value === "string" ? value.toLowerCase() : undefined;
+}
+
+/**
+ * Neutralize leaked reserved control tokens across every string in an outgoing
+ * Responses `input` array. This is the request-boundary complement to the
+ * replay-history sanitizer: leaked Harmony markers (`<|channel|>analysis`, ...)
+ * can enter the payload from assistant reasoning summaries, live-converted
+ * message/tool-output text, or user-authored content — not just replayed
+ * history — and every gpt-5.6 request that carries one is rejected with
+ * `Request blocked (code=invalid_prompt)`. Walking every string (rather than an
+ * item-type allowlist) guarantees no leak source is missed as item shapes
+ * evolve; the zero-width-space insertion is idempotent (`<\u200b|` no longer
+ * matches `<|`) and keeps the text human-readable.
+ */
+export function neutralizeResponsesInputControlTokens<T>(items: readonly T[]): T[] {
+	return items.map(item => deepNeutralizeReservedControlTokens(item) as T);
+}
+
+function deepNeutralizeReservedControlTokens(value: unknown): unknown {
+	if (typeof value === "string") return neutralizeReservedControlTokens(value);
+	if (Array.isArray(value)) return value.map(deepNeutralizeReservedControlTokens);
+	if (value && typeof value === "object") {
+		const out: Record<string, unknown> = {};
+		for (const [key, nested] of Object.entries(value)) {
+			out[key] = deepNeutralizeReservedControlTokens(nested);
+		}
+		return out;
+	}
+	return value;
+}
+
 function stringifyResponsesStringParamForReplay(value: unknown): string {
-	if (typeof value === "string") return value.toWellFormed();
+	if (typeof value === "string") return neutralizeReservedControlTokens(value.toWellFormed());
 	try {
 		const encoded = JSON.stringify(value);
-		if (typeof encoded === "string") return encoded.toWellFormed();
+		if (typeof encoded === "string") return neutralizeReservedControlTokens(encoded.toWellFormed());
 	} catch {
 		// Fall through to String().
 	}
-	return String(value ?? "").toWellFormed();
+	return neutralizeReservedControlTokens(String(value ?? "").toWellFormed());
 }
 
 function normalizeResponsesMessageTextForReplay(value: unknown): string {
-	if (typeof value === "string") return value.toWellFormed();
+	if (typeof value === "string") return neutralizeReservedControlTokens(value.toWellFormed());
 	if (value && typeof value === "object") {
 		const nestedText = (value as { text?: unknown }).text;
-		if (typeof nestedText === "string") return nestedText.toWellFormed();
+		if (typeof nestedText === "string") return neutralizeReservedControlTokens(nestedText.toWellFormed());
 	}
 	return stringifyResponsesStringParamForReplay(value);
 }
@@ -163,7 +272,7 @@ function normalizeResponsesImageUrlForReplay(value: unknown): NormalizedResponse
 }
 
 function sanitizeResponsesMessageContentForReplay(content: unknown): unknown {
-	if (typeof content === "string") return content.toWellFormed();
+	if (typeof content === "string") return neutralizeReservedControlTokens(content.toWellFormed());
 	if (!Array.isArray(content)) return content;
 	return content.map(part => {
 		if (!part || typeof part !== "object") return part;
@@ -197,12 +306,11 @@ function sanitizeResponsesStringFieldsForReplay(item: Record<string, unknown>):
 	if (item.type === "custom_tool_call" && "input" in item && typeof item.input !== "string") {
 		item.input = stringifyResponsesStringParamForReplay(item.input);
 	}
-	if (
-		(item.type === "function_call_output" || item.type === "custom_tool_call_output") &&
-		"output" in item &&
-		typeof item.output !== "string"
-	) {
-		item.output = stringifyResponsesStringParamForReplay(item.output);
+	if ((item.type === "function_call_output" || item.type === "custom_tool_call_output") && "output" in item) {
+		item.output =
+			typeof item.output === "string"
+				? neutralizeReservedControlTokens(item.output.toWellFormed())
+				: stringifyResponsesStringParamForReplay(item.output);
 	}
 }
 

package/dist/types/api-registry.d.ts

@@ -1,30 +0,0 @@
-/**
- * Custom API provider registry.
- *
- * Allows extensions to register streaming functions for custom API types
- * (e.g., "vertex-Anthropic model-api") that are not built into stream.ts.
- */
-import type { Api, AssistantMessageEventStream, Context, Model, SimpleStreamOptions, StreamOptions } from "./types";
-export type CustomStreamFn = (model: Model<Api>, context: Context, options?: StreamOptions) => AssistantMessageEventStream;
-export type CustomStreamSimpleFn = (model: Model<Api>, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStream;
-export interface RegisteredCustomApi {
-    stream: CustomStreamFn;
-    streamSimple: CustomStreamSimpleFn;
-    sourceId?: string;
-}
-/**
- * Register a custom API streaming function.
- */
-export declare function registerCustomApi(api: string, streamSimple: CustomStreamSimpleFn, sourceId?: string, stream?: CustomStreamFn): void;
-/**
- * Get a custom API provider by API identifier.
- */
-export declare function getCustomApi(api: string): RegisteredCustomApi | undefined;
-/**
- * Remove all custom APIs registered by a specific source (e.g., extension path).
- */
-export declare function unregisterCustomApis(sourceId: string): void;
-/**
- * Clear all custom API registrations.
- */
-export declare function clearCustomApis(): void;

package/dist/types/auth-broker/client.d.ts

@@ -1,67 +0,0 @@
-import type { AuthCredential } from "../auth-storage";
-import type { CredentialDisableResponse, CredentialIfAbsentUploadResponse, CredentialRefreshResponse, CredentialUploadResponse, HealthzResponse, SnapshotResponse, SnapshotStreamEvent, UsageResponse } from "./types";
-export interface AuthBrokerClientOptions {
-    /** Base URL (e.g. `https://broker.tailnet:8765`). Trailing slashes are trimmed. */
-    url: string;
-    /** Bearer token used for everything except `healthz`. */
-    token: string;
-    /** Per-request timeout in milliseconds. Default 10s. */
-    timeoutMs?: number;
-    /** Retry connection errors this many times. Default 1. */
-    maxRetries?: number;
-    /** Override fetch (used in tests). Default global `fetch`. */
-    fetchImpl?: typeof fetch;
-}
-export declare class AuthBrokerError extends Error {
-    readonly status: number | undefined;
-    readonly body: string | undefined;
-    constructor(message: string, opts?: {
-        status?: number;
-        body?: string;
-        cause?: unknown;
-    });
-}
-/**
- * Thrown when a broker responds 404 to `GET /v1/snapshot/stream` — old
- * brokers that predate the SSE endpoint. Callers (`RemoteAuthCredentialStore`)
- * detect this sentinel to fall back to long-polling permanently.
- */
-export declare class AuthBrokerStreamUnsupportedError extends AuthBrokerError {
-    constructor(message?: string);
-}
-export interface FetchSnapshotOptions {
-    ifGenerationGt?: number;
-    waitMs?: number;
-    signal?: AbortSignal;
-}
-export type FetchSnapshotResult = {
-    status: 200;
-    snapshot: SnapshotResponse;
-    generation: number;
-} | {
-    status: 304;
-    generation: number;
-};
-export declare class AuthBrokerClient {
-    #private;
-    constructor(opts: AuthBrokerClientOptions);
-    healthz(signal?: AbortSignal): Promise<HealthzResponse>;
-    fetchSnapshot(opts?: FetchSnapshotOptions): Promise<FetchSnapshotResult>;
-    /**
-     * Subscribe to the broker's SSE snapshot stream. The first frame is always
-     * a full `snapshot`; subsequent frames are `entry` upserts / refreshes or
-     * `removed` deletes. Caller controls lifecycle via `opts.signal`.
-     *
-     * Throws {@link AuthBrokerStreamUnsupportedError} when the broker responds
-     * 404 — older brokers predate this endpoint and the caller should fall back
-     * to long-polling for the remainder of its lifetime.
-     */
-    openSnapshotStream(opts?: {
-        signal?: AbortSignal;
-    }): AsyncGenerator<SnapshotStreamEvent>;
-    fetchUsage(signal?: AbortSignal): Promise<UsageResponse>;
-    refreshCredential(id: number, signal?: AbortSignal): Promise<CredentialRefreshResponse>;
-    disableCredential(id: number, cause: string, signal?: AbortSignal): Promise<CredentialDisableResponse>;
-    uploadCredential(provider: string, credential: AuthCredential, signal?: AbortSignal): Promise<CredentialUploadResponse>;
-    uploadCredentialIfAbsent(provider: string, credential: AuthCredential, signal?: AbortSignal): Promise<CredentialIfAbsentUploadResponse>;
-}

package/dist/types/auth-broker/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./client";
-export * from "./refresher";
-export * from "./remote-store";
-export * from "./server";
-export * from "./types";

package/dist/types/auth-broker/refresher.d.ts

@@ -1,25 +0,0 @@
-import type { AuthStorage } from "../auth-storage";
-export interface AuthBrokerRefresherOptions {
-    storage: AuthStorage;
-    /** Refresh credentials expiring within this window. Default 5 min. */
-    refreshSkewMs?: number;
-    /** Loop cadence. Default 60s. */
-    refreshIntervalMs?: number;
-    /** Override clock (tests). */
-    now?: () => number;
-}
-export interface AuthBrokerRefresherSchedule {
-    enabled: boolean;
-    intervalMs: number;
-    skewMs: number;
-    nextSweepAt: number;
-}
-export declare class AuthBrokerRefresher {
-    #private;
-    constructor(opts: AuthBrokerRefresherOptions);
-    start(): void;
-    stop(): void;
-    getSchedule(): AuthBrokerRefresherSchedule;
-    /** Run one sweep. Exposed for tests. */
-    tick(): Promise<void>;
-}

package/dist/types/auth-broker/remote-store.d.ts

@@ -1,99 +0,0 @@
-import { type AuthCredential, type AuthCredentialIfAbsentResult, type AuthCredentialStore, type OAuthCredential, type StoredAuthCredential } from "../auth-storage";
-import type { Provider } from "../types";
-import type { UsageReport } from "../usage";
-import type { OAuthCredentials } from "../utils/oauth/types";
-import { type AuthBrokerClient } from "./client";
-import type { SnapshotResponse } from "./types";
-export interface RemoteAuthCredentialStoreOptions {
-    client: AuthBrokerClient;
-    /**
-     * Initial snapshot. When omitted, callers must call
-     * {@link RemoteAuthCredentialStore.refreshSnapshot} before the first read.
-     */
-    initialSnapshot?: SnapshotResponse;
-    /**
-     * Subscribe to the broker's SSE snapshot stream when available. Falls back
-     * to long-poll permanently when the broker returns 404. Default `true`.
-     */
-    streamSnapshots?: boolean;
-}
-export declare class RemoteAuthCredentialStore implements AuthCredentialStore {
-    #private;
-    constructor(opts: RemoteAuthCredentialStoreOptions);
-    get client(): AuthBrokerClient;
-    get snapshot(): SnapshotResponse;
-    /** Re-hydrate the in-memory snapshot from the broker. */
-    refreshSnapshot(): Promise<SnapshotResponse>;
-    listAuthCredentials(provider?: string): StoredAuthCredential[];
-    /**
-     * In-memory update from a successful refresh through the broker. AuthStorage
-     * calls this after `#replaceCredentialAt`; the broker already persisted the
-     * authoritative row, so we just mirror it.
-     */
-    updateAuthCredential(id: number, credential: AuthCredential): void;
-    deleteAuthCredential(id: number, disabledCause: string): void;
-    tryDisableAuthCredentialIfMatches(id: number, _expectedData: string, disabledCause: string): boolean;
-    waitForFreshSnapshot(maxWaitMs: number, opts?: {
-        signal?: AbortSignal;
-    }): Promise<boolean>;
-    prepareForRequest(credentialId: number, opts?: {
-        signal?: AbortSignal;
-    }): Promise<boolean>;
-    markCredentialSuspect(credentialId: number, opts?: {
-        signal?: AbortSignal;
-    }): Promise<void>;
-    replaceAuthCredentialsForProvider(_provider: string, _credentials: AuthCredential[]): StoredAuthCredential[];
-    upsertAuthCredentialForProvider(_provider: string, _credential: AuthCredential): StoredAuthCredential[];
-    upsertAuthCredentialForProviderIfAbsent(_provider: string, _credential: AuthCredential): AuthCredentialIfAbsentResult;
-    deleteAuthCredentialsForProvider(_provider: string, _disabledCause: string): void;
-    /**
-     * Upsert a single credential through the broker. The broker server is the
-     * canonical writer — see `POST /v1/credential`. The redacted snapshot
-     * entries returned by the server replace the provider's rows in our local
-     * snapshot, and the global snapshot is then refreshed in the background so
-     * any concurrent peer (refresh, generation bump) stays in sync.
-     */
-    upsertAuthCredentialRemote(provider: string, credential: AuthCredential): Promise<StoredAuthCredential[]>;
-    upsertAuthCredentialRemoteIfAbsent(provider: string, credential: AuthCredential): Promise<AuthCredentialIfAbsentResult>;
-    /**
-     * Replace-all semantics: disable every active credential for the provider,
-     * then upload each of the new credentials. Used by API-key login so a new
-     * key clobbers any previously stored key for the same provider.
-     */
-    replaceAuthCredentialsRemote(provider: string, credentials: AuthCredential[]): Promise<StoredAuthCredential[]>;
-    /**
-     * Logout: disable every active credential for the provider on the broker,
-     * then drop them from the local snapshot. Refresh fetches the authoritative
-     * post-state in the background.
-     */
-    deleteAuthCredentialsRemote(provider: string, disabledCause: string): Promise<void>;
-    getCache(key: string): string | null;
-    setCache(key: string, value: string, expiresAtSec: number): void;
-    cleanExpiredCache(): void;
-    deleteCachePrefix(prefix: string): void;
-    /**
-     * Store-level hook consumed by `AuthStorage` — routes refresh through the
-     * broker so the actual refresh token never leaves the broker host. Returns
-     * the broker-redacted credential with {@link REMOTE_REFRESH_SENTINEL} in
-     * the `refresh` slot.
-     */
-    refreshOAuthCredential(_provider: Provider, credentialId: number, _credential: OAuthCredential, signal?: AbortSignal): Promise<OAuthCredentials>;
-    /**
-     * Store-level hook consumed by `AuthStorage.fetchUsageReports()` — proxies
-     * to the broker's `/v1/usage` endpoint. The broker's egress IP isn't
-     * rate-limited by Anthropic's per-IP `/usage` cap the way a heavy
-     * residential laptop is, so all credentials surface every cycle.
-     */
-    fetchUsageReports(signal?: AbortSignal): Promise<UsageReport[] | null>;
-    /**
-     * Per-credential usage hook consumed by `AuthStorage.#getUsageReport`. Pulls
-     * the aggregate broker `/v1/usage` once and serves all callers from the
-     * same response (coalesced + cached), then matches the credential to a
-     * report by provider + identity (accountId / email / projectId).
-     *
-     * The broker already aggregates with its own 30s TTL on the server side; our
-     * 15s client TTL is below that so we usually re-use the broker's cache too.
-     */
-    getUsageReport(provider: Provider, credential: OAuthCredential, signal?: AbortSignal): Promise<UsageReport | null>;
-    close(): void;
-}

package/dist/types/auth-broker/server.d.ts

@@ -1,32 +0,0 @@
-import type { AuthStorage } from "../auth-storage";
-export interface AuthBrokerServerOptions {
-    /** Underlying credential storage (wraps the local SQLite store on the broker). */
-    storage: AuthStorage;
-    /** Listen address; accepts `host:port` or just `port`. */
-    bind?: string;
-    /** Accept any of these bearer tokens. Empty disables auth (loopback only). */
-    bearerTokens: string[];
-    /** Broker version string surfaced on `/v1/healthz`. */
-    version?: string;
-    /** Refresh credentials expiring within this window. Default 5 min. */
-    refreshSkewMs?: number;
-    /** Background refresh cadence. Default 60s. */
-    refreshIntervalMs?: number;
-    /** Disable the background refresher (e.g. for tests). */
-    disableRefresher?: boolean;
-    /**
-     * Override SSE keepalive cadence in milliseconds for `/v1/snapshot/stream`.
-     * Internal-only — tests use a short interval so they can assert heartbeats
-     * without long sleeps. Default {@link DEFAULT_STREAM_KEEPALIVE_MS}.
-     */
-    streamKeepaliveMs?: number;
-}
-export interface AuthBrokerServerHandle {
-    /** Bound URL (`http://host:port`). */
-    url: string;
-    port: number;
-    hostname: string;
-    close(): Promise<void>;
-}
-/** Boot the broker. Caller owns lifecycle; `handle.close()` to stop. */
-export declare function startAuthBroker(opts: AuthBrokerServerOptions): AuthBrokerServerHandle;

package/dist/types/auth-broker/types.d.ts

@@ -1,110 +0,0 @@
-/**
- * Wire types shared between the auth-broker server and clients.
- *
- * The broker holds OAuth refresh tokens and exposes a redacted snapshot;
- * clients use `access` tokens directly and call back to the broker when a
- * credential expires or a 401 surfaces on a supposedly-fresh credential.
- */
-import type { AuthCredential, AuthCredentialIfAbsentReason, AuthCredentialSnapshot, AuthCredentialSnapshotEntry } from "../auth-storage";
-import type { UsageReport } from "../usage";
-/** GET /v1/healthz response body. */
-export interface HealthzResponse {
-    ok: boolean;
-    version?: string;
-}
-export interface RefresherSchedule {
-    enabled: boolean;
-    intervalMs: number;
-    skewMs: number;
-    nextSweepInMs: number;
-}
-export type SnapshotEntry = AuthCredentialSnapshotEntry & {
-    rotatesInMs: number | null;
-};
-/** GET /v1/snapshot response body. */
-export interface SnapshotResponse extends Omit<AuthCredentialSnapshot, "credentials"> {
-    serverNowMs: number;
-    refresher: RefresherSchedule;
-    credentials: SnapshotEntry[];
-}
-/** GET /v1/usage response body — matches the local `AuthStorage.fetchUsageReports` shape. */
-export interface UsageResponse {
-    generatedAt: number;
-    reports: UsageReport[];
-}
-/** POST /v1/credential/:id/refresh response body. */
-export interface CredentialRefreshResponse {
-    entry: AuthCredentialSnapshotEntry;
-}
-/** POST /v1/credential/:id/disable request body. */
-export interface CredentialDisableRequest {
-    cause: string;
-}
-/** POST /v1/credential/:id/disable response body. */
-export interface CredentialDisableResponse {
-    ok: boolean;
-}
-/**
- * POST /v1/credential request body. The OAuth `refresh` must be the *real*
- * refresh token (not the sentinel) — the broker is the canonical writer.
- */
-export interface CredentialUploadRequest {
-    provider: string;
-    credential: AuthCredential;
-}
-/** POST /v1/credential response body — redacted snapshot of the provider's rows after upsert. */
-export interface CredentialUploadResponse {
-    entries: AuthCredentialSnapshotEntry[];
-}
-export interface CredentialIfAbsentUploadResponse {
-    inserted: boolean;
-    reason: AuthCredentialIfAbsentReason;
-    entries: AuthCredentialSnapshotEntry[];
-}
-/**
- * SSE event kinds emitted on `GET /v1/snapshot/stream`. The same value is set
- * as the SSE `event:` name (load-bearing for clients) **and** embedded as a
- * `kind` field inside the JSON body so a Zod discriminated union can validate
- * the payload without consulting the line metadata.
- */
-export type SnapshotStreamEventKind = "snapshot" | "entry" | "removed";
-/** Initial frame emitted on connect — the full {@link SnapshotResponse}. */
-export interface SnapshotStreamSnapshotEvent extends SnapshotResponse {
-    kind: "snapshot";
-}
-/** Single credential added/changed (upsert or refresh). */
-export interface SnapshotStreamEntryEvent {
-    kind: "entry";
-    generation: number;
-    serverNowMs: number;
-    refresher: RefresherSchedule;
-    entry: SnapshotEntry;
-}
-/** Single credential disabled/deleted. */
-export interface SnapshotStreamRemovedEvent {
-    kind: "removed";
-    generation: number;
-    serverNowMs: number;
-    refresher: RefresherSchedule;
-    id: number;
-}
-/** Discriminated union of every event the snapshot stream emits. */
-export type SnapshotStreamEvent = SnapshotStreamSnapshotEvent | SnapshotStreamEntryEvent | SnapshotStreamRemovedEvent;
-/**
- * Default bearer-protected route prefix. The broker exposes `/v1/healthz`
- * unauthenticated for liveness probes; everything else requires a bearer.
- */
-export declare const AUTH_BROKER_API_PREFIX = "/v1";
-/** Default port when none is configured. Loopback-only, no external exposure. */
-export declare const DEFAULT_AUTH_BROKER_BIND = "127.0.0.1:8765";
-/** Default broker→provider refresh skew. Refresh credentials this close to expiry. */
-export declare const DEFAULT_REFRESH_SKEW_MS: number;
-/** Default broker refresh-loop cadence. */
-export declare const DEFAULT_REFRESH_INTERVAL_MS = 60000;
-/** Keepalive cadence for `GET /v1/snapshot/stream` SSE comments. */
-export declare const DEFAULT_STREAM_KEEPALIVE_MS = 20000;
-/**
- * Bun.serve `idleTimeout` (seconds) used by the broker. Default Bun idle
- * timeout (10s) would close long-lived SSE connections between keepalives.
- */
-export declare const DEFAULT_SERVER_IDLE_TIMEOUT_S = 255;