@aexhq/sdk 0.46.5-canary → 0.51.0

package/dist/_contracts/otlp-projection.d.ts

@@ -1,78 +0,0 @@
-import type { AexEvent } from "./event-envelope.js";
-/** Signals exposed by the session telemetry pull API. */
-export type OtlpSignal = "traces" | "logs";
-/** OTLP/HTTP JSON AnyValue. The projection emits only public scalar values. */
-export type OtlpAnyValue = {
-    readonly stringValue: string;
-} | {
-    readonly boolValue: boolean;
-} | {
-    readonly intValue: string;
-} | {
-    readonly doubleValue: number;
-};
-export interface OtlpKeyValue {
-    readonly key: string;
-    readonly value: OtlpAnyValue;
-}
-export interface OtlpResource {
-    readonly attributes: readonly OtlpKeyValue[];
-}
-export interface OtlpInstrumentationScope {
-    readonly name: string;
-    readonly version?: string;
-}
-export interface OtlpTraceSpan {
-    readonly traceId: string;
-    readonly spanId: string;
-    readonly parentSpanId?: string;
-    readonly name: string;
-    readonly kind: 1;
-    readonly startTimeUnixNano: string;
-    readonly endTimeUnixNano: string;
-    readonly attributes: readonly OtlpKeyValue[];
-    readonly status: {
-        readonly code: 1 | 2;
-    };
-}
-export interface OtlpScopeSpans {
-    readonly scope: OtlpInstrumentationScope;
-    readonly spans: readonly OtlpTraceSpan[];
-}
-export interface OtlpResourceSpans {
-    readonly resource: OtlpResource;
-    readonly scopeSpans: readonly OtlpScopeSpans[];
-}
-/** Standards-pure OTLP ExportTraceServiceRequest JSON body. */
-export interface OtlpExportTraceServiceRequest {
-    readonly resourceSpans: readonly OtlpResourceSpans[];
-}
-export interface OtlpLogRecord {
-    readonly timeUnixNano: string;
-    readonly observedTimeUnixNano: string;
-    readonly severityNumber: 9 | 13 | 17;
-    readonly severityText: "INFO" | "WARN" | "ERROR";
-    readonly body: OtlpAnyValue;
-    readonly attributes: readonly OtlpKeyValue[];
-    readonly traceId?: string;
-    readonly spanId?: string;
-}
-export interface OtlpScopeLogs {
-    readonly scope: OtlpInstrumentationScope;
-    readonly logRecords: readonly OtlpLogRecord[];
-}
-export interface OtlpResourceLogs {
-    readonly resource: OtlpResource;
-    readonly scopeLogs: readonly OtlpScopeLogs[];
-}
-/** Standards-pure OTLP ExportLogsServiceRequest JSON body. */
-export interface OtlpExportLogsServiceRequest {
-    readonly resourceLogs: readonly OtlpResourceLogs[];
-}
-export type OtlpExportRequest = OtlpExportTraceServiceRequest | OtlpExportLogsServiceRequest;
-export interface ToOtlpOptions<Signal extends OtlpSignal = OtlpSignal> {
-    readonly signal: Signal;
-}
-export declare function toOTLP(events: readonly AexEvent[], options: ToOtlpOptions<"traces">): OtlpExportTraceServiceRequest;
-export declare function toOTLP(events: readonly AexEvent[], options: ToOtlpOptions<"logs">): OtlpExportLogsServiceRequest;
-export declare function toOTLP(events: readonly AexEvent[], options: ToOtlpOptions): OtlpExportRequest;

package/dist/_contracts/otlp-projection.js

@@ -1,171 +0,0 @@
-import { redactString } from "./sdk-secrets.js";
-const TRACE_ID = /^[0-9a-f]{32}$/;
-const SPAN_ID = /^[0-9a-f]{16}$/;
-const SCOPE = Object.freeze({ name: "@aexhq/contracts", version: "1" });
-/**
- * Project public event envelopes into a standards-pure OTLP/HTTP JSON body.
- *
- * This function accepts only the public event contract. It never accepts or
- * imports private journal rows. Projection is allow-list based: arbitrary
- * event data is ignored, and text that is intentionally public is passed
- * through the canonical public redactor before it becomes telemetry.
- */
-export function toOTLP(events, options) {
-    if (options.signal === "traces")
-        return projectTraces(events);
-    if (options.signal === "logs")
-        return projectLogs(events);
-    throw new TypeError(`unsupported OTLP signal: ${String(options.signal)}`);
-}
-function projectTraces(events) {
-    const spans = events.flatMap((event) => {
-        if (!validTraceIdentity(event))
-            return [];
-        const start = unixNano(event.time);
-        return [{
-                traceId: event.traceId,
-                spanId: event.spanId,
-                ...(validSpanId(event.parentSpanId) ? { parentSpanId: event.parentSpanId } : {}),
-                name: publicSpanName(event),
-                kind: 1,
-                startTimeUnixNano: start,
-                endTimeUnixNano: (BigInt(start) + 1n).toString(),
-                attributes: publicAttributes(event, "traces"),
-                status: { code: event.type === "RUN_ERROR" ? 2 : 1 }
-            }];
-    });
-    return {
-        resourceSpans: spans.length === 0 ? [] : [{
-                resource: publicResource(),
-                scopeSpans: [{ scope: SCOPE, spans }]
-            }]
-    };
-}
-function projectLogs(events) {
-    const logRecords = events
-        .filter((event) => event.channel === "log" || event.type === "LOG")
-        .map((event) => {
-        const time = unixNano(event.time);
-        const severity = severityOf(event.level);
-        const message = typeof event.message === "string"
-            ? event.message
-            : typeof event.data["message"] === "string"
-                ? event.data["message"]
-                : event.type;
-        return {
-            timeUnixNano: time,
-            observedTimeUnixNano: time,
-            ...severity,
-            body: { stringValue: redactString(message) },
-            attributes: publicAttributes(event, "logs"),
-            ...(validTraceId(event.traceId) ? { traceId: event.traceId } : {}),
-            ...(validSpanId(event.spanId) ? { spanId: event.spanId } : {})
-        };
-    });
-    return {
-        resourceLogs: logRecords.length === 0 ? [] : [{
-                resource: publicResource(),
-                scopeLogs: [{ scope: SCOPE, logRecords }]
-            }]
-    };
-}
-function publicResource() {
-    return {
-        attributes: [
-            attribute("service.name", "aex"),
-            attribute("aex.visibility", "external")
-        ]
-    };
-}
-function publicAttributes(event, signal) {
-    const attributes = [
-        attribute("aex.visibility", "external"),
-        attribute("aex.session.id", event.subject),
-        attribute("aex.run.id", event.runId)
-    ];
-    const turnSeq = publicNumber(event.data["turnSeq"])
-        ?? publicNestedNumber(event.data["value"], "turnSeq");
-    if (turnSeq !== undefined)
-        attributes.push(attribute("aex.turn.seq", turnSeq));
-    const callId = publicString(event.data["callId"])
-        ?? publicNestedString(event.data["fields"], "callId")
-        ?? publicNestedString(event.data["value"], "callId");
-    if (callId !== undefined)
-        attributes.push(attribute("aex.call.id", callId));
-    const failureClass = publicString(event.data["failureClass"]);
-    if (failureClass !== undefined)
-        attributes.push(attribute("aex.failure.class_public", failureClass));
-    if (signal === "logs") {
-        const ioStream = publicIoStream(event.data["stream"])
-            ?? publicNestedIoStream(event.data["fields"], "stream")
-            ?? publicNestedIoStream(event.data["value"], "stream");
-        if (ioStream !== undefined)
-            attributes.push(attribute("log.iostream", ioStream));
-    }
-    const exitCode = publicSafeInteger(event.data["exitCode"])
-        ?? publicNestedSafeInteger(event.data["fields"], "exitCode")
-        ?? publicNestedSafeInteger(event.data["value"], "exitCode");
-    if (exitCode !== undefined)
-        attributes.push(attribute("aex.tool.exit_code", exitCode));
-    return attributes;
-}
-function publicSpanName(event) {
-    const customName = event.type === "CUSTOM" ? publicString(event.data["name"]) : undefined;
-    return redactString(customName ?? event.type);
-}
-function attribute(key, value) {
-    if (typeof value === "string")
-        return { key, value: { stringValue: redactString(value) } };
-    if (typeof value === "boolean")
-        return { key, value: { boolValue: value } };
-    return Number.isSafeInteger(value)
-        ? { key, value: { intValue: String(value) } }
-        : { key, value: { doubleValue: value } };
-}
-function severityOf(level) {
-    if (level === "error")
-        return { severityNumber: 17, severityText: "ERROR" };
-    if (level === "warn")
-        return { severityNumber: 13, severityText: "WARN" };
-    return { severityNumber: 9, severityText: "INFO" };
-}
-function unixNano(value) {
-    const milliseconds = Date.parse(value);
-    return (BigInt(Number.isFinite(milliseconds) ? Math.max(0, Math.trunc(milliseconds)) : 0) * 1000000n).toString();
-}
-function validTraceIdentity(event) {
-    return validTraceId(event.traceId) && validSpanId(event.spanId);
-}
-function validTraceId(value) {
-    return typeof value === "string" && TRACE_ID.test(value) && !/^0+$/.test(value);
-}
-function validSpanId(value) {
-    return typeof value === "string" && SPAN_ID.test(value) && !/^0+$/.test(value);
-}
-function publicString(value) {
-    return typeof value === "string" && value.length > 0 ? redactString(value) : undefined;
-}
-function publicNumber(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-function publicSafeInteger(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) ? value : undefined;
-}
-function publicIoStream(value) {
-    return value === "stdout" || value === "stderr" ? value : undefined;
-}
-function publicNestedString(value, key) {
-    return isPlainRecord(value) ? publicString(value[key]) : undefined;
-}
-function publicNestedNumber(value, key) {
-    return isPlainRecord(value) ? publicNumber(value[key]) : undefined;
-}
-function publicNestedSafeInteger(value, key) {
-    return isPlainRecord(value) ? publicSafeInteger(value[key]) : undefined;
-}
-function publicNestedIoStream(value, key) {
-    return isPlainRecord(value) ? publicIoStream(value[key]) : undefined;
-}
-function isPlainRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}

package/dist/_contracts/post-hook.d.ts

@@ -1,31 +0,0 @@
-/** Default post-agent-run hook timeout (5 minutes). */
-export declare const DEFAULT_POST_HOOK_TIMEOUT_MS: number;
-/** Default number of repair turns after a failing hook. */
-export declare const DEFAULT_POST_HOOK_MAX_TURNS = 10;
-/**
- * Private post-agent-run verifier input. The public SDK does not
- * accepts this field; platform-internal paths may still normalize old wire
- * records to {@link PlatformPostHook}.
- *
- * The runtime statement of this shape is `postHookSchema()` in
- * `./schemas/post-hook.ts`; its keys are the accepted field list.
- */
-export interface PlatformPostHookInput {
-    readonly command: string;
-    readonly timeout?: string;
-    readonly maxTurns?: number;
-    readonly maxChars?: number | null;
-}
-/** Parsed post-agent-run verifier carried through dispatch to the runner. */
-export interface PlatformPostHook {
-    readonly command: string;
-    readonly timeoutMs: number;
-    readonly maxTurns: number;
-    readonly maxChars: number | null;
-}
-/**
- * Parse the private `postHook` option. An omitted hook, null hook, or hook with
- * an empty/whitespace-only command is treated as omitted so callers can pre-fill
- * configs without enabling the verifier accidentally.
- */
-export declare function parsePostHook(input: unknown, path?: string): PlatformPostHook | undefined;

package/dist/_contracts/post-hook.js

@@ -1,61 +0,0 @@
-import { parseDurationToMs } from "./runtime-sizes.js";
-import { withContractParseError } from "./contract-parse-error.js";
-import { postHookGateSchema, postHookSchema } from "./schemas/post-hook.js";
-import { parseWire } from "./schemas/wire.js";
-/** Default post-agent-run hook timeout (5 minutes). */
-export const DEFAULT_POST_HOOK_TIMEOUT_MS = 5 * 60 * 1000;
-/** Default number of repair turns after a failing hook. */
-export const DEFAULT_POST_HOOK_MAX_TURNS = 10;
-/**
- * Parse the private `postHook` option. An omitted hook, null hook, or hook with
- * an empty/whitespace-only command is treated as omitted so callers can pre-fill
- * configs without enabling the verifier accidentally.
- */
-export function parsePostHook(input, path = "postHook") {
-    return withContractParseError("parsePostHook", () => {
-        if (input === undefined || input === null) {
-            return undefined;
-        }
-        // Two passes, deliberately. The gate settles shape, the allow-list and the
-        // command; only if the command is non-blank do the sibling rules run. A
-        // single pass would reject `{ command: "", timeout: <junk> }`, which is
-        // exactly the pre-filled config the blank-command rule exists to allow.
-        if (parseWire(postHookGateSchema(path), input).command.trim().length === 0) {
-            return undefined;
-        }
-        return normalizePostHook(parseWire(postHookSchema(path), input), path);
-    });
-}
-/**
- * Apply the hook's defaults and turn its wire duration into milliseconds.
- *
- * Separate from the schema because both halves are transforms — per D4 a schema
- * that transformed could not be converted on the output side — and because the
- * duration parse belongs to {@link parseDurationToMs}, which brands its own
- * failures.
- *
- * The blank-command collapse is repeated here so this function is correct on its
- * own; the caller has already applied it via the gate schema, which is what
- * keeps a blank command from ever reaching the sibling field rules.
- */
-function normalizePostHook(hook, path) {
-    if (hook.command.trim().length === 0) {
-        return undefined;
-    }
-    return {
-        command: hook.command,
-        timeoutMs: postHookTimeoutMs(hook.timeout, `${path}.timeout`),
-        maxTurns: hook.maxTurns ?? DEFAULT_POST_HOOK_MAX_TURNS,
-        maxChars: hook.maxChars ?? null
-    };
-}
-function postHookTimeoutMs(timeout, path) {
-    if (timeout === undefined) {
-        return DEFAULT_POST_HOOK_TIMEOUT_MS;
-    }
-    const ms = parseDurationToMs(timeout);
-    if (ms <= 0) {
-        throw new Error(`${path} must be greater than 0ms; got ${ms}ms`);
-    }
-    return ms;
-}

package/dist/_contracts/provider-fault.d.ts

@@ -1,34 +0,0 @@
-/** Canonical, redaction-safe terminal fault reported by an upstream provider. */
-export declare const PROVIDER_FAULT_KINDS: readonly ["rate_limit", "overloaded", "quota_exceeded", "unavailable", "provider_error"];
-export type KnownProviderFaultKind = (typeof PROVIDER_FAULT_KINDS)[number];
-declare const UNKNOWN_PROVIDER_FAULT_KIND: unique symbol;
-/**
- * A syntactically valid future provider-fault kind accepted from the wire.
- * Producers must use a known kind; only the canonical parser creates this type.
- */
-export type UnknownProviderFaultKind = string & {
-    readonly [UNKNOWN_PROVIDER_FAULT_KIND]: "UnknownProviderFaultKind";
-};
-export type ProviderFaultKind = KnownProviderFaultKind | UnknownProviderFaultKind;
-export interface ProviderFault {
-    /** Upstream provider id, for example `anthropic`, when reported. */
-    readonly provider?: string;
-    /** Exact machine-readable fault class. Unknown future tokens are non-throttling. */
-    readonly kind: ProviderFaultKind;
-    /** Upstream HTTP status, when reported. */
-    readonly status?: number;
-    /** Retry delay in milliseconds, when reported. */
-    readonly retryAfterMs?: number;
-    /** Short, already-redacted diagnostic message. */
-    readonly message?: string;
-}
-export declare function isKnownProviderFaultKind(kind: string): kind is KnownProviderFaultKind;
-/**
- * Strictly parse the canonical provider-fault wire object.
- *
- * This parser intentionally rejects aliases, coercions, unknown fields, and
- * malformed present values. A valid future `kind` token is preserved for
- * forward compatibility, but callers must not infer throttle semantics from it.
- */
-export declare function parseProviderFault(value: unknown): ProviderFault;
-export {};

package/dist/_contracts/provider-fault.js

@@ -1,68 +0,0 @@
-/** Canonical, redaction-safe terminal fault reported by an upstream provider. */
-import { rethrowContractParseError } from "./contract-parse-error.js";
-import { isRecord } from "./value-guards.js";
-export const PROVIDER_FAULT_KINDS = [
-    "rate_limit",
-    "overloaded",
-    "quota_exceeded",
-    "unavailable",
-    "provider_error"
-];
-const PROVIDER_FAULT_KIND_SET = new Set(PROVIDER_FAULT_KINDS);
-const PROVIDER_FAULT_KEYS = new Set(["provider", "kind", "status", "retryAfterMs", "message"]);
-const KIND_TOKEN = /^[a-z][a-z0-9_.:-]{0,63}$/;
-const PROVIDER_TOKEN = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/;
-const MAX_MESSAGE_LENGTH = 512;
-export function isKnownProviderFaultKind(kind) {
-    return PROVIDER_FAULT_KIND_SET.has(kind);
-}
-/**
- * Strictly parse the canonical provider-fault wire object.
- *
- * This parser intentionally rejects aliases, coercions, unknown fields, and
- * malformed present values. A valid future `kind` token is preserved for
- * forward compatibility, but callers must not infer throttle semantics from it.
- */
-export function parseProviderFault(value) {
-    try {
-        return parseProviderFaultValue(value);
-    }
-    catch (error) {
-        rethrowContractParseError(error, "parseProviderFault");
-    }
-}
-function parseProviderFaultValue(value) {
-    if (!isRecord(value))
-        throw new TypeError("providerFault must be an object");
-    for (const key of Object.keys(value)) {
-        if (!PROVIDER_FAULT_KEYS.has(key)) {
-            throw new TypeError("providerFault contains an unknown field");
-        }
-    }
-    if (!Object.hasOwn(value, "kind") || typeof value.kind !== "string" || !KIND_TOKEN.test(value.kind)) {
-        throw new TypeError("providerFault.kind must be a canonical token");
-    }
-    if (Object.hasOwn(value, "provider") && (typeof value.provider !== "string" || !PROVIDER_TOKEN.test(value.provider))) {
-        throw new TypeError("providerFault.provider must be a canonical provider token");
-    }
-    if (Object.hasOwn(value, "status") && (!Number.isInteger(value.status) || value.status < 100 || value.status > 599)) {
-        throw new TypeError("providerFault.status must be an HTTP status integer");
-    }
-    if (Object.hasOwn(value, "retryAfterMs") && (!Number.isSafeInteger(value.retryAfterMs) || value.retryAfterMs < 0)) {
-        throw new TypeError("providerFault.retryAfterMs must be a non-negative safe integer");
-    }
-    if (Object.hasOwn(value, "message") && (typeof value.message !== "string" || value.message.length === 0 ||
-        value.message.length > MAX_MESSAGE_LENGTH || /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/.test(value.message))) {
-        throw new TypeError(`providerFault.message must be 1-${MAX_MESSAGE_LENGTH} printable characters`);
-    }
-    const kind = isKnownProviderFaultKind(value.kind)
-        ? value.kind
-        : value.kind;
-    return {
-        kind,
-        ...(Object.hasOwn(value, "provider") ? { provider: value.provider } : {}),
-        ...(Object.hasOwn(value, "status") ? { status: value.status } : {}),
-        ...(Object.hasOwn(value, "retryAfterMs") ? { retryAfterMs: value.retryAfterMs } : {}),
-        ...(Object.hasOwn(value, "message") ? { message: value.message } : {})
-    };
-}

package/dist/_contracts/retry-core.d.ts

@@ -1,29 +0,0 @@
-/**
- * Public-safe retry primitives shared by public packages through the
- * `@aexhq/contracts/internal` subpath. Keep this module free of hosted
- * implementation details and do not export it from the public contracts root.
- */
-export declare const RETRYABLE_HTTP_STATUS: readonly number[];
-export declare const RATE_LIMIT_HTTP_STATUS: readonly number[];
-export interface RetryBackoffConfig {
-    readonly initialDelayMs: number;
-    readonly maxDelayMs: number;
-}
-export type RetryRandom = () => number;
-export declare function isRetryableHttpStatus(status: number): boolean;
-export declare function isRateLimitHttpStatus(status: number): boolean;
-/**
- * Parse an HTTP `Retry-After` header into milliseconds. RFC 7231 permits either
- * a non-negative integer number of seconds or an HTTP-date.
- */
-export declare function tryParseRetryAfterMs(headerValue: string | null | undefined, now?: number): number | undefined;
-/** @deprecated Use {@link tryParseRetryAfterMs}; this compatibility wrapper is identical. */
-export declare function parseRetryAfterMs(headerValue: string | null | undefined, now?: number): number | undefined;
-/**
- * Full-jitter exponential backoff: the nominal wait doubles per failed attempt
- * and the actual delay is sampled uniformly in `[0, nominal]`.
- */
-export declare function computeRetryBackoffDelayMs(config: RetryBackoffConfig, attemptNumber: number, random: RetryRandom): number;
-/** Combine a server `Retry-After` floor with the jittered backoff delay. */
-export declare function computeRetryDelayMs(config: RetryBackoffConfig, attemptNumber: number, random: RetryRandom, retryAfterMs: number | undefined): number;
-export declare function abortableSleep(ms: number, signal?: AbortSignal): Promise<void>;

package/dist/_contracts/retry-core.js

@@ -1,79 +0,0 @@
-/**
- * Public-safe retry primitives shared by public packages through the
- * `@aexhq/contracts/internal` subpath. Keep this module free of hosted
- * implementation details and do not export it from the public contracts root.
- */
-export const RETRYABLE_HTTP_STATUS = [429, 500, 502, 503, 504, 529];
-export const RATE_LIMIT_HTTP_STATUS = [429, 503, 529];
-const RETRYABLE_HTTP_STATUS_SET = new Set(RETRYABLE_HTTP_STATUS);
-const RATE_LIMIT_HTTP_STATUS_SET = new Set(RATE_LIMIT_HTTP_STATUS);
-export function isRetryableHttpStatus(status) {
-    return RETRYABLE_HTTP_STATUS_SET.has(status);
-}
-export function isRateLimitHttpStatus(status) {
-    return RATE_LIMIT_HTTP_STATUS_SET.has(status);
-}
-/**
- * Parse an HTTP `Retry-After` header into milliseconds. RFC 7231 permits either
- * a non-negative integer number of seconds or an HTTP-date.
- */
-export function tryParseRetryAfterMs(headerValue, now = Date.now()) {
-    if (headerValue === null || headerValue === undefined)
-        return undefined;
-    const trimmed = headerValue.trim();
-    if (trimmed.length === 0)
-        return undefined;
-    if (/^\d+$/.test(trimmed)) {
-        return Number(trimmed) * 1000;
-    }
-    const dateMs = Date.parse(trimmed);
-    if (!Number.isNaN(dateMs)) {
-        return Math.max(0, dateMs - now);
-    }
-    return undefined;
-}
-/** @deprecated Use {@link tryParseRetryAfterMs}; this compatibility wrapper is identical. */
-export function parseRetryAfterMs(headerValue, now = Date.now()) {
-    return tryParseRetryAfterMs(headerValue, now);
-}
-/**
- * Full-jitter exponential backoff: the nominal wait doubles per failed attempt
- * and the actual delay is sampled uniformly in `[0, nominal]`.
- */
-export function computeRetryBackoffDelayMs(config, attemptNumber, random) {
-    const exponent = Math.max(0, attemptNumber - 1);
-    const nominal = Math.min(config.maxDelayMs, config.initialDelayMs * 2 ** exponent);
-    return Math.round(random() * nominal);
-}
-/** Combine a server `Retry-After` floor with the jittered backoff delay. */
-export function computeRetryDelayMs(config, attemptNumber, random, retryAfterMs) {
-    const backoff = computeRetryBackoffDelayMs(config, attemptNumber, random);
-    return retryAfterMs === undefined ? backoff : Math.max(retryAfterMs, backoff);
-}
-export function abortableSleep(ms, signal) {
-    return new Promise((resolve, reject) => {
-        if (signal?.aborted) {
-            reject(abortReason(signal));
-            return;
-        }
-        const timer = setTimeout(() => {
-            signal?.removeEventListener("abort", onAbort);
-            resolve();
-        }, ms);
-        const onAbort = () => {
-            clearTimeout(timer);
-            reject(signal ? abortReason(signal) : makeAbortError());
-        };
-        signal?.addEventListener("abort", onAbort, { once: true });
-    });
-}
-function abortReason(signal) {
-    return signal.reason instanceof Error ? signal.reason : makeAbortError();
-}
-function makeAbortError() {
-    if (typeof DOMException !== "undefined")
-        return new DOMException("Aborted", "AbortError");
-    const err = new Error("Aborted");
-    err.name = "AbortError";
-    return err;
-}

package/dist/_contracts/runner-event.d.ts

@@ -1,117 +0,0 @@
-/**
- * Unified runner event schema. The managed runtime feeds one shape into
- * the hosted aex event pipeline:
- *
- *   - The per-session managed runtime POSTs batches of NDJSON events to
- *     `/sessions/{id}/runner/events`; the runtime adapter translates each
- *     event into one or more `RunnerEvent`s.
- *
- * The downstream subscribers (dashboard, SDK `streamEvents`, observable
- * spans) never see runtime-specific wire shapes — they only see
- * `RunnerEvent`s.
- *
- * This is the public event contract consumed by SDK and CLI clients.
- */
-import { type JsonValue } from "./value-guards.js";
-/**
- * Schema version. Bump when the shape of `RunnerEvent`, its kind set,
- * or the batch envelope changes. Subscribers gate on this so a future
- * v2 wire shape can land behind a feature flag.
- */
-export declare const RUNNER_EVENT_VERSION: 1;
-/**
- * The set of event kinds emitted into the unified stream. Adapters
- * fold runtime-specific events into one of these — anything that
- * doesn't fit is mapped to `notification` so the data is captured
- * even when no UI handler exists yet.
- *
- *   - `runtime_started`  — the managed runtime announced "ready" or
- *                          accepted the first turn.
- *   - `assistant_text`   — model text delta.
- *   - `tool_request`     — model emitted a tool_use / function call.
- *   - `tool_response`    — tool result delivered back to the model.
- *   - `skill_loaded`     — a skill was loaded from a provider ref or
- *                          a workspace folder mount.
- *   - `file_uploaded`    — a file became available to the agent
- *                          (Files API id OR workspace path).
- *   - `notification`     — runtime/extension notification; catch-all
- *                          for diagnostic data.
- *   - `stream_error`     — stream-level error (non-fatal). Subscribers
- *                          may surface this as a UI warning; the session
- *                          continues unless `runtime_terminal` follows.
- *   - `runtime_terminal` — the session reached a terminal state. The
- *                          adapter MUST emit exactly one of these per
- *                          run; subscribers gate on it for end-of-stream.
- */
-export declare const RUNNER_EVENT_KINDS: readonly ["runtime_started", "assistant_text", "tool_request", "tool_response", "skill_loaded", "file_uploaded", "notification", "stream_error", "runtime_terminal"];
-export type RunnerEventKind = (typeof RUNNER_EVENT_KINDS)[number];
-/**
- * One event in the unified stream. `seq` is monotonically increasing
- * within a single run (the adapter is responsible for assigning seqs
- * — no two events with the same `seq` for the same `sessionId`); `tMs` is
- * a millisecond-resolution timestamp that is also monotonically
- * non-decreasing within a single run (an event's `tMs` is never less
- * than the previous event's `tMs`). `data` carries the runtime- and
- * kind-specific payload, JSON-typed so the batch round-trips through
- * the database column without ad-hoc serialization.
- */
-export interface RunnerEvent {
-    readonly seq: number;
-    readonly tMs: number;
-    /** Optional per-source ordering counter carried through to AexEvent. */
-    readonly sourceSeq?: number;
-    /** Optional producer wall-clock time in milliseconds. */
-    readonly emittedAt?: number;
-    readonly kind: RunnerEventKind;
-    readonly data: Readonly<Record<string, JsonValue>>;
-}
-/**
- * Batch envelope. The runner ships one or more events per POST so the
- * inbox writes them atomically. `events` MUST be sorted by `seq`
- * ascending; api.aex.dev rejects malformed batches before touching
- * Postgres.
- */
-export interface RunnerEventBatch {
-    readonly v: typeof RUNNER_EVENT_VERSION;
-    readonly sessionId: string;
-    readonly events: readonly RunnerEvent[];
-}
-/**
- * Maximum number of events per batch. Bounds the size of the body
- * api.aex.dev accepts and the size of the downstream Postgres / metadata-store
- * write. Larger streams are split into multiple batches; the runner is
- * responsible for chunking.
- */
-export declare const RUNNER_EVENT_BATCH_MAX_EVENTS: 256;
-/**
- * Validation outcome for an inbound batch. The `ok` branch returns
- * the parsed batch with frozen events; the `error` branch returns the
- * code + a short human message suitable for an HTTP 400 body. Codes
- * are stable strings — the dashboard / SDK may branch on them.
- */
-export type RunnerEventBatchValidation = {
-    readonly ok: true;
-    readonly batch: RunnerEventBatch;
-} | {
-    readonly ok: false;
-    readonly code: RunnerEventBatchValidationCode;
-    readonly message: string;
-};
-export declare const RUNNER_EVENT_BATCH_VALIDATION_CODES: readonly ["invalid_envelope", "version_mismatch", "missing_session_id", "empty_batch", "batch_too_large", "invalid_event", "seq_not_monotonic", "t_ms_not_monotonic"];
-export type RunnerEventBatchValidationCode = (typeof RUNNER_EVENT_BATCH_VALIDATION_CODES)[number];
-/**
- * Parse + validate an inbound runner event batch (untrusted input).
- * Used at the api.aex.dev ingress so adapters never have to
- * re-check the wire shape, and used by tests to assert the contract.
- *
- * Successful validation guarantees:
- *   - top-level envelope matches {@link RunnerEventBatch}
- *   - `v === RUNNER_EVENT_VERSION`
- *   - `sessionId` is a non-empty string
- *   - `events` is a non-empty array of at most
- *     {@link RUNNER_EVENT_BATCH_MAX_EVENTS} entries
- *   - each event is a {@link RunnerEvent} with a known `kind`
- *   - `seq` is strictly increasing across the batch
- *   - `tMs` is non-decreasing across the batch
- */
-export declare function validateRunnerEventBatch(input: unknown): RunnerEventBatchValidation;