reverseport 0.0.0-stage → 1.2.0

package/dist/contracts/artifactToolContracts.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { artifactOutputSchemas } from "./toolOutputSchemaGroups.js";
+import { artifactIntegrityPolicySchema } from "../domain/artifactIntegrityPolicy.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { toolContractMetadata } from "./toolEffects.js";
+import { requireOutputSchema } from "./toolOutputSchemaPrimitives.js";
+import { appleAssetCatalogInputSchema } from "../domain/apple/appleAssetCatalog.js";
+import { dylibResolutionInputSchema } from "../domain/apple/dylibResolution.js";
+import { keyedArchiveInputSchema } from "../domain/apple/keyedArchive.js";
+/** Exact caller boundary for deterministic artifact inventory. */
+export const artifactInventoryInputSchema = z.strictObject({
+    integrity_policy: artifactIntegrityPolicySchema,
+});
+/** Extraction needs no selector: it materializes every regular child file. */
+export const artifactExtractionInputSchema = z.strictObject({
+    integrity_policy: artifactIntegrityPolicySchema,
+});
+/** Provider input containing the destination chosen by the local adapter. */
+export const artifactExtractionExecutionSchema = artifactExtractionInputSchema.extend({
+    output_root: z.string().min(1),
+});
+const exampleInputSchema = z.record(z.string(), jsonValueSchema);
+const examples = {
+    inspect_artifact: {},
+    extract_artifact: {},
+    decode_interface_builder: {},
+    inspect_asset_catalog: { offset: 0, limit: 1000 },
+    inspect_keyed_archive: { path: "Contents/Resources/Model.plist" },
+    trace_dylib_resolution: {
+        roots: ["Contents/MacOS/App"],
+        architecture: "arm64",
+    },
+};
+const artifact = (name, description, inputSchema) => {
+    const outputSchema = requireOutputSchema(artifactOutputSchemas, name);
+    return {
+        name,
+        ...toolContractMetadata(name),
+        description,
+        kind: "artifact-provider",
+        inputSchema,
+        outputSchema,
+        examples: [
+            {
+                title: `Example ${name.replaceAll("_", " ")} request`,
+                input: exampleInputSchema.parse(examples[name] ?? {}),
+            },
+        ],
+    };
+};
+/** Artifact-graph inventory and safe extraction contracts. */
+export const ARTIFACT_TOOL_CONTRACTS = [
+    artifact("inspect_artifact", "Inspect an active archive or application package in one call. Returns the complete content-addressed artifact graph once, as the nested inventory Evidence, with root and integrity observations, integrity contradictions, hypotheses, unexplored branches, limitations, and next probes inline. Read-only DMG mounting is used automatically on supported macOS hosts. Integrity mismatches fail by default; record-and-continue keeps mismatches explicitly untrusted. It does not extract files; use extract_artifact to materialize its regular contents.", artifactInventoryInputSchema),
+    artifact("extract_artifact", "Extract all regular files from the active archive or application package into a fresh temporary directory chosen by REA. The result includes its location. Rejects traversal and symlink escapes, never overwrites, and verifies cleanup. Integrity mismatches fail by default; record-and-continue extracts the observed bytes and returns each mismatch as an explicitly untrusted integrity contradiction.", artifactExtractionInputSchema),
+    artifact("decode_interface_builder", "Decode compiled storyboard and nib archives inside the active Apple app bundle, including keyed property lists and NIBArchive object tables, into a bounded object, hierarchy, and connection graph. This is static archive parsing; unrecognized archive classes and unresolved code handlers remain explicit unknowns.", z.strictObject({
+        max_documents: z.number().int().min(1).max(64).default(64),
+        max_objects: z.number().int().min(1).max(20_000).default(20_000),
+        max_connections: z.number().int().min(1).max(40_000).default(40_000),
+    })),
+    artifact("inspect_keyed_archive", "Inspect one Foundation NSKeyedArchiver plist in the active app bundle as original object-table nodes, class descriptors, named roots, and UID edges. Preserves shared and cyclic references without instantiating classes. The path is relative to the bundle; root selection and object pagination preserve original identities.", keyedArchiveInputSchema),
+    artifact("inspect_asset_catalog", "Inspect compiled Assets.car metadata in an active Apple app bundle. Returns stable paginated catalog and rendition records with raw assetutil metadata and catalog digests; rendition bytes are not extracted.", appleAssetCatalogInputSchema),
+    artifact("trace_dylib_resolution", "Trace how dyld would resolve each Mach-O dylib load for the active Mach-O, or for every executable in the active .app bundle (the main app, XPC services, extensions, login items, helpers). Expands @executable_path, @loader_path, and @rpath through each process's LC_RPATH stack in dependents-first load order, and reports every candidate path with its outcome, the resolved image and digest, weak, re-export, and upward flags, and derived findings such as unresolved required loads or absent earlier @rpath candidates. Pure header parsing: nothing is executed, and absolute or system paths outside the analyzed root stay undetermined. Select roots or one architecture to narrow large bundles.", dylibResolutionInputSchema),
+];
+/** Provider operations; inventory remains an internal primitive of inspection. */
+export const ARTIFACT_ANALYSIS_OPERATIONS = [
+    "inventory_artifact",
+    ...ARTIFACT_TOOL_CONTRACTS.map(({ name }) => name),
+];

package/dist/contracts/browserProviderToolContracts.js

@@ -0,0 +1,7 @@
+import { BROWSER_SCENARIO_TOOL_CONTRACTS } from "./browserScenarioToolContracts.js";
+import { BROWSER_TOOL_CONTRACTS } from "./browserToolContracts.js";
+/** Complete ordered browser-provider contract inventory. */
+export const BROWSER_PROVIDER_TOOL_CONTRACTS = [
+    ...BROWSER_TOOL_CONTRACTS,
+    ...BROWSER_SCENARIO_TOOL_CONTRACTS,
+];

package/dist/contracts/browserScenarioToolContracts.js

@@ -0,0 +1,32 @@
+import { toolContractMetadata } from "./toolEffects.js";
+import { evidenceResultOf } from "./toolOutputSchemaPrimitives.js";
+import { browserScenarioInputSchema } from "../domain/browserScenario.js";
+import { browserScenarioCaptureSchema } from "../domain/browserScenarioCapture.js";
+const example = {
+    browser: {
+        mode: "launch",
+        executable_path: "/opt/chromium/chrome",
+    },
+    start_url: { url: "https://app.example.test/", query: [] },
+    actions: [
+        {
+            step_id: "settle",
+            action: "wait_for_timeout",
+            duration_ms: 250,
+        },
+    ],
+};
+/** Controlled browser scenario contract shared by MCP and catalog generation. */
+export const BROWSER_SCENARIO_TOOL_CONTRACTS = [
+    {
+        name: "capture_browser_scenario",
+        ...toolContractMetadata("capture_browser_scenario"),
+        description: "Run a controlled browser scenario when passive observation cannot exercise the application. Launch the selected executable or connect to a loopback CDP target, provide a start URL and actions, and select storage or artifacts when needed. Environment, empty storage, and a URL-only final capture are defaults. capture.network selects request_body, response_body, and header_values independently; selected content is returned inline with transaction and event references, byte digests, and explicit unavailable states. Credentials and declared secrets are redacted. Agents can run their own local fixture servers to control application responses. Actions run until completion or cancellation unless timeout_ms is set. Results are returned inline.",
+        kind: "browser-provider",
+        inputSchema: browserScenarioInputSchema,
+        outputSchema: evidenceResultOf(browserScenarioCaptureSchema),
+        examples: [
+            { title: "Capture a deterministic browser scenario", input: example },
+        ],
+    },
+];

package/dist/contracts/browserToolContracts.js

@@ -0,0 +1,256 @@
+import { inspectWebPageInputSchema, listBrowserTargetsInputSchema, } from "../domain/browserObservation.js";
+import { browserTargetListSchema, webPageInspectionSchema, } from "../domain/browserObservationSchemas.js";
+import { analyzeWebBundleInputSchema, webBundleAnalysisSchema, } from "../domain/webBundleAnalysis.js";
+import { observeWebSessionInputSchema, webObservationSessionSchema, } from "../domain/browserSession.js";
+import { discoverWebMcpToolsInputSchema, webMcpDiscoverySchema, } from "../domain/webMcpDiscovery.js";
+import { browserCaptureComparisonInputSchema, browserCaptureComparisonSchema, } from "../domain/browserCaptureComparison.js";
+import { captureWebScreenshotInputSchema, compareWebScreenshotsInputSchema, webScreenshotDiffSchema, webScreenshotSchema, } from "../domain/webScreenshot.js";
+import { toolContractMetadata } from "./toolEffects.js";
+import { evidenceResultOf } from "./toolOutputSchemaPrimitives.js";
+const listOutputSchema = evidenceResultOf(browserTargetListSchema);
+const inspectionOutputSchema = evidenceResultOf(webPageInspectionSchema);
+const bundleOutputSchema = evidenceResultOf(webBundleAnalysisSchema);
+const observationSessionOutputSchema = evidenceResultOf(webObservationSessionSchema);
+const webMcpOutputSchema = evidenceResultOf(webMcpDiscoverySchema);
+const captureDiffOutputSchema = evidenceResultOf(browserCaptureComparisonSchema);
+const screenshotOutputSchema = evidenceResultOf(webScreenshotSchema);
+const screenshotDiffOutputSchema = evidenceResultOf(webScreenshotDiffSchema);
+const endpoint = "http://127.0.0.1:9222";
+const origin = "https://app.example.test";
+const scenarioUrl = {
+    url: `${origin}/`,
+    origin,
+    query_parameter_names: [],
+    redacted: false,
+};
+const scenarioCompleteness = {
+    status: "complete",
+    equality_eligible: true,
+    missing_sections: [],
+    truncated_sections: [],
+};
+const scenarioArtifacts = {
+    screenshot: { state: "not_requested" },
+    dom: { state: "not_requested" },
+    accessibility: { state: "not_requested" },
+    url: { state: "not_requested" },
+    history: { state: "not_requested" },
+    storage: { state: "not_requested" },
+};
+const exampleScenarioCapture = () => ({
+    browser: {
+        mode: "connect",
+        process_ownership: "external",
+        cleanup: "disconnected-external",
+        product: "Chromium",
+        version: "149",
+    },
+    scenario: {
+        start_origin: origin,
+        action_count: 1,
+        secret_references: [],
+        network_content: {
+            request_body: false,
+            response_body: false,
+            header_values: false,
+        },
+    },
+    duration_ms: 10,
+    steps: [
+        {
+            step_index: 0,
+            step_id: "scenario_start",
+            action: "scenario_start",
+            status: "completed",
+            elapsed_ms: 0,
+            before_url: scenarioUrl,
+            after_url: scenarioUrl,
+            error: null,
+            event_sequence_start: 1,
+            event_sequence_end: 0,
+            artifacts: scenarioArtifacts,
+            completeness: scenarioCompleteness,
+        },
+        {
+            step_index: 1,
+            step_id: "open-settings",
+            action: "click",
+            status: "completed",
+            elapsed_ms: 10,
+            before_url: scenarioUrl,
+            after_url: scenarioUrl,
+            error: null,
+            event_sequence_start: 1,
+            event_sequence_end: 0,
+            artifacts: scenarioArtifacts,
+            completeness: scenarioCompleteness,
+        },
+    ],
+    events: { retained: 0, dropped: 0, items: [] },
+    completeness: scenarioCompleteness,
+    limitations: [],
+});
+/** Passive browser reverse-engineering contracts. */
+export const BROWSER_TOOL_CONTRACTS = [
+    {
+        name: "list_browser_targets",
+        ...toolContractMetadata("list_browser_targets"),
+        description: "List page targets exposed by the selected loopback Chrome DevTools Protocol endpoint. Optionally filter by exact origin. URLs preserve query values and fragments; only URL userinfo credentials are removed.",
+        kind: "browser-provider",
+        inputSchema: listBrowserTargetsInputSchema,
+        outputSchema: listOutputSchema,
+        examples: [
+            {
+                title: "List browser page targets",
+                input: {
+                    cdp_endpoint: endpoint,
+                },
+            },
+        ],
+    },
+    {
+        name: "inspect_web_page",
+        ...toolContractMetadata("inspect_web_page"),
+        description: "Passively inspect one selected page target through CDP without evaluating JavaScript, navigating, clicking, closing, or mutating the page. If no origin filter is supplied, capture is scoped to the target's current origin. Returns DOM structure, accessibility, scripts, resources, attach-window network and console metadata, workers, and redacted storage inventory as Evidence.",
+        kind: "browser-provider",
+        inputSchema: inspectWebPageInputSchema,
+        outputSchema: inspectionOutputSchema,
+        examples: [
+            {
+                title: "Inspect one browser page",
+                input: {
+                    cdp_endpoint: endpoint,
+                    target_id: "TARGET_ID_FROM_LIST_BROWSER_TARGETS",
+                },
+            },
+        ],
+    },
+    {
+        name: "analyze_web_bundle",
+        ...toolContractMetadata("analyze_web_bundle"),
+        description: "Capture JavaScript source from one selected CDP page and statically derive a chunk graph, route and endpoint candidates, vendor fingerprints, page-declared WebMCP metadata, and optionally fetch source maps from the selected target origin or explicitly requested origins. JavaScript is parsed but never executed.",
+        kind: "browser-provider",
+        inputSchema: analyzeWebBundleInputSchema,
+        outputSchema: bundleOutputSchema,
+        examples: [
+            {
+                title: "Analyze a page bundle",
+                input: {
+                    cdp_endpoint: endpoint,
+                    target_id: "TARGET_ID_FROM_LIST_BROWSER_TARGETS",
+                    observation_ms: 500,
+                    include_accessibility_text: false,
+                    include_script_sources: true,
+                    include_storage_keys: false,
+                    fetch_source_maps: false,
+                },
+            },
+        ],
+    },
+    {
+        name: "observe_web_session",
+        ...toolContractMetadata("observe_web_session"),
+        description: "Arm a CDP observation window of the requested duration while the user operates the page. By default it follows the selected target's current origin; an explicit origin list controls which origins may be retained. Records navigation, redirect, lifecycle, and failure events.",
+        kind: "browser-provider",
+        inputSchema: observeWebSessionInputSchema,
+        outputSchema: observationSessionOutputSchema,
+        examples: [
+            {
+                title: "Observe one external user action",
+                input: {
+                    cdp_endpoint: endpoint,
+                    target_id: "TARGET_ID_FROM_LIST_BROWSER_TARGETS",
+                    observation_ms: 10_000,
+                },
+            },
+        ],
+    },
+    {
+        name: "discover_webmcp_tools",
+        ...toolContractMetadata("discover_webmcp_tools"),
+        description: "Passively inventory every page-registered WebMCP tool and its complete structural input-schema summary using the experimental CDP WebMCP domain. Metadata is page-declared-untrusted; REA never registers or invokes discovered tools.",
+        kind: "browser-provider",
+        inputSchema: discoverWebMcpToolsInputSchema,
+        outputSchema: webMcpOutputSchema,
+        examples: [
+            {
+                title: "Discover current WebMCP declarations",
+                input: {
+                    cdp_endpoint: endpoint,
+                    target_id: "TARGET_ID_FROM_LIST_BROWSER_TARGETS",
+                    observation_ms: 100,
+                },
+            },
+        ],
+    },
+    {
+        name: "compare_web_captures",
+        ...toolContractMetadata("compare_web_captures"),
+        description: "Compare passive web captures by providing before and after, each with the complete inspect_web_page normalized_result in inspection and an optional complete discover_webmcp_tools normalized_result in webmcp; or compare recorded scenarios by passing complete capture_browser_scenario normalized_result objects in before_scenario and after_scenario with an optional normalization policy. Use exactly one input group. Network comparison includes observed HTTP requests and WebSocket frame streams; same-URL connections are compared as an unordered collection of ordered streams, retaining connection counts without claiming stable identity between individual connections. Scenario comparison aligns exact step IDs, records deterministic literal normalization, and returns every artifact-level difference plus alignment failures inline. Missing or truncated evidence never proves equality.",
+        kind: "browser-provider",
+        inputSchema: browserCaptureComparisonInputSchema,
+        outputSchema: captureDiffOutputSchema,
+        examples: [
+            {
+                title: "Compare two recorded browser scenarios",
+                input: {
+                    before_scenario: exampleScenarioCapture(),
+                    after_scenario: exampleScenarioCapture(),
+                    normalization: {
+                        rules: [
+                            {
+                                rule_id: "volatile-build-id",
+                                artifacts: ["dom", "accessibility"],
+                                match: "build-123",
+                                replacement: "[BUILD_ID]",
+                            },
+                        ],
+                    },
+                },
+            },
+        ],
+    },
+    {
+        name: "capture_web_screenshot",
+        ...toolContractMetadata("capture_web_screenshot"),
+        description: "Capture the current visible viewport of one configured page as an inline, content-addressed PNG artifact. The operation never scrolls, navigates, or evaluates page JavaScript.",
+        kind: "browser-provider",
+        inputSchema: captureWebScreenshotInputSchema,
+        outputSchema: screenshotOutputSchema,
+        examples: [
+            {
+                title: "Capture a viewport",
+                input: {
+                    cdp_endpoint: endpoint,
+                    target_id: "TARGET_ID_FROM_LIST_BROWSER_TARGETS",
+                },
+            },
+        ],
+    },
+    {
+        name: "compare_web_screenshots",
+        ...toolContractMetadata("compare_web_screenshots"),
+        description: "Compare two self-verifying PNG screenshot artifacts with local pixel metrics. Returns exact changed-pixel ratios and channel deltas without OCR or external services.",
+        kind: "browser-provider",
+        inputSchema: compareWebScreenshotsInputSchema,
+        outputSchema: screenshotDiffOutputSchema,
+        examples: [
+            {
+                title: "Compare two screenshot artifacts",
+                input: {
+                    before: exampleScreenshot(),
+                    after: exampleScreenshot(),
+                    channel_threshold: 0,
+                },
+            },
+        ],
+    },
+];
+function exampleScreenshot() {
+    return {
+        sha256: "153cf6c9a526a63053a37b10234c2fd85df38887c2dc0a800d90abfa6631d01c",
+        bytes: 70,
+        media_type: "image/png",
+        data_base64: "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PzWvWQAAAABJRU5ErkJggg==",
+    };
+}

package/dist/contracts/compactInputSchema.js

@@ -0,0 +1,256 @@
+import { schemaArrays, schemaChildren, schemaMaps, } from "./inputSchemaPresentation.js";
+// Kimi expands schema-local references before sending tools to Moonshot.
+// Compact advertisements must fit after expansion, independently of client
+// reference handling. Canonical server-side validation remains unchanged.
+/** Annotation keys that carry guidance but no validation semantics. */
+const annotationKeys = new Set(["description", "examples", "default", "title"]);
+/** Keys whose values are literal data, never nested schemas to rewrite. */
+const dataKeys = new Set(["const", "enum", "examples", "default"]);
+const definitionKeys = new Set(["$defs", "definitions"]);
+// An empty schema accepts every JSON value. Kimi otherwise infers string.
+const jsonValueTypes = [
+    "null",
+    "boolean",
+    "object",
+    "array",
+    "number",
+    "string",
+];
+const isSchemaObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const serializedBytes = (value) => Buffer.byteLength(JSON.stringify(value), "utf8");
+/** Rewrite every schema-valued position; literal data stays opaque. */
+const rebuildSchemaPositions = (node, rebuild) => {
+    if (Array.isArray(node))
+        return node.map((child) => rebuild(child));
+    if (!isSchemaObject(node))
+        return node;
+    const out = {};
+    for (const [key, value] of Object.entries(node)) {
+        if (dataKeys.has(key)) {
+            out[key] = value;
+            continue;
+        }
+        if (schemaMaps.has(key) && isSchemaObject(value)) {
+            out[key] = Object.fromEntries(Object.entries(value).map(([name, child]) => [name, rebuild(child)]));
+            continue;
+        }
+        if (schemaArrays.has(key) && Array.isArray(value)) {
+            out[key] = value.map((child) => rebuild(child));
+            continue;
+        }
+        if (schemaChildren.has(key)) {
+            out[key] = Array.isArray(value)
+                ? value.map((child) => rebuild(child))
+                : rebuild(value);
+            continue;
+        }
+        out[key] = value;
+    }
+    return out;
+};
+/**
+ * Drop annotation prose from every subschema while preserving all validation
+ * keywords. The root keeps its own description because the root-union
+ * projection encodes accepted input groups there; the root's echoed literal
+ * examples leave with the rest of the annotation prose.
+ */
+const stripAnnotations = (schema) => {
+    const rebuilt = rebuildSchemaPositions(schema, stripChildAnnotations);
+    const out = {};
+    for (const [key, value] of Object.entries(rebuilt)) {
+        if (annotationKeys.has(key) && key !== "description")
+            continue;
+        out[key] = value;
+    }
+    return out;
+};
+const stripChildAnnotations = (child) => {
+    const rebuilt = rebuildSchemaPositions(child, stripChildAnnotations);
+    if (!isSchemaObject(rebuilt))
+        return rebuilt;
+    const kept = {};
+    for (const [key, value] of Object.entries(rebuilt))
+        if (!annotationKeys.has(key))
+            kept[key] = value;
+    return kept;
+};
+const resolveLocalReference = (root, reference) => {
+    if (reference === "#")
+        return root;
+    if (!reference.startsWith("#/"))
+        return undefined;
+    let value = root;
+    for (const token of reference.slice(2).split("/")) {
+        const key = token.replaceAll("~1", "/").replaceAll("~0", "~");
+        if (!isSchemaObject(value) || !Object.hasOwn(value, key))
+            return undefined;
+        value = value[key];
+    }
+    return value;
+};
+/** Stop serialization at the budget before allocating an expanded schema. */
+const inlineWithinBudget = (root, budgetBytes) => {
+    let resolved = true;
+    function* serialize(value, position, active) {
+        if (Array.isArray(value)) {
+            yield "[";
+            for (const [index, child] of value.entries()) {
+                if (index > 0)
+                    yield ",";
+                yield* serialize(child, position, active);
+            }
+            yield "]";
+        }
+        else if (isSchemaObject(value)) {
+            if (position === "schema" && Object.keys(value).length === 0) {
+                yield JSON.stringify({ type: jsonValueTypes });
+                return;
+            }
+            if (position === "schema" && typeof value.$ref === "string") {
+                const target = resolveLocalReference(root, value.$ref);
+                if (target === undefined || active.has(value.$ref)) {
+                    resolved = false;
+                    return;
+                }
+                const { $ref, ...siblings } = value;
+                // Reference siblings are independent constraints in draft 2020-12.
+                // Merging their keys into the target would overwrite validation rules.
+                yield* serialize(Object.keys(siblings).length === 0
+                    ? target
+                    : { allOf: [target, siblings] }, "schema", new Set([...active, $ref]));
+                return;
+            }
+            yield "{";
+            let first = true;
+            for (const [key, child] of Object.entries(value)) {
+                if (position === "schema" && definitionKeys.has(key))
+                    continue;
+                if (!first)
+                    yield ",";
+                first = false;
+                yield JSON.stringify(key) + ":";
+                const childPosition = position === "map"
+                    ? "schema"
+                    : position === "schema" && schemaMaps.has(key)
+                        ? "map"
+                        : position === "schema" &&
+                            (schemaArrays.has(key) || schemaChildren.has(key))
+                            ? "schema"
+                            : "data";
+                yield* serialize(child, childPosition, active);
+            }
+            yield "}";
+        }
+        else {
+            yield JSON.stringify(value);
+        }
+    }
+    const chunks = [];
+    let bytes = 0;
+    for (const chunk of serialize(root, "schema", new Set())) {
+        bytes += Buffer.byteLength(chunk, "utf8");
+        if (bytes > budgetBytes || !resolved)
+            return undefined;
+        chunks.push(chunk);
+    }
+    return resolved
+        ? JSON.parse(chunks.join(""))
+        : undefined;
+};
+/** Preserve every possible type, including referenced and nullable unions. */
+const detectedTypes = (schema, root, active = new Set()) => {
+    if (!isSchemaObject(schema))
+        return undefined;
+    if (typeof schema.$ref === "string") {
+        if (active.has(schema.$ref))
+            return undefined;
+        return detectedTypes(resolveLocalReference(root, schema.$ref), root, new Set([...active, schema.$ref]));
+    }
+    if (typeof schema.type === "string")
+        return [schema.type];
+    if (Array.isArray(schema.type) &&
+        schema.type.every((type) => typeof type === "string"))
+        return schema.type;
+    const alternatives = Array.isArray(schema.anyOf)
+        ? schema.anyOf
+        : Array.isArray(schema.oneOf)
+            ? schema.oneOf
+            : [];
+    if (alternatives.length === 0)
+        return undefined;
+    const types = alternatives.map((branch) => detectedTypes(branch, root, active));
+    if (types.some((type) => type === undefined))
+        return undefined;
+    return [...new Set(types.flatMap((type) => type ?? []))];
+};
+const REDUCED_ANNOTATION = "Advertised in reduced form by the compact input schema profile; the server still validates complete canonical inputs.";
+/**
+ * Present only the root property shape with per-property guidance. Used for
+ * schemas whose validation structure alone exceeds the compact budget; the
+ * canonical schema still rejects malformed calls server-side.
+ */
+const reduceToShallowProperties = (schema) => {
+    const properties = isSchemaObject(schema.properties) ? schema.properties : {};
+    const description = [
+        typeof schema.description === "string" ? schema.description : undefined,
+        REDUCED_ANNOTATION,
+    ]
+        .filter((text) => text !== undefined)
+        .join(" ");
+    const $schema = typeof schema.$schema === "string" ? { $schema: schema.$schema } : {};
+    const shallow = Object.fromEntries(Object.entries(properties).map(([name, value]) => {
+        const types = detectedTypes(value, schema);
+        const type = types?.length === 1 ? types[0] : types;
+        const description = isSchemaObject(value) && typeof value.description === "string"
+            ? { description: value.description }
+            : {};
+        return [
+            name,
+            { ...(type === undefined ? {} : { type }), ...description },
+        ];
+    }));
+    return {
+        ...$schema,
+        type: "object",
+        description,
+        properties: shallow,
+        ...(Array.isArray(schema.required)
+            ? { required: [...schema.required] }
+            : {}),
+        ...(typeof schema.minProperties === "number"
+            ? { minProperties: schema.minProperties }
+            : {}),
+        ...(isSchemaObject(schema.dependentRequired)
+            ? { dependentRequired: { ...schema.dependentRequired } }
+            : {}),
+        ...(schema.additionalProperties === false
+            ? { additionalProperties: false }
+            : {}),
+    };
+};
+/**
+ * Render an advertised input schema within a per-schema byte budget for
+ * providers that validate the literal serialized schema size. Validation
+ * keywords and the canonical contract are preserved; only
+ * annotation prose and, for structurally oversized schemas, nested
+ * validation detail leave the advertised form.
+ */
+export const compactAdvertisedInputSchema = (schema, budgetBytes) => {
+    const inline = inlineWithinBudget(stripAnnotations(schema), budgetBytes);
+    if (inline !== undefined)
+        return { schema: inline, presentation: "inline" };
+    const reduced = reduceToShallowProperties(schema);
+    if (serializedBytes(reduced) <= budgetBytes)
+        return { schema: reduced, presentation: "reduced" };
+    // A future contract with an extreme root-property count still advertises
+    // an honest, budget-fitting shape instead of an oversized one.
+    return {
+        schema: reduceToShallowProperties({
+            type: "object",
+            description: (typeof schema.description === "string"
+                ? `${schema.description} `
+                : "") + REDUCED_ANNOTATION,
+        }),
+        presentation: "reduced",
+    };
+};