rea-agents 6.0.0 → 6.2.0

package/dist/contracts/toolOutputSchemaGroups.js

@@ -9,8 +9,8 @@ import { nativeInstructionSchema, nativeCallTargetsSchema, } from "../domain/nat
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { residualUnknownSchema } from "../domain/residualUnknown.js";
 import { evidenceBundleSchema } from "../domain/evidenceBundle.js";
-import { processCaptureComparisonSchema, processCaptureSchema, } from "../domain/process/processCapture.js";
-import { functionInstructionWindowSchema, referenceKindSchema, } from "../domain/hopperValues.js";
+import { processCaptureComparisonSchema } from "../domain/process/processComparison.js";
+import { analysisBookmarkSchema, functionInstructionWindowSchema, referenceEdgeSchema, unresolvedCallSchema, analysisStringSchema, procedureIdentitySchema, } from "../domain/hopperValues.js";
 import { nativeApiInspectionResultSchema } from "../domain/native/nativeApiBoundary.js";
 import { demangleSwiftSchema, inspectMachoSchema, inspectPlistSchema, inspectSignatureSchema, listArchitecturesSchema, } from "../domain/native/nativeInspection.js";
 import { artifactExtractionResultSchema } from "../domain/artifactGraph.js";
@@ -21,20 +21,21 @@ import { keyedArchiveResultSchema } from "../domain/apple/keyedArchive.js";
 import { appleAssetCatalogResultSchema } from "../domain/apple/appleAssetCatalog.js";
 import { managedArtifactInspectionSchema, managedMemberInspectionSchema, managedNativeBoundaryInspectionSchema, } from "../domain/managed/managedArtifact.js";
 import { managedMemberComparisonResultSchema } from "../domain/managed/managedMemberComparison.js";
-import { managedNativeVerificationResultSchema } from "../domain/managed/managedNativeVerification.js";
+import { managedNativeVerificationResultSchema } from "../domain/managed/managedNativeVerificationSchemas.js";
 import { managedReconstructionImportResultSchema } from "../domain/managed/managedReconstruction.js";
 import { managedApplicationGraphResultSchema } from "../domain/managed/managedApplicationGraph.js";
 import { artifactComparisonResultSchema } from "../domain/artifactComparison.js";
-import { functionComparisonResultSchema } from "../domain/functionComparison.js";
+import { functionComparisonResultSchema } from "../domain/functionComparisonSchemas.js";
 import { bundleComparisonResultSchema } from "../domain/bundleComparison.js";
 import { changedBehaviorResultSchema } from "../domain/changedBehavior.js";
-import { callPathResultSchema } from "../domain/callPath.js";
+import { callPathResultSchema } from "../domain/callPathSchemas.js";
 import { staticRuntimeCorrelationResultSchema } from "../domain/staticRuntimeCorrelation.js";
-import { reconstructionVerificationResultSchema } from "../domain/reconstructionVerification.js";
+import { reconstructionVerificationResultSchema } from "../domain/reconstructionVerificationSchemas.js";
 import { analysisErrorProjectionSchema } from "./errorSchemas.js";
 import { nativeDispatchMetadataResultSchema } from "../domain/native/objcSwiftMetadata.js";
 import { nativeInvestigationTraceSchema } from "../domain/native/nativeInvestigationGraph.js";
-import { addressList, addressedValue, addressedEntry, containingProcedureResolution, functionDossierOutput, graphNode, lifecycleResultOf, nullableText, procedureIdentity, procedureInfoOutput, evidenceResultOf as resultOf, segmentOutput, sessionProvider, symbolDiscoveryOutput, targetFormatSchema, targetKindSchema, } from "./toolOutputSchemaPrimitives.js";
+import { addressList, addressedValue, addressedEntry, containingProcedureResolution, functionDossierOutput, graphNode, lifecycleResultOf, nullableText, procedureInfoOutput, evidenceResultOf, segmentOutput, sessionProvider, symbolDiscoveryOutput, targetFormatSchema, targetKindSchema, } from "./toolOutputSchemaPrimitives.js";
+import { processCaptureSchema } from "../domain/process/processCapture.js";
 const contextFacetSchema = z.discriminatedUnion("state", [
     z.object({ state: z.literal("available"), value: jsonValueSchema }),
     z.object({
@@ -44,92 +45,93 @@ const contextFacetSchema = z.discriminatedUnion("state", [
     }),
 ]);
 const bookmarkFacetSchema = z.discriminatedUnion("state", [
-    z.object({ state: z.literal("available"), value: z.array(addressedEntry) }),
+    z.object({
+        state: z.literal("available"),
+        value: z.array(analysisBookmarkSchema),
+    }),
     z.object({
         state: z.literal("unavailable"),
         reason: z.string(),
         remediation: z.string(),
     }),
 ]);
-const addressedString = z.object({
-    address: z.string(),
-    value: z.string(),
-    string: z
-        .object({
-        encoding: z.string().min(1),
-        termination: z.enum(["missing", "present_or_not_required"]),
-        byte_length: z.number().int().min(0),
-    })
-        .optional(),
-});
 /** Exact structured-content schemas shared by direct analysis providers. */
 export const officialOutputSchemas = {
-    annotate_native_function: resultOf(nativeFunctionAnnotationsSchema),
-    inspect_native_load_image: resultOf(nativeLoadImageSchema),
-    inspect_native_data_type: resultOf(nativeDataTypeSchema),
-    inspect_native_instruction: resultOf(nativeInstructionSchema),
-    resolve_native_call_targets: resultOf(nativeCallTargetsSchema),
-    address_name: resultOf(nullableText),
-    comment: resultOf(nullableText),
-    current_address: resultOf(z.string()),
-    current_procedure: resultOf(z.string()),
-    current_document: resultOf(z.string()),
-    goto_address: resultOf(z.string()),
-    inline_comment: resultOf(nullableText),
-    list_bookmarks: resultOf(z.array(addressedEntry)),
-    list_documents: resultOf(z.array(z.string())),
-    list_names: resultOf(z.array(addressedValue)),
-    list_procedures: resultOf(z.array(addressedValue)),
+    annotate_native_function: evidenceResultOf(nativeFunctionAnnotationsSchema),
+    inspect_native_load_image: evidenceResultOf(nativeLoadImageSchema),
+    inspect_native_data_type: evidenceResultOf(nativeDataTypeSchema),
+    inspect_native_instruction: evidenceResultOf(nativeInstructionSchema),
+    resolve_native_call_targets: evidenceResultOf(nativeCallTargetsSchema),
+    address_name: evidenceResultOf(nullableText),
+    comment: evidenceResultOf(nullableText),
+    current_address: evidenceResultOf(z.string()),
+    current_procedure: evidenceResultOf(z.string()),
+    current_document: evidenceResultOf(z.string()),
+    goto_address: evidenceResultOf(z.string()),
+    inline_comment: evidenceResultOf(nullableText),
+    list_bookmarks: evidenceResultOf(z.array(analysisBookmarkSchema)),
+    list_documents: evidenceResultOf(z.array(z.string())),
+    list_names: evidenceResultOf(z.array(addressedValue)),
+    list_procedures: evidenceResultOf(z.array(addressedValue)),
     list_segments: segmentOutput,
-    list_strings: resultOf(z.array(addressedString)),
-    next_address: resultOf(z.string()),
-    prev_address: resultOf(z.string()),
-    procedure_address: resultOf(z.string()),
-    procedure_assembly: resultOf(z.string()),
-    procedure_callees: resultOf(addressList),
-    procedure_callers: resultOf(addressList),
+    list_strings: evidenceResultOf(z.array(analysisStringSchema)),
+    next_address: evidenceResultOf(z.string()),
+    prev_address: evidenceResultOf(z.string()),
+    procedure_address: evidenceResultOf(z.string()),
+    procedure_assembly: evidenceResultOf(z.string()),
+    procedure_callees: evidenceResultOf(addressList),
+    procedure_callers: evidenceResultOf(addressList),
     procedure_info: procedureInfoOutput,
-    read_function_instructions: resultOf(functionInstructionWindowSchema),
-    read_bytes: resultOf(z.object({
+    read_function_instructions: evidenceResultOf(functionInstructionWindowSchema),
+    read_bytes: evidenceResultOf(z.object({
         address: z.string(),
         requested_bytes: z.number().int().min(1),
         returned_bytes: z.number().int().min(0),
         bytes_hex: z.string().regex(/^(?:[a-f0-9]{2})*$/u),
         complete: z.boolean(),
     })),
-    address_to_file_offset: resultOf(z.object({
+    address_to_file_offset: evidenceResultOf(z.object({
         address: z.string(),
         file_offset: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+        provider_file_offset: z
+            .number()
+            .int()
+            .min(0)
+            .max(Number.MAX_SAFE_INTEGER)
+            .exactOptional()
+            .describe("Original coordinate returned by the provider's mapping API."),
+        image_base_file_offset: z
+            .number()
+            .int()
+            .min(0)
+            .max(Number.MAX_SAFE_INTEGER)
+            .exactOptional()
+            .describe("File offset of the loaded image within its source container; zero for a thin executable."),
+        source_path: z
+            .string()
+            .exactOptional()
+            .describe("Observed original executable path used to verify the file mapping."),
     })),
-    procedure_references: resultOf(z.object({
-        procedure: procedureIdentity,
+    procedure_references: evidenceResultOf(z.object({
+        procedure: procedureIdentitySchema,
         direction: z.enum(["incoming", "outgoing"]),
         reference_kinds_available: z.boolean().optional(),
-        unresolved_calls: z
-            .array(z.object({ address: z.string(), reason: z.string() }))
-            .default([]),
-        references: z.array(z.object({
-            source_address: z.string(),
-            target_address: z.string(),
-            source_procedure: procedureIdentity.nullable(),
-            target_procedure: procedureIdentity.nullable(),
-            kind: referenceKindSchema,
-        })),
+        unresolved_calls: z.array(unresolvedCallSchema).default([]),
+        references: z.array(referenceEdgeSchema),
     })),
-    procedure_pseudo_code: resultOf(nullableText),
-    resolve_containing_procedure: resultOf(containingProcedureResolution),
-    search_procedures: resultOf(z.array(z.object({ address: z.string(), value: z.string() }))),
-    search_strings: resultOf(z.array(z.object({ address: z.string(), value: z.string() }))),
-    set_address_name: resultOf(z.boolean()),
-    set_addresses_names: resultOf(z.record(z.string(), z.boolean())),
-    set_bookmark: resultOf(z.boolean()),
-    set_comment: resultOf(z.boolean()),
-    set_current_document: resultOf(z.string()),
-    set_inline_comment: resultOf(z.boolean()),
-    unset_bookmark: resultOf(z.boolean()),
-    xrefs: resultOf(addressList),
+    procedure_pseudo_code: evidenceResultOf(nullableText),
+    resolve_containing_procedure: evidenceResultOf(containingProcedureResolution),
+    search_procedures: evidenceResultOf(z.array(z.object({ address: z.string(), value: z.string() }))),
+    search_strings: evidenceResultOf(z.array(analysisStringSchema)),
+    set_address_name: evidenceResultOf(z.boolean()),
+    set_addresses_names: evidenceResultOf(z.record(z.string(), z.boolean())),
+    set_bookmark: evidenceResultOf(z.boolean()),
+    set_comment: evidenceResultOf(z.boolean()),
+    set_inline_comment: evidenceResultOf(z.boolean()),
+    unset_bookmark: evidenceResultOf(z.boolean()),
+    xrefs: evidenceResultOf(addressList),
 };
-const literalTraceOutput = resultOf(z.object({
+const literalTraceOutput = evidenceResultOf(z.object({
     query: z.string(),
     search_mode: z.literal("literal"),
     matches: z.array(z.object({
@@ -145,7 +147,7 @@ const literalTraceOutput = resultOf(z.object({
     truncated: z.boolean(),
     residual_unknowns: z.array(z.string()),
 }));
-const callPathTraceOutput = resultOf(z.object({
+const callPathTraceOutput = evidenceResultOf(z.object({
     start: z.string(),
     goal: z.string().nullable(),
     direction: z.enum(["forward", "backward"]),
@@ -171,22 +173,44 @@ const callPathTraceOutput = resultOf(z.object({
     residual_unknowns: z.array(z.string()),
     limitations: z.array(z.string()),
 }));
+/** Identity facts attached to one requested batch selector. */
+const batchProcedureIdentity = z.discriminatedUnion("status", [
+    z.object({
+        status: z.literal("resolved"),
+        address: z.string().min(1).describe("Observed canonical procedure entry."),
+        name: z
+            .string()
+            .nullable()
+            .describe("Provider's entry label, or null when unavailable."),
+        name_error: analysisErrorProjectionSchema.optional(),
+    }),
+    z.object({
+        status: z.literal("unknown"),
+        error: analysisErrorProjectionSchema,
+    }),
+]);
 /** Exact structured-content schemas for composed analysis workflows. */
 export const enhancedOutputSchemas = {
-    inspect_native_dispatch_metadata: resultOf(nativeDispatchMetadataResultSchema),
-    trace_native_values: resultOf(nativeValueTraceSchema),
-    trace_native_ui_action: resultOf(nativeInvestigationTraceSchema),
+    inspect_native_dispatch_metadata: evidenceResultOf(nativeDispatchMetadataResultSchema),
+    trace_native_values: evidenceResultOf(nativeValueTraceSchema),
+    trace_native_ui_action: evidenceResultOf(nativeInvestigationTraceSchema),
     get_objc_classes: symbolDiscoveryOutput("classes"),
     get_objc_protocols: symbolDiscoveryOutput("protocols"),
-    batch_decompile: resultOf(z.object({
+    batch_decompile: evidenceResultOf(z.object({
         items: z.array(z.discriminatedUnion("status", [
             z.object({
-                address: z.string(),
+                address: z
+                    .string()
+                    .describe("Original caller-selected symbol or address."),
+                procedure: batchProcedureIdentity,
                 status: z.literal("ok"),
                 pseudocode: z.string().min(1),
             }),
             z.object({
-                address: z.string(),
+                address: z
+                    .string()
+                    .describe("Original caller-selected symbol or address."),
+                procedure: batchProcedureIdentity,
                 status: z.literal("error"),
                 error: analysisErrorProjectionSchema,
             }),
@@ -195,15 +219,23 @@ export const enhancedOutputSchemas = {
         succeeded: z.number().int().min(0),
         failed: z.number().int().min(0),
     })),
-    get_call_graph: resultOf(z.record(z.string(), z.array(graphNode))),
-    analyze_swift_types: resultOf(z.object({
+    get_call_graph: evidenceResultOf(z.record(z.string(), z.array(graphNode))),
+    analyze_swift_types: evidenceResultOf(z.object({
         total: z.number().int().min(0),
         categories: z.record(z.string(), z.object({
             count: z.number().int().min(0),
-            items: z.array(addressedEntry),
+            items: z.array(addressedEntry.extend({
+                mangled_names: z.array(z.string()),
+            })),
+        })),
+        unclassified: z.array(addressedEntry.extend({
+            mangled_names: z.array(z.string()),
+            reason: z.enum(["category_not_decoded", "conflicting_categories"]),
         })),
+        limitations: z.array(z.string()),
+        symbol_inventory_error: analysisErrorProjectionSchema.exactOptional(),
     })),
-    find_xrefs_to_name: resultOf(z.discriminatedUnion("status", [
+    find_xrefs_to_name: evidenceResultOf(z.discriminatedUnion("status", [
         z.object({
             status: z.literal("resolved"),
             name: z.string(),
@@ -216,7 +248,7 @@ export const enhancedOutputSchemas = {
             reason: z.literal("name_not_found"),
         }),
     ])),
-    binary_overview: resultOf(z.object({
+    binary_overview: evidenceResultOf(z.object({
         document: z.string(),
         segments: z.array(z.object({
             name: z.string(),
@@ -229,42 +261,42 @@ export const enhancedOutputSchemas = {
         string_count: z.number().int().min(0),
     })),
     analyze_function: functionDossierOutput,
-    inspect_native_api: resultOf(nativeApiInspectionResultSchema),
+    inspect_native_api: evidenceResultOf(nativeApiInspectionResultSchema),
     trace_feature: literalTraceOutput,
     trace_call_path: callPathTraceOutput,
 };
 /** Exact Evidence schemas for provider-neutral native inspection. */
 export const nativeOutputSchemas = {
-    observe_native_ui: resultOf(nativeUiResultSchema),
-    capture_native_ui_scenario: resultOf(nativeUiResultSchema),
-    observe_native_calls: resultOf(nativeCallObservationResultSchema),
-    inspect_macho: resultOf(inspectMachoSchema),
-    inspect_signature: resultOf(inspectSignatureSchema),
-    inspect_plist: resultOf(inspectPlistSchema),
-    list_architectures: resultOf(listArchitecturesSchema),
-    demangle_swift: resultOf(demangleSwiftSchema),
+    observe_native_ui: evidenceResultOf(nativeUiResultSchema),
+    capture_native_ui_scenario: evidenceResultOf(nativeUiResultSchema),
+    observe_native_calls: evidenceResultOf(nativeCallObservationResultSchema),
+    inspect_macho: evidenceResultOf(inspectMachoSchema),
+    inspect_signature: evidenceResultOf(inspectSignatureSchema),
+    inspect_plist: evidenceResultOf(inspectPlistSchema),
+    list_architectures: evidenceResultOf(listArchitecturesSchema),
+    demangle_swift: evidenceResultOf(demangleSwiftSchema),
 };
 /** Exact Evidence schemas for provider-neutral artifact graph operations. */
 export const artifactOutputSchemas = {
-    inspect_artifact: resultOf(artifactInspectionResultSchema),
-    extract_artifact: resultOf(artifactExtractionResultSchema),
-    decode_interface_builder: resultOf(interfaceBuilderAnalysisSchema),
-    inspect_keyed_archive: resultOf(keyedArchiveResultSchema),
-    inspect_asset_catalog: resultOf(appleAssetCatalogResultSchema),
-    trace_dylib_resolution: resultOf(dylibResolutionResultSchema),
+    inspect_artifact: evidenceResultOf(artifactInspectionResultSchema),
+    extract_artifact: evidenceResultOf(artifactExtractionResultSchema),
+    decode_interface_builder: evidenceResultOf(interfaceBuilderAnalysisSchema),
+    inspect_keyed_archive: evidenceResultOf(keyedArchiveResultSchema),
+    inspect_asset_catalog: evidenceResultOf(appleAssetCatalogResultSchema),
+    trace_dylib_resolution: evidenceResultOf(dylibResolutionResultSchema),
 };
 /** Exact Evidence schema for execution-free managed static analysis. */
 export const managedOutputSchemas = {
-    inspect_managed_artifact: resultOf(managedArtifactInspectionSchema),
-    inspect_managed_members: resultOf(managedMemberInspectionSchema),
-    inspect_managed_native_boundaries: resultOf(managedNativeBoundaryInspectionSchema),
+    inspect_managed_artifact: evidenceResultOf(managedArtifactInspectionSchema),
+    inspect_managed_members: evidenceResultOf(managedMemberInspectionSchema),
+    inspect_managed_native_boundaries: evidenceResultOf(managedNativeBoundaryInspectionSchema),
 };
 /** Exact Evidence schema for provider-neutral managed workflows. */
 export const managedWorkflowOutputSchemas = {
-    compare_managed_members: resultOf(managedMemberComparisonResultSchema),
-    verify_managed_native_boundaries: resultOf(managedNativeVerificationResultSchema),
-    import_managed_reconstruction: resultOf(managedReconstructionImportResultSchema),
-    project_managed_application_graph: resultOf(managedApplicationGraphResultSchema),
+    compare_managed_members: evidenceResultOf(managedMemberComparisonResultSchema),
+    verify_managed_native_boundaries: evidenceResultOf(managedNativeVerificationResultSchema),
+    import_managed_reconstruction: evidenceResultOf(managedReconstructionImportResultSchema),
+    project_managed_application_graph: evidenceResultOf(managedApplicationGraphResultSchema),
 };
 /** Exact structured-content schemas for target lifecycle operations. */
 export const sessionOutputSchemas = {
@@ -272,7 +304,6 @@ export const sessionOutputSchemas = {
         path: z.string(),
         format: targetFormatSchema,
         kind: targetKindSchema,
-        loaderArgs: z.array(z.string()),
         sha256: z.string().regex(/^[a-f0-9]{64}$/u),
         architecture: z.enum(["x86", "x86_64", "arm", "arm64"]).nullable(),
     })),
@@ -281,7 +312,21 @@ export const sessionOutputSchemas = {
         z.object({
             path: z.string(),
             bytes: z.number().int().min(0),
-            entries: z.number().int().min(0),
+            primitive_entries: z
+                .number()
+                .int()
+                .min(0)
+                .describe("Retained eligible primitive query bindings."),
+            workflow_entries: z
+                .number()
+                .int()
+                .min(0)
+                .describe("Retained eligible composed workflow bindings."),
+            evidence_records: z
+                .number()
+                .int()
+                .min(0)
+                .describe("All retained Evidence records, including observations without replay bindings."),
         }),
     ])),
     binary_session: lifecycleResultOf(z.union([
@@ -325,15 +370,15 @@ export const sessionOutputSchemas = {
         unknowns_added: z.number().int().min(0),
         total: z.number().int().min(0),
     })),
-    capture_process_scenario: resultOf(processCaptureSchema),
-    compare_process_captures: resultOf(processCaptureComparisonSchema),
-    compare_artifacts: resultOf(artifactComparisonResultSchema),
-    compare_functions: resultOf(functionComparisonResultSchema),
-    compare_bundles: resultOf(bundleComparisonResultSchema),
-    find_changed_behavior: resultOf(changedBehaviorResultSchema),
-    build_call_path: resultOf(callPathResultSchema),
-    correlate_static_and_runtime: resultOf(staticRuntimeCorrelationResultSchema),
-    verify_reconstruction: resultOf(reconstructionVerificationResultSchema),
+    capture_process_scenario: evidenceResultOf(processCaptureSchema),
+    compare_process_captures: evidenceResultOf(processCaptureComparisonSchema),
+    compare_artifacts: evidenceResultOf(artifactComparisonResultSchema),
+    compare_functions: evidenceResultOf(functionComparisonResultSchema),
+    compare_bundles: evidenceResultOf(bundleComparisonResultSchema),
+    find_changed_behavior: evidenceResultOf(changedBehaviorResultSchema),
+    build_call_path: evidenceResultOf(callPathResultSchema),
+    correlate_static_and_runtime: evidenceResultOf(staticRuntimeCorrelationResultSchema),
+    verify_reconstruction: evidenceResultOf(reconstructionVerificationResultSchema),
     list_unknowns: lifecycleResultOf(z.object({
         items: z.array(residualUnknownSchema),
         total: z.number().int().min(0),

package/dist/contracts/toolOutputSchemaPrimitives.js

@@ -1,19 +1,16 @@
 import { z } from "zod";
 import { procedureClassificationSchema, procedureIdentitySchema, localVariableSchema, functionDossierSchema, functionBodySchema, } from "../domain/hopperValues.js";
 import { analysisProfileSchema } from "../domain/analysisProfile.js";
-import { evidenceEnvelopeSchema } from "../domain/evidence.js";
+import { evidenceSchema, validateAnalysisProfileProvider, } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { PROVIDER_REJECTION_CODES, } from "./providerSelection.js";
+import { PROVIDER_FAILURE_STAGES, PROVIDER_OPERATION_STATES, PROVIDER_RETRY_ACTIONS, } from "../domain/providerOperationHealth.js";
 import { analysisErrorProjectionSchema } from "./errorSchemas.js";
-import { prefixedDigestSchema } from "./../domain/digests.js";
-/** Inline result with its complete Evidence record. */
-export const inlineEvidenceRecordSchema = evidenceEnvelopeSchema;
-export const evidenceResultOf = (schema) => z.strictObject({
-    result: schema,
-    evidence_id: prefixedDigestSchema("ev"),
-    evidence: inlineEvidenceRecordSchema,
-});
-const resultOf = evidenceResultOf;
+/** Specialize the single normalized result inside a complete Evidence record. */
+export const evidenceResultOf = (schema) => z
+    .strictObject({ ...evidenceSchema.shape, normalized_result: schema })
+    .superRefine(validateAnalysisProfileProvider);
+/** Wrap a lifecycle result while preserving its exact schema type. */
 export const lifecycleResultOf = (schema) => z.object({ result: schema });
 /** Resolve a required named output schema or reject contract drift. */
 export const requireOutputSchema = (schemas, name) => {
@@ -133,6 +130,20 @@ export const analysisActivity = z.object({
         queued_requests: z.number().int().min(0),
     })),
 });
+const providerOperationRequest = z.object({
+    request_id: z.number().int().min(1),
+    operation: z.string().min(1),
+    stage: z.enum(PROVIDER_FAILURE_STAGES),
+});
+export const providerOperationHealth = z
+    .object({
+    state: z.enum(PROVIDER_OPERATION_STATES),
+    stage: z.enum(PROVIDER_FAILURE_STAGES).nullable(),
+    retry_action: z.enum(PROVIDER_RETRY_ACTIONS).nullable(),
+    exit_code: z.number().int().nullable(),
+    requests: z.array(providerOperationRequest),
+})
+    .nullable();
 const providerRejectionCode = z.enum(PROVIDER_REJECTION_CODES);
 const providerDiagnostics = z.record(z.string(), jsonValueSchema);
 const providerAvailability = z.discriminatedUnion("status", [
@@ -254,11 +265,10 @@ export const toolAvailability = z.discriminatedUnion("available", [
 ]);
 export const sessionProvider = z
     .object({
-    provider: providerIdentity,
-    providers: z.array(providerIdentity),
     capabilities: z.array(providerCapability),
     analysis_run: analysisRun,
     analysis_activity: analysisActivity,
+    provider_operation_health: providerOperationHealth,
     analysis_provider_binding: z
         .object({
         provider: providerIdentity,
@@ -325,13 +335,11 @@ export const addressedEntry = z.object({
     address: z.string(),
     name: z.string(),
 });
-export const procedureIdentity = procedureIdentitySchema;
-const localVariable = localVariableSchema;
 export const containingProcedureResolution = z.discriminatedUnion("found", [
     z.object({
         query_address: z.string(),
         found: z.literal(true),
-        procedure: procedureIdentity,
+        procedure: procedureIdentitySchema,
     }),
     z.object({
         query_address: z.string(),
@@ -389,21 +397,21 @@ const memoryRegionOutput = z.object({
     initialized: z.boolean().optional(),
     overlay: z.boolean().optional(),
 });
-export const segmentOutput = resultOf(z.array(memoryRegionOutput.extend({ sections: z.array(memoryRegionOutput) })));
-export const procedureInfoOutput = resultOf(z.object({
+export const segmentOutput = evidenceResultOf(z.array(memoryRegionOutput.extend({ sections: z.array(memoryRegionOutput) })));
+export const procedureInfoOutput = evidenceResultOf(z.object({
     name: z.string(),
     entrypoint: z.string(),
     basicblock_count: z.number().int().min(0),
     length: z.number().min(0),
     signature: nullableText,
-    locals: z.array(localVariable),
+    locals: z.array(localVariableSchema),
     classification: procedureClassificationSchema.nullable().default(null),
     body: functionBodySchema.default({
         available: false,
         reason: "The provider did not report complete function body ranges.",
     }),
 }));
-export const symbolDiscoveryOutput = (property) => resultOf(z.object({
+export const symbolDiscoveryOutput = (property) => evidenceResultOf(z.object({
     count: z.number().int().min(0),
     [property]: z.array(addressedEntry),
 }));
@@ -419,4 +427,4 @@ export const graphNode = z.discriminatedUnion("status", [
         error: analysisErrorProjectionSchema,
     }),
 ]);
-export const functionDossierOutput = resultOf(functionDossierSchema);
+export const functionDossierOutput = evidenceResultOf(functionDossierSchema);

package/dist/contracts/toolSchemaMetadata.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { presentInputJsonSchema } from "./inputSchemaPresentation.js";
 const PROPERTY_DESCRIPTIONS = {
     addresses: "Ordered provider-normalized procedure addresses to analyze.",
     after: "The later or right-hand observation to compare.",
@@ -38,52 +39,60 @@ const PROPERTY_DESCRIPTIONS = {
     unknown_id: "Exact residual-unknown identifier.",
 };
 /** Attach caller guidance to a canonical schema for the SDK wire projection. */
-export const toolInputSchemaWithMetadata = (contract) => {
-    const schema = contract.inputSchema.meta(z.globalRegistry.get(contract.inputSchema) ?? {});
-    const standard = schema["~standard"];
-    const inputJsonSchema = standard.jsonSchema?.input;
-    if (inputJsonSchema === undefined)
-        throw new TypeError("Tool input schema does not expose Standard JSON Schema");
+export const toolInputSchemaWithMetadata = (contract) => withAdvertisedJsonSchema(contract.inputSchema, "input", (project) => (options) => {
+    const shared = project({
+        ...options,
+        libraryOptions: { reused: "ref", ...options.libraryOptions },
+    });
+    return {
+        ...presentInputJsonSchema(shared, fallbackPropertyDescription),
+        examples: contract.examples.map(({ input }) => input),
+    };
+});
+/** Share repeated output definitions without changing canonical validation. */
+export const toolOutputSchemaWithMetadata = (contract) => withAdvertisedJsonSchema(contract.outputSchema, "output", (project) => (options) => project({
+    ...options,
+    libraryOptions: { reused: "ref", ...options.libraryOptions },
+}));
+const withAdvertisedJsonSchema = (canonical, io, advertise = (project) => project) => {
     // Zod's input projection drops root metadata when a descendant transforms.
     // Preserve the parser and let the SDK own conversion of everything else.
+    const schema = canonical.meta(z.globalRegistry.get(canonical) ?? {});
+    const standard = schema["~standard"];
+    const project = standard.jsonSchema?.[io];
+    if (project === undefined)
+        throw new TypeError(`Tool ${io} schema does not expose Standard JSON Schema`);
     Object.defineProperty(schema, "~standard", {
         value: {
             ...standard,
             jsonSchema: {
                 ...standard.jsonSchema,
-                input: (options) => ({
-                    ...describeProperties(inputJsonSchema(options)),
-                    examples: contract.examples.map(({ input }) => input),
-                }),
+                [io]: memoizeByTarget(advertise(project)),
             },
         },
     });
     return schema;
 };
-const describeProperties = (value) => Object.fromEntries(Object.entries(value).map(([key, child]) => {
-    if (key !== "properties" || !isObject(child))
-        return [key, describeValue(child)];
-    return [
-        key,
-        Object.fromEntries(Object.entries(child).map(([property, propertySchema]) => [
-            property,
-            isObject(propertySchema) &&
-                typeof propertySchema.description !== "string"
-                ? {
-                    ...describeProperties(propertySchema),
-                    description: fallbackPropertyDescription(property),
-                }
-                : describeValue(propertySchema),
-        ])),
-    ];
-}));
-const describeValue = (value) => {
-    if (Array.isArray(value))
-        return value.map(describeValue);
-    return isObject(value) ? describeProperties(value) : value;
+// The SDK reconverts every registered schema on each `tools/list`, although a
+// registered contract cannot change. Like the SDK's own memoized output
+// projection, the advertised value is shared and treated as read-only.
+const memoizeByTarget = (project) => {
+    const byTarget = new Map();
+    return (options) => {
+        if (options.libraryOptions !== undefined)
+            return project(options);
+        const cached = byTarget.get(options.target);
+        if (cached !== undefined)
+            return cached;
+        const projected = project(options);
+        byTarget.set(options.target, projected);
+        return projected;
+    };
 };
 const fallbackPropertyDescription = (property) => {
-    const explicit = PROPERTY_DESCRIPTIONS[property];
+    const explicit = Object.hasOwn(PROPERTY_DESCRIPTIONS, property)
+        ? PROPERTY_DESCRIPTIONS[property]
+        : undefined;
     if (explicit !== undefined)
         return explicit;
     const words = property.replaceAll("_", " ");
@@ -111,4 +120,3 @@ const fallbackPropertyDescription = (property) => {
         return `Whether ${words}.`;
     return `Value for ${words}.`;
 };
-const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);

package/dist/contracts/webNetworkCaptureToolContracts.js

@@ -1,12 +1,12 @@
 import { inspectWebNetworkCaptureInputSchema, webNetworkCaptureSchema, } from "../domain/webNetworkCapture.js";
 import { toolContractMetadata } from "./toolEffects.js";
-import { evidenceResultOf } from "./toolOutputSchemas.js";
+import { evidenceResultOf } from "./toolOutputSchemaPrimitives.js";
 /** Historical inspection is distinct from live browser capture and runtime authority. */
 export const WEB_NETWORK_CAPTURE_TOOL_CONTRACTS = [
     {
         name: "inspect_web_network_capture",
         ...toolContractMetadata("inspect_web_network_capture"),
-        description: "Inspect retained local HAR 1.2 or native mitmproxy capture records without contacting recorded URLs. Returns original ordinals, pointers/byte ranges, preserved producer fields, precise numeric representations and exact exposed binary bytes inline. Excludes known transport credentials and explicitly marked values. Decodes every record before optional ordinal selection; malformed or oversized captures return no partial success. Duplicate HAR members are invalid; prototype-named __proto__ members are unsupported by the current shared JSON boundary. Uses pinned upstream parsers, owned temporary files and bounded offline processes. Native mitmproxy requires caller-supplied mitmdump 12.2.3 on Linux. Browser transaction IDs, runtime attribution and original bytes of HAR Unicode text remain unknown.",
+        description: "Inspect retained local HAR 1.2 or native mitmproxy capture records without contacting recorded URLs. Returns original ordinals, pointers/byte ranges, preserved producer fields, precise numeric representations and exact exposed binary bytes inline. Excludes known transport credentials and explicitly marked values. Decodes every record before optional ordinal selection; malformed or oversized captures return no partial success. Duplicate HAR members are invalid; prototype-named members such as __proto__ are preserved as ordinary own JSON members without prototype mutation. Uses pinned upstream parsers, owned temporary files and bounded offline processes. Native mitmproxy requires caller-supplied mitmdump 12.2.3 on Linux. Browser transaction IDs, runtime attribution and original bytes of HAR Unicode text remain unknown.",
         kind: "browser-provider",
         inputSchema: inspectWebNetworkCaptureInputSchema,
         outputSchema: evidenceResultOf(webNetworkCaptureSchema),

package/dist/contracts/webRuntimeToolContracts.js

@@ -1,5 +1,5 @@
 import { toolContractMetadata } from "./toolEffects.js";
-import { evidenceResultOf } from "./toolOutputSchemas.js";
+import { evidenceResultOf } from "./toolOutputSchemaPrimitives.js";
 import { observeWebExecutionInputSchema, webExecutionSchema, } from "../domain/webExecution.js";
 import { inspectWebEventListenersInputSchema, webEventListenersSchema, } from "../domain/webEventListeners.js";
 /** Native website runtime primitives distinguish instrumentation from listener inspection. */