@aexhq/sdk 0.46.4-canary → 0.50.0

package/dist/_contracts/schemas/response-identity.js

@@ -1,131 +0,0 @@
-/**
- * Response schema for `GET /whoami` — the data-plane identity canary.
- *
- * This is the route `parseWhoAmI` already hand-guards, including an explicit
- * "these three fields were removed and must not reappear" check for `caps`,
- * `tokenId` and `tokenName`. A strict object generalises that: EVERY undeclared
- * field is a reappearance, not just the three someone remembered to list.
- *
- * The CONTROL plane serves a different body at the same path — an
- * `account_token` principal, parsed by `parseAccountWhoAmI`. It is declared here
- * too, and the two are NOT unioned: unioning them would let a data-plane whoami
- * pass while carrying a control-plane body. They are kept apart by ORIGIN
- * instead — `WireResponse` carries the origin it came from, and the harness is
- * installed with the plane its bindings describe. See
- * `testing/response-bindings.ts`.
- */
-import * as z from "zod/mini";
-import { BILLING_ADMISSION_STATES } from "../billing-admission.js";
-import { RUNTIME_KINDS } from "./runtime-kind.js";
-import { RUNTIME_SIZES } from "./runtime-sizes.js";
-import { describeResponse, responseObject, wireBoolean, wireEnum, wireLiteral, wireNonEmptyString, wireNumber, wireString } from "./response-common.js";
-const optional = z.optional;
-/** A per-runtime-kind partial map, strict about which kinds may appear. */
-function byRuntimeKind(value) {
-    return responseObject({
-        container: optional(value),
-        spot_container: optional(value),
-        lambda: optional(value)
-    });
-}
-const RuntimeProfileSchema = responseObject({
-    schemaVersion: wireLiteral(1),
-    runtimeKind: wireEnum(RUNTIME_KINDS),
-    capabilities: responseObject({
-        toolExecution: wireEnum(["supported", "unsupported"]),
-        workspaceCheckpoint: wireEnum(["supported", "unsupported"]),
-        workspaceFileCapture: wireEnum(["supported", "unsupported"]),
-        streamingDeltas: wireEnum(["supported", "unsupported"]),
-        approvalGate: wireEnum(["supported", "unsupported"]),
-        postHook: wireEnum(["supported", "unsupported"]),
-        mcpTools: wireEnum(["supported", "unsupported"]),
-        scheduledWait: wireEnum(["supported", "unsupported"]),
-        customerSecrets: wireEnum(["supported", "unsupported"]),
-        containedEgress: wireEnum(["supported", "unsupported"])
-    }),
-    limits: responseObject({
-        maxSessionMs: wireNumber,
-        maxSingleEffectMs: wireNumber,
-        maxWorkspaceBytes: wireNumber,
-        maxConcurrentToolCalls: wireNumber
-    }),
-    delivery: responseObject({
-        toolExecution: wireEnum(["at-least-once", "exactly-once"]),
-        coldStartClass: wireEnum(["warm", "cold-seconds", "cold-tens-of-seconds"]),
-        idleBilling: wireEnum(["wall-clock", "zero"])
-    }),
-    computeBasis: wireEnum(["wall_clock", "microvm_running"])
-});
-const RuntimeProfilesSchema = responseObject({
-    container: RuntimeProfileSchema,
-    spot_container: RuntimeProfileSchema,
-    lambda: RuntimeProfileSchema
-});
-export const RuntimeCapabilitiesSchema = describeResponse("RuntimeCapabilities", "Authenticated runtime availability and behavior profiles for the workspace. " +
-    "`sizesByRuntimeKind` and `unavailable` are complementary partial maps over " +
-    "the runtime kinds; `profilesByRuntimeKind` is total.", responseObject({
-    schemaVersion: wireLiteral(1),
-    capabilityVersion: wireNonEmptyString,
-    capabilityHash: wireNonEmptyString,
-    availableRuntimeKinds: z.array(wireEnum(RUNTIME_KINDS)),
-    sizesByRuntimeKind: byRuntimeKind(z.array(wireEnum(RUNTIME_SIZES))),
-    unavailable: byRuntimeKind(responseObject({ code: wireNonEmptyString })),
-    profilesByRuntimeKind: RuntimeProfilesSchema
-}));
-/**
- * Effective workspace limits, from the same read models admission uses.
- *
- * Every field is REQUIRED. The plan catalog is gone, and with it the optional
- * `pastDueAt` / `graceEndsAt` pair that only existed while a subscription could
- * be in arrears — prepaid credit cannot go negative, so there is no dunning
- * state to report. What gates a submit now is the pair
- * (`balanceUsd`, `llmTokenAllowanceRemainingUsd`), and `admissionState` says
- * which of the three card-derived states produced the caps above it. A strict
- * schema still expecting the retired fields fails C4 against the current server.
- *
- * `admissionState` is a CLOSED enum here — unlike an allowance `dimension`, the
- * three admission states are public contract (`BillingAdmissionState`), not
- * hosted policy, so the declared union and the wire assertion share one list.
- */
-export const WhoAmILimitsSchema = describeResponse("WhoAmILimits", "Effective concurrency, rate, spend and prepaid-credit limits plus the card-derived admission state.", responseObject({
-    maxConcurrentSessions: wireNumber,
-    submitRatePerMinute: wireNumber,
-    spendCapUsd: wireNumber,
-    monthSpendUsd: wireNumber,
-    balanceUsd: wireNumber,
-    balanceGraceFloorUsd: wireNumber,
-    llmTokenAllowanceRemainingUsd: wireNumber,
-    creditGateActive: wireBoolean,
-    paymentMethodStatus: wireEnum(["none", "active"]),
-    admissionState: wireEnum(BILLING_ADMISSION_STATES),
-    autoTopupEnabled: wireBoolean,
-    accountType: wireEnum(["standard", "internal"])
-}));
-/** `GET /whoami` on the DATA plane (workspace API key). */
-export const WhoAmIResponseSchema = describeResponse("WhoAmIResponse", "Identity of a workspace API key. Strict: a removed field reappearing fails, " +
-    "which is what the hand-written `caps`/`tokenId`/`tokenName` guard did for three names.", responseObject({
-    ok: wireLiteral(true),
-    principalType: wireLiteral("api_key"),
-    workspaceId: wireNonEmptyString,
-    scopes: z.array(wireNonEmptyString),
-    limits: WhoAmILimitsSchema,
-    runtimeCapabilities: optional(RuntimeCapabilitiesSchema)
-}));
-/**
- * `GET /whoami` on the CONTROL plane (account PAT / device session).
- *
- * Not bound to a data-plane route: `api-routes.ts` describes the data plane, and
- * the control plane has no route table in this package yet. Declared so the
- * shape has one statement, and so a control-plane binding table can be built
- * without re-deriving it.
- */
-export const AccountWhoAmIResponseSchema = describeResponse("AccountWhoAmIResponse", "Identity of a control-plane account token. No workspace, no data-plane limits.", responseObject({
-    ok: wireLiteral(true),
-    principalType: wireLiteral("account_token"),
-    appUserId: wireNonEmptyString,
-    scopes: z.array(wireString),
-    orgId: optional(wireString),
-    tokenId: optional(wireString),
-    tokenName: optional(wireString),
-    tokenKind: optional(wireString)
-}));

package/dist/_contracts/schemas/response-mcp-servers.d.ts

@@ -1,51 +0,0 @@
-/**
- * Response schemas for the `mcpServers.*` family — persisted workspace MCP
- * server configuration.
- *
- * `headerShape` is header NAMES only; the values live in the secret store. As
- * with secrets, the strict object is what keeps that true: a `headers` or
- * `authorization` key appearing on a read fails the suite.
- *
- * These four routes had NO declared client type: `operations.ts` has no
- * mcp-server operations, so the CLI/dashboard reached them directly and cast the
- * result. `McpServerRecord` / `McpServerList` in `runtime-types.ts` are now
- * `z.infer`red from the schemas below, so the contract has exactly one
- * statement. The shapes themselves come from the server projection in
- * `api/routes/mcp-servers.ts`.
- *
- * `workspaceId` is the PUBLIC `wsp_<hex>` form here (the handler runs it through
- * `publicWorkspaceId`), matching `whoami` — and NOT matching the billing ledger,
- * the admin-billing routes or the workspace erase, which all emit raw ids.
- */
-import * as z from "zod/mini";
-export declare const McpServerRecordSchema: z.ZodMiniObject<{
-    id: z.ZodMiniString<string>;
-    workspaceId: z.ZodMiniString<string>;
-    name: z.ZodMiniString<string>;
-    url: z.ZodMiniString<string>;
-    headerShape: z.ZodMiniArray<z.ZodMiniString<string>>;
-    createdAt: z.ZodMiniString<string>;
-    updatedAt: z.ZodMiniString<string>;
-}, z.core.$strict>;
-export declare const McpServerResponseSchema: z.ZodMiniObject<{
-    mcpServer: z.ZodMiniObject<{
-        id: z.ZodMiniString<string>;
-        workspaceId: z.ZodMiniString<string>;
-        name: z.ZodMiniString<string>;
-        url: z.ZodMiniString<string>;
-        headerShape: z.ZodMiniArray<z.ZodMiniString<string>>;
-        createdAt: z.ZodMiniString<string>;
-        updatedAt: z.ZodMiniString<string>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export declare const McpServerListResponseSchema: z.ZodMiniObject<{
-    mcpServers: z.ZodMiniArray<z.ZodMiniObject<{
-        id: z.ZodMiniString<string>;
-        workspaceId: z.ZodMiniString<string>;
-        name: z.ZodMiniString<string>;
-        url: z.ZodMiniString<string>;
-        headerShape: z.ZodMiniArray<z.ZodMiniString<string>>;
-        createdAt: z.ZodMiniString<string>;
-        updatedAt: z.ZodMiniString<string>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;

package/dist/_contracts/schemas/response-mcp-servers.js

@@ -1,32 +0,0 @@
-/**
- * Response schemas for the `mcpServers.*` family — persisted workspace MCP
- * server configuration.
- *
- * `headerShape` is header NAMES only; the values live in the secret store. As
- * with secrets, the strict object is what keeps that true: a `headers` or
- * `authorization` key appearing on a read fails the suite.
- *
- * These four routes had NO declared client type: `operations.ts` has no
- * mcp-server operations, so the CLI/dashboard reached them directly and cast the
- * result. `McpServerRecord` / `McpServerList` in `runtime-types.ts` are now
- * `z.infer`red from the schemas below, so the contract has exactly one
- * statement. The shapes themselves come from the server projection in
- * `api/routes/mcp-servers.ts`.
- *
- * `workspaceId` is the PUBLIC `wsp_<hex>` form here (the handler runs it through
- * `publicWorkspaceId`), matching `whoami` — and NOT matching the billing ledger,
- * the admin-billing routes or the workspace erase, which all emit raw ids.
- */
-import * as z from "zod/mini";
-import { describeResponse, responseObject, wireNonEmptyString, wireString } from "./response-common.js";
-export const McpServerRecordSchema = describeResponse("McpServerRecord", "One persisted workspace MCP server. `headerShape` lists header NAMES only.", responseObject({
-    id: wireNonEmptyString,
-    workspaceId: wireNonEmptyString,
-    name: wireNonEmptyString,
-    url: wireNonEmptyString,
-    headerShape: z.array(wireString),
-    createdAt: wireNonEmptyString,
-    updatedAt: wireNonEmptyString
-}));
-export const McpServerResponseSchema = describeResponse("McpServerResponse", "One workspace MCP server configuration.", responseObject({ mcpServer: McpServerRecordSchema }));
-export const McpServerListResponseSchema = describeResponse("McpServerListResponse", "Every workspace MCP server, newest first. Not paged.", responseObject({ mcpServers: z.array(McpServerRecordSchema) }));

package/dist/_contracts/schemas/response-secrets.d.ts

@@ -1,50 +0,0 @@
-/**
- * Response schemas for the `secrets.*` family — the workspace secret store.
- *
- * These records are METADATA ONLY by design: the persisted value is write-only
- * through this API. A strict object is the check that keeps it that way — if a
- * `value`, `envelope` or `ciphertext` key ever appears on a read, the suite
- * fails rather than the value quietly reaching a log.
- *
- * Divergence from the declared `SecretRecord`: that interface makes `createdAt`
- * and `updatedAt` optional and adds `deletedAt?: string | null`. The server
- * sends all six fields unconditionally and never a `deletedAt`. `deletedAt` is
- * kept (our own type declares it). The index signature that interface also
- * carried is gone — see `response-common.ts`.
- *
- * `createdAt` / `updatedAt` are ISO-8601 with a `Z`, unlike the billing
- * timestamps, which are raw Data-API text.
- */
-import * as z from "zod/mini";
-export declare const SecretRecordSchema: z.ZodMiniObject<{
-    id: z.ZodMiniString<string>;
-    name: z.ZodMiniString<string>;
-    version: z.ZodMiniNumberFormat;
-    state: z.ZodMiniLiteral<"ready">;
-    createdAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    updatedAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    deletedAt: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
-}, z.core.$strict>;
-/** `POST /secrets` (201), `GET /secrets/{name}` (200), `POST /secrets/{name}/rotate` (200). */
-export declare const SecretResponseSchema: z.ZodMiniObject<{
-    secret: z.ZodMiniObject<{
-        id: z.ZodMiniString<string>;
-        name: z.ZodMiniString<string>;
-        version: z.ZodMiniNumberFormat;
-        state: z.ZodMiniLiteral<"ready">;
-        createdAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        updatedAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        deletedAt: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export declare const SecretListResponseSchema: z.ZodMiniObject<{
-    secrets: z.ZodMiniArray<z.ZodMiniObject<{
-        id: z.ZodMiniString<string>;
-        name: z.ZodMiniString<string>;
-        version: z.ZodMiniNumberFormat;
-        state: z.ZodMiniLiteral<"ready">;
-        createdAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        updatedAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        deletedAt: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;

package/dist/_contracts/schemas/response-secrets.js

@@ -1,32 +0,0 @@
-/**
- * Response schemas for the `secrets.*` family — the workspace secret store.
- *
- * These records are METADATA ONLY by design: the persisted value is write-only
- * through this API. A strict object is the check that keeps it that way — if a
- * `value`, `envelope` or `ciphertext` key ever appears on a read, the suite
- * fails rather than the value quietly reaching a log.
- *
- * Divergence from the declared `SecretRecord`: that interface makes `createdAt`
- * and `updatedAt` optional and adds `deletedAt?: string | null`. The server
- * sends all six fields unconditionally and never a `deletedAt`. `deletedAt` is
- * kept (our own type declares it). The index signature that interface also
- * carried is gone — see `response-common.ts`.
- *
- * `createdAt` / `updatedAt` are ISO-8601 with a `Z`, unlike the billing
- * timestamps, which are raw Data-API text.
- */
-import * as z from "zod/mini";
-import { describeResponse, responseObject, wireLiteral, wireNonEmptyString, wirePositiveInteger, wireString } from "./response-common.js";
-const optional = z.optional;
-export const SecretRecordSchema = describeResponse("SecretRecord", "Metadata for one workspace secret. Never carries the value.", responseObject({
-    id: wireNonEmptyString,
-    name: wireNonEmptyString,
-    version: wirePositiveInteger,
-    state: wireLiteral("ready"),
-    createdAt: optional(wireString),
-    updatedAt: optional(wireString),
-    deletedAt: optional(z.nullable(wireString))
-}));
-/** `POST /secrets` (201), `GET /secrets/{name}` (200), `POST /secrets/{name}/rotate` (200). */
-export const SecretResponseSchema = describeResponse("SecretResponse", "One workspace secret's metadata.", responseObject({ secret: SecretRecordSchema }));
-export const SecretListResponseSchema = describeResponse("SecretListResponse", "Every workspace secret's metadata, ordered by name. Not paged.", responseObject({ secrets: z.array(SecretRecordSchema) }));

package/dist/_contracts/schemas/response-sessions-internal.d.ts

@@ -1,200 +0,0 @@
-/**
- * Response schemas for the three session routes that are JSON but are not part
- * of the bearer-key SDK surface: the OTLP telemetry pull, and the two
- * writer-token hops the in-container runtime uses to read a child's result and
- * to finalize it.
- *
- * They are separated from `response-sessions.ts` because they have a different
- * audience and a different failure mode: nothing in this repository's
- * `HttpClient` call sites can produce them, so they are permanently
- * "unexercised" in a C4 report. `testing/response-bindings.ts` names that fact
- * rather than leaving a reader to infer thin coverage.
- *
- * The OTLP shapes are the ONE place where the wire is standards-defined rather
- * than ours: they mirror `otlp-projection.ts`, which is itself the declaration
- * of what `toOTLP` emits, so this schema and that type must agree exactly.
- */
-import * as z from "zod/mini";
-export declare const ChildResultResponseSchema: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
-    id: z.ZodMiniString<string>;
-    state: z.ZodMiniEnum<{
-        running: "running";
-        queued: "queued";
-        settling: "settling";
-    }>;
-    files: z.ZodMiniArray<z.ZodMiniObject<{
-        id: z.ZodMiniString<string>;
-        path: z.ZodMiniString<string>;
-        checkpointId: z.ZodMiniString<string>;
-        sizeBytes: z.ZodMiniNumberFormat;
-        sha256: z.ZodMiniString<string>;
-        contentType: z.ZodMiniString<string>;
-    }, z.core.$strict>>;
-}, z.core.$strict>, z.ZodMiniObject<{
-    id: z.ZodMiniString<string>;
-    state: z.ZodMiniLiteral<"finished">;
-    outcome: z.ZodMiniEnum<{
-        succeeded: "succeeded";
-        failed: "failed";
-        timed_out: "timed_out";
-        cancelled: "cancelled";
-        interrupted: "interrupted";
-    }>;
-    files: z.ZodMiniArray<z.ZodMiniObject<{
-        id: z.ZodMiniString<string>;
-        path: z.ZodMiniString<string>;
-        checkpointId: z.ZodMiniString<string>;
-        sizeBytes: z.ZodMiniNumberFormat;
-        sha256: z.ZodMiniString<string>;
-        contentType: z.ZodMiniString<string>;
-    }, z.core.$strict>>;
-    text: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    failureClass: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    failureMessage: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    conflicts: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
-        path: z.ZodMiniString<string>;
-        kind: z.ZodMiniEnum<{
-            blocked: "blocked";
-            stale: "stale";
-        }>;
-        resolved: z.ZodMiniLiteral<false>;
-    }, z.core.$strict>>>;
-}, z.core.$strict>]>;
-export declare const ChildFinalizeResponseSchema: z.ZodMiniObject<{
-    id: z.ZodMiniString<string>;
-    lifecycleStatus: z.ZodMiniEnum<{
-        error: "error";
-        idle: "idle";
-    }>;
-    outcome: z.ZodMiniEnum<{
-        succeeded: "succeeded";
-        failed: "failed";
-        timed_out: "timed_out";
-        cancelled: "cancelled";
-        interrupted: "interrupted";
-    }>;
-    checkpoint: z.ZodMiniOptional<z.ZodMiniObject<{
-        checkpointId: z.ZodMiniString<string>;
-        runId: z.ZodMiniString<string>;
-        turnSeq: z.ZodMiniNumberFormat;
-        committedAt: z.ZodMiniString<string>;
-        throughSeq: z.ZodMiniNumberFormat;
-    }, z.core.$strict>>;
-    failureClass: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    failureMessage: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    childCostUsd: z.ZodMiniNumber<number>;
-    providerUsage: z.ZodMiniArray<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>>;
-}, z.core.$strict>;
-/**
- * The OTLP body, keyed by the requested signal.
- *
- * A union of two SINGLE-KEY strict objects is the schema form of what
- * `assertStandardsPureOtlpBody` asserts by hand: exactly one root key, and no
- * aex pagination smuggled into a standards body — the cursor rides in the
- * `x-aex-next-cursor` HEADER, which this schema cannot see and must therefore
- * not tolerate in the body.
- */
-export declare const SessionOtlpResponseSchema: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
-    resourceSpans: z.ZodMiniArray<z.ZodMiniObject<{
-        resource: z.ZodMiniObject<{
-            attributes: z.ZodMiniArray<z.ZodMiniObject<{
-                key: z.ZodMiniString<string>;
-                value: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
-                    stringValue: z.ZodMiniString<string>;
-                }, z.core.$strict>, z.ZodMiniObject<{
-                    boolValue: z.ZodMiniBoolean<boolean>;
-                }, z.core.$strict>, z.ZodMiniObject<{
-                    intValue: z.ZodMiniString<string>;
-                }, z.core.$strict>, z.ZodMiniObject<{
-                    doubleValue: z.ZodMiniNumber<number>;
-                }, z.core.$strict>]>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>;
-        scopeSpans: z.ZodMiniArray<z.ZodMiniObject<{
-            scope: z.ZodMiniObject<{
-                name: z.ZodMiniString<string>;
-                version: z.ZodMiniOptional<z.ZodMiniString<string>>;
-            }, z.core.$strict>;
-            spans: z.ZodMiniArray<z.ZodMiniObject<{
-                traceId: z.ZodMiniString<string>;
-                spanId: z.ZodMiniString<string>;
-                parentSpanId: z.ZodMiniOptional<z.ZodMiniString<string>>;
-                name: z.ZodMiniString<string>;
-                kind: z.ZodMiniLiteral<1>;
-                startTimeUnixNano: z.ZodMiniString<string>;
-                endTimeUnixNano: z.ZodMiniString<string>;
-                attributes: z.ZodMiniArray<z.ZodMiniObject<{
-                    key: z.ZodMiniString<string>;
-                    value: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
-                        stringValue: z.ZodMiniString<string>;
-                    }, z.core.$strict>, z.ZodMiniObject<{
-                        boolValue: z.ZodMiniBoolean<boolean>;
-                    }, z.core.$strict>, z.ZodMiniObject<{
-                        intValue: z.ZodMiniString<string>;
-                    }, z.core.$strict>, z.ZodMiniObject<{
-                        doubleValue: z.ZodMiniNumber<number>;
-                    }, z.core.$strict>]>;
-                }, z.core.$strict>>;
-                status: z.ZodMiniObject<{
-                    code: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<1>, z.ZodMiniLiteral<2>]>;
-                }, z.core.$strict>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-}, z.core.$strict>, z.ZodMiniObject<{
-    resourceLogs: z.ZodMiniArray<z.ZodMiniObject<{
-        resource: z.ZodMiniObject<{
-            attributes: z.ZodMiniArray<z.ZodMiniObject<{
-                key: z.ZodMiniString<string>;
-                value: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
-                    stringValue: z.ZodMiniString<string>;
-                }, z.core.$strict>, z.ZodMiniObject<{
-                    boolValue: z.ZodMiniBoolean<boolean>;
-                }, z.core.$strict>, z.ZodMiniObject<{
-                    intValue: z.ZodMiniString<string>;
-                }, z.core.$strict>, z.ZodMiniObject<{
-                    doubleValue: z.ZodMiniNumber<number>;
-                }, z.core.$strict>]>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>;
-        scopeLogs: z.ZodMiniArray<z.ZodMiniObject<{
-            scope: z.ZodMiniObject<{
-                name: z.ZodMiniString<string>;
-                version: z.ZodMiniOptional<z.ZodMiniString<string>>;
-            }, z.core.$strict>;
-            logRecords: z.ZodMiniArray<z.ZodMiniObject<{
-                timeUnixNano: z.ZodMiniString<string>;
-                observedTimeUnixNano: z.ZodMiniString<string>;
-                severityNumber: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<9>, z.ZodMiniLiteral<13>, z.ZodMiniLiteral<17>]>;
-                severityText: z.ZodMiniEnum<{
-                    INFO: "INFO";
-                    WARN: "WARN";
-                    ERROR: "ERROR";
-                }>;
-                body: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
-                    stringValue: z.ZodMiniString<string>;
-                }, z.core.$strict>, z.ZodMiniObject<{
-                    boolValue: z.ZodMiniBoolean<boolean>;
-                }, z.core.$strict>, z.ZodMiniObject<{
-                    intValue: z.ZodMiniString<string>;
-                }, z.core.$strict>, z.ZodMiniObject<{
-                    doubleValue: z.ZodMiniNumber<number>;
-                }, z.core.$strict>]>;
-                attributes: z.ZodMiniArray<z.ZodMiniObject<{
-                    key: z.ZodMiniString<string>;
-                    value: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
-                        stringValue: z.ZodMiniString<string>;
-                    }, z.core.$strict>, z.ZodMiniObject<{
-                        boolValue: z.ZodMiniBoolean<boolean>;
-                    }, z.core.$strict>, z.ZodMiniObject<{
-                        intValue: z.ZodMiniString<string>;
-                    }, z.core.$strict>, z.ZodMiniObject<{
-                        doubleValue: z.ZodMiniNumber<number>;
-                    }, z.core.$strict>]>;
-                }, z.core.$strict>>;
-                traceId: z.ZodMiniOptional<z.ZodMiniString<string>>;
-                spanId: z.ZodMiniOptional<z.ZodMiniString<string>>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-}, z.core.$strict>]>;

package/dist/_contracts/schemas/response-sessions-internal.js

@@ -1,142 +0,0 @@
-/**
- * Response schemas for the three session routes that are JSON but are not part
- * of the bearer-key SDK surface: the OTLP telemetry pull, and the two
- * writer-token hops the in-container runtime uses to read a child's result and
- * to finalize it.
- *
- * They are separated from `response-sessions.ts` because they have a different
- * audience and a different failure mode: nothing in this repository's
- * `HttpClient` call sites can produce them, so they are permanently
- * "unexercised" in a C4 report. `testing/response-bindings.ts` names that fact
- * rather than leaving a reader to infer thin coverage.
- *
- * The OTLP shapes are the ONE place where the wire is standards-defined rather
- * than ours: they mirror `otlp-projection.ts`, which is itself the declaration
- * of what `toOTLP` emits, so this schema and that type must agree exactly.
- */
-import * as z from "zod/mini";
-import { SESSION_TERMINAL_OUTCOMES } from "../status.js";
-import { CheckpointRevisionSchema } from "./response-sessions.js";
-import { describeResponse, responseObject, wireEnum, wireLiteral, wireNonEmptyString, wireNonNegativeInteger, wireNonNegativeNumber, wireString } from "./response-common.js";
-const optional = z.optional;
-// ===========================================================================
-// GET /sessions/{id}/result — writer-token child result
-// ===========================================================================
-/**
- * A child file as the result route projects it.
- *
- * NOTE the key is `path`, not `filename` — this is NOT the
- * `publicFileFromObject` shape the public `/files` routes emit. Two projections
- * of one concept, differing in one key name.
- */
-const ChildResultFileSchema = responseObject({
-    id: wireNonEmptyString,
-    path: wireString,
-    checkpointId: wireNonEmptyString,
-    sizeBytes: wireNonNegativeInteger,
-    sha256: wireString,
-    contentType: wireString
-});
-const ChildResultPendingSchema = responseObject({
-    id: wireNonEmptyString,
-    state: wireEnum(["settling", "running", "queued"]),
-    files: z.array(ChildResultFileSchema)
-});
-const ChildResultFinishedSchema = responseObject({
-    id: wireNonEmptyString,
-    state: wireLiteral("finished"),
-    outcome: wireEnum(SESSION_TERMINAL_OUTCOMES),
-    files: z.array(ChildResultFileSchema),
-    text: optional(wireString),
-    failureClass: optional(wireString),
-    failureMessage: optional(wireString),
-    conflicts: optional(z.array(responseObject({
-        path: wireString,
-        kind: wireEnum(["stale", "blocked"]),
-        resolved: wireLiteral(false)
-    })))
-});
-export const ChildResultResponseSchema = describeResponse("ChildResultResponse", "A subagent child's result: still in flight, or finished with its outcome and files.", z.union([ChildResultPendingSchema, ChildResultFinishedSchema], {
-    error: 'child result must be state "settling"/"running"/"queued", or "finished" with an outcome'
-}));
-// ===========================================================================
-// POST /sessions/{id}/finalize — writer-token child settle hop
-// ===========================================================================
-export const ChildFinalizeResponseSchema = describeResponse("ChildFinalizeResponse", "The settled child's terminal facts. No `session` envelope — this route is not " +
-    "shaped like the public session routes.", responseObject({
-    id: wireNonEmptyString,
-    lifecycleStatus: wireEnum(["idle", "error"]),
-    outcome: wireEnum(SESSION_TERMINAL_OUTCOMES),
-    checkpoint: optional(CheckpointRevisionSchema),
-    failureClass: optional(wireString),
-    failureMessage: optional(wireString),
-    childCostUsd: wireNonNegativeNumber,
-    providerUsage: z.array(z.record(wireString, z.unknown()))
-}));
-// ===========================================================================
-// GET /sessions/{id}/otel — standards-pure OTLP/HTTP JSON
-// ===========================================================================
-/**
- * OTLP `AnyValue`, restricted to the scalars the projection emits.
- *
- * A strict union rather than a loose object: OTLP's own `AnyValue` admits
- * arrays and kvlists, and `otlp-projection.ts` deliberately emits neither.
- */
-const OtlpAnyValueSchema = z.union([
-    responseObject({ stringValue: wireString }),
-    responseObject({ boolValue: z.boolean() }),
-    responseObject({ intValue: wireString }),
-    responseObject({ doubleValue: z.number() })
-], { error: "OTLP AnyValue must be one of stringValue, boolValue, intValue, doubleValue" });
-const OtlpKeyValueSchema = responseObject({ key: wireString, value: OtlpAnyValueSchema });
-const OtlpResourceSchema = responseObject({ attributes: z.array(OtlpKeyValueSchema) });
-const OtlpScopeSchema = responseObject({
-    name: wireString,
-    version: optional(wireString)
-});
-const OtlpTraceSpanSchema = responseObject({
-    traceId: wireString,
-    spanId: wireString,
-    parentSpanId: optional(wireString),
-    name: wireString,
-    kind: wireLiteral(1),
-    startTimeUnixNano: wireString,
-    endTimeUnixNano: wireString,
-    attributes: z.array(OtlpKeyValueSchema),
-    status: responseObject({ code: z.union([wireLiteral(1), wireLiteral(2)]) })
-});
-const OtlpLogRecordSchema = responseObject({
-    timeUnixNano: wireString,
-    observedTimeUnixNano: wireString,
-    severityNumber: z.union([wireLiteral(9), wireLiteral(13), wireLiteral(17)]),
-    severityText: wireEnum(["INFO", "WARN", "ERROR"]),
-    body: OtlpAnyValueSchema,
-    attributes: z.array(OtlpKeyValueSchema),
-    traceId: optional(wireString),
-    spanId: optional(wireString)
-});
-const OtlpTracesSchema = responseObject({
-    resourceSpans: z.array(responseObject({
-        resource: OtlpResourceSchema,
-        scopeSpans: z.array(responseObject({ scope: OtlpScopeSchema, spans: z.array(OtlpTraceSpanSchema) }))
-    }))
-});
-const OtlpLogsSchema = responseObject({
-    resourceLogs: z.array(responseObject({
-        resource: OtlpResourceSchema,
-        scopeLogs: z.array(responseObject({ scope: OtlpScopeSchema, logRecords: z.array(OtlpLogRecordSchema) }))
-    }))
-});
-/**
- * The OTLP body, keyed by the requested signal.
- *
- * A union of two SINGLE-KEY strict objects is the schema form of what
- * `assertStandardsPureOtlpBody` asserts by hand: exactly one root key, and no
- * aex pagination smuggled into a standards body — the cursor rides in the
- * `x-aex-next-cursor` HEADER, which this schema cannot see and must therefore
- * not tolerate in the body.
- */
-export const SessionOtlpResponseSchema = describeResponse("SessionOtlpResponse", "A standards-pure OTLP/HTTP JSON export body: `resourceSpans` for traces, " +
-    "`resourceLogs` for logs, and nothing else. Pagination is a response header.", z.union([OtlpTracesSchema, OtlpLogsSchema], {
-    error: "session OTLP response must contain exactly one of resourceSpans or resourceLogs"
-}));