@mcoda/mswarm 0.1.89 → 0.1.91

package/dist/codali-executor.js

@@ -22,6 +22,8 @@ function normalizeCodaliProviderName(providerOrAdapter) {
         return "codex-cli";
     return value;
 }
+export const MSWARM_CODALI_FEEDBACK_SUBMISSION_SCHEMA_VERSION = "codali.feedback_submission.v1";
+export const MSWARM_CODALI_PRODUCT_METADATA_SCHEMA_VERSION = "codali.product_metadata.v1";
 const DEFAULT_RUNTIME_MS = 3600000;
 const DEFAULT_MAX_STEPS = 24;
 const DEFAULT_MAX_TOOL_CALLS = 40;
@@ -51,6 +53,349 @@ async function loadCodaliModule() {
 function optionalText(value) {
     return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
 }
+function recordOrUndefined(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function optionalScopeText(record, keys) {
+    if (!record)
+        return undefined;
+    for (const key of keys) {
+        const value = optionalText(record[key]);
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+function optionalScopeBoolean(record, keys) {
+    if (!record)
+        return undefined;
+    for (const key of keys) {
+        const value = optionalBoolean(record[key]);
+        if (value !== undefined)
+            return value;
+    }
+    return undefined;
+}
+function compactRecord(record) {
+    const compacted = Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+    return Object.keys(compacted).length > 0 ? compacted : undefined;
+}
+function normalizeFeedbackSubmissionVisibility(visibility, tenantWide) {
+    const value = optionalText(visibility);
+    if (value === "requester" ||
+        value === "conversation" ||
+        value === "product" ||
+        value === "tenant") {
+        return value === "tenant" && !tenantWide ? "requester" : value;
+    }
+    return "requester";
+}
+function buildFeedbackSubmissionProductScope(input) {
+    const gatewayProduct = input.codaliGateway?.product;
+    const jobContext = recordOrUndefined(input.codaliJob?.context);
+    const jobProduct = recordOrUndefined(jobContext?.product);
+    const product = gatewayProduct ?? jobProduct;
+    const tenant = input.codaliGateway?.tenant ?? input.codaliJob?.tenant;
+    return compactRecord({
+        product_id: optionalScopeText(product, ["productId", "product_id", "id", "slug", "name"]),
+        tenant_hash: optionalScopeText(product, ["tenantHash", "tenant_hash", "tenantScopeHash", "tenant_scope_hash"]) ??
+            optionalScopeText(tenant, ["tenantHash", "tenant_hash", "hash", "scopeHash", "scope_hash"]),
+        deployment_id: optionalScopeText(product, ["deploymentId", "deployment_id", "deployment"]),
+        environment: optionalScopeText(product, ["environment", "env"]),
+        product_scope_present: product ? true : undefined,
+        tenant_scope_present: tenant ? true : undefined,
+    });
+}
+function buildFeedbackSubmissionRequesterScope(input) {
+    const requester = input.codaliGateway?.requester ?? input.codaliJob?.requester;
+    const conversation = recordOrUndefined(input.codaliGateway?.conversation);
+    const tenantWide = optionalScopeBoolean(requester, ["tenantWide", "tenant_wide"]) === true;
+    const metadata = compactRecord({
+        requester_scope_present: requester ? true : undefined,
+        conversation_scope_present: conversation ? true : undefined,
+    });
+    return {
+        visibility: normalizeFeedbackSubmissionVisibility(optionalScopeText(requester, ["visibility", "scope"]), tenantWide),
+        tenant_wide: tenantWide,
+        ...(optionalScopeText(requester, [
+            "requesterHash",
+            "requester_hash",
+            "subjectHash",
+            "subject_hash",
+            "hash",
+        ])
+            ? {
+                requester_hash: optionalScopeText(requester, [
+                    "requesterHash",
+                    "requester_hash",
+                    "subjectHash",
+                    "subject_hash",
+                    "hash",
+                ]),
+            }
+            : {}),
+        ...(optionalScopeText(conversation, ["conversationHash", "conversation_hash", "hash"])
+            ? { conversation_hash: optionalScopeText(conversation, ["conversationHash", "conversation_hash", "hash"]) }
+            : {}),
+        ...(optionalScopeText(requester, ["requesterType", "requester_type", "type", "role"])
+            ? { requester_type: optionalScopeText(requester, ["requesterType", "requester_type", "type", "role"]) }
+            : {}),
+        ...(metadata ? { metadata } : {}),
+    };
+}
+function feedbackSubmissionRole(input) {
+    if (input.codaliGateway)
+        return "codali_gateway_answer";
+    if (input.codaliJob)
+        return "codali_job_result";
+    return "codali_runtime_result";
+}
+function buildMswarmCodaliFeedbackSubmissionMetadata(input, runId) {
+    const role = feedbackSubmissionRole(input);
+    const recordMetadata = compactRecord({
+        job_id: input.jobId,
+        request_id: input.requestId,
+        gateway_id: input.codaliGateway?.id,
+        codali_job_id: input.codaliJob?.id,
+        codali_job_type: input.codaliJob?.jobType,
+    });
+    const deletionGroupId = optionalScopeText(input.codaliGateway?.metadata, ["deletionGroupId", "deletion_group_id"]) ??
+        optionalScopeText(input.codaliJob?.metadata, ["deletionGroupId", "deletion_group_id"]) ??
+        `delete-group-${runId}`;
+    return {
+        schema_version: MSWARM_CODALI_FEEDBACK_SUBMISSION_SCHEMA_VERSION,
+        run_id: runId,
+        deletion_group_id: deletionGroupId,
+        target: {
+            record_type: "gateway_record",
+            record_id: runId,
+            role,
+            ...(recordMetadata ? { metadata: recordMetadata } : {}),
+        },
+        candidate_records: [
+            {
+                record_type: "gateway_record",
+                record_id: runId,
+                role,
+                ...(recordMetadata ? { metadata: recordMetadata } : {}),
+            },
+        ],
+        ...(buildFeedbackSubmissionProductScope(input)
+            ? { product_scope: buildFeedbackSubmissionProductScope(input) }
+            : {}),
+        requester_scope: buildFeedbackSubmissionRequesterScope(input),
+        source: {
+            runtime: "mswarm",
+            job_id: input.jobId,
+            request_id: input.requestId,
+            agent_slug: input.agent.slug,
+            ...(input.session?.id ? { session_id: input.session.id } : {}),
+        },
+        raw_trace_included: false,
+    };
+}
+function buildProductDatasetCollectionMetadata(metadata) {
+    const collection = recordOrUndefined(metadata.datasetCollection ?? metadata.dataset_collection);
+    const recordCounts = collection
+        ? recordOrUndefined(collection.recordCounts ?? collection.record_counts)
+        : undefined;
+    const errors = collection ? stringArray(collection.errors) : undefined;
+    const output = {
+        status: optionalScopeText(collection, ["status"]) ?? "not_configured",
+    };
+    if (collection) {
+        const accepted = optionalScopeBoolean(collection, ["accepted"]);
+        const recordCount = optionalNumber(collection.recordCount, collection.record_count);
+        const objectCount = optionalNumber(collection.objectCount, collection.object_count);
+        const replayed = optionalScopeBoolean(collection, ["replayed"]);
+        const fallbackUsed = optionalScopeBoolean(collection, ["fallbackUsed", "fallback_used"]);
+        if (accepted !== undefined)
+            output.accepted = accepted;
+        if (recordCount !== undefined)
+            output.record_count = recordCount;
+        if (objectCount !== undefined)
+            output.object_count = objectCount;
+        if (replayed !== undefined)
+            output.replayed = replayed;
+        if (fallbackUsed !== undefined)
+            output.fallback_used = fallbackUsed;
+    }
+    if (errors)
+        output.errors = errors;
+    if (recordCounts)
+        output.record_counts = recordCounts;
+    return output;
+}
+function buildProductPrivacyFlags(metadata) {
+    const flags = recordOrUndefined(metadata.privacyFlags ?? metadata.privacy_flags);
+    const privacy = recordOrUndefined(metadata.privacy ?? metadata.privacy_metadata);
+    const uploadAllowed = optionalScopeBoolean(flags, ["uploadAllowed", "upload_allowed", "allowUpload", "allow_upload"]) ??
+        optionalScopeBoolean(privacy, ["uploadAllowed", "upload_allowed", "allowUpload", "allow_upload"]) ??
+        false;
+    const exportAllowed = optionalScopeBoolean(flags, ["exportAllowed", "export_allowed", "allowExport", "allow_export"]) ??
+        optionalScopeBoolean(privacy, ["exportAllowed", "export_allowed", "allowExport", "allow_export"]) ??
+        false;
+    const trainingAllowed = optionalScopeBoolean(flags, [
+        "trainingAllowed",
+        "training_allowed",
+        "allowTraining",
+        "allow_training",
+    ]) ??
+        optionalScopeBoolean(privacy, [
+            "trainingAllowed",
+            "training_allowed",
+            "allowTraining",
+            "allow_training",
+        ]) ??
+        false;
+    return {
+        local_only: !(uploadAllowed || exportAllowed || trainingAllowed),
+        upload_allowed: uploadAllowed,
+        export_allowed: exportAllowed,
+        training_allowed: trainingAllowed,
+        raw_trace_included: false,
+        contains_personal_data: optionalScopeBoolean(flags, [
+            "containsPersonalData",
+            "contains_personal_data",
+            "containsPii",
+            "contains_pii",
+        ]) ??
+            optionalScopeBoolean(privacy, [
+                "containsPersonalData",
+                "contains_personal_data",
+                "containsPii",
+                "contains_pii",
+            ]) ??
+            true,
+        contains_tenant_private_data: optionalScopeBoolean(flags, [
+            "containsTenantPrivateData",
+            "contains_tenant_private_data",
+        ]) ??
+            optionalScopeBoolean(privacy, [
+                "containsTenantPrivateData",
+                "contains_tenant_private_data",
+            ]) ??
+            true,
+        contains_customer_data: optionalScopeBoolean(flags, ["containsCustomerData", "contains_customer_data"]) ??
+            optionalScopeBoolean(privacy, ["containsCustomerData", "contains_customer_data"]) ??
+            true,
+    };
+}
+function latencyMsFromRecord(record) {
+    const metadata = recordOrUndefined(record.metadata);
+    const latency = optionalNumber(record.latencyMs, record.latency_ms, record.durationMs, record.duration_ms, metadata?.latencyMs, metadata?.latency_ms, metadata?.durationMs, metadata?.duration_ms);
+    return latency !== undefined && latency >= 0 ? latency : undefined;
+}
+function sumLatencyMs(records) {
+    let total = 0;
+    let found = false;
+    for (const record of records) {
+        const latency = latencyMsFromRecord(record);
+        if (latency === undefined)
+            continue;
+        total += latency;
+        found = true;
+    }
+    return found ? Math.round(total) : undefined;
+}
+function buildProductModelTiers(gatewayResult) {
+    const output = [];
+    const seen = new Set();
+    const push = (record, roleFallback) => {
+        if (!record)
+            return;
+        const metadata = recordOrUndefined(record.metadata);
+        const entry = compactRecord({
+            role: optionalScopeText(record, ["role"]) ?? roleFallback,
+            tier: optionalScopeText(record, ["tier", "modelTier", "model_tier"]) ??
+                optionalScopeText(metadata, ["tier", "modelTier", "model_tier"]),
+            model: optionalScopeText(record, ["model", "modelId", "model_id"]) ??
+                optionalScopeText(metadata, ["model", "modelId", "model_id"]),
+            provider: optionalScopeText(record, ["provider", "providerName", "provider_name"]) ??
+                optionalScopeText(metadata, ["provider", "providerName", "provider_name"]),
+            agent_slug: optionalScopeText(record, ["agentSlug", "agent_slug"]) ??
+                optionalScopeText(metadata, ["agentSlug", "agent_slug"]),
+        });
+        if (!entry)
+            return;
+        const key = JSON.stringify(entry);
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        output.push(entry);
+    };
+    push(recordOrUndefined(gatewayResult.finalModel), "final_synthesizer");
+    for (const call of gatewayResult.trace.modelCalls) {
+        push(recordOrUndefined(call));
+    }
+    return output;
+}
+function buildMswarmCodaliProductMetadata(gatewayResult, feedbackSubmission) {
+    const gatewayTrace = gatewayResult.trace;
+    const gatewayMetadata = gatewayResult.metadata ?? {};
+    const traceMetadata = gatewayTrace.metadata ?? {};
+    const datasetCollection = buildProductDatasetCollectionMetadata(gatewayMetadata);
+    const warnings = uniqueStrings(gatewayTrace.warnings, stringArray(gatewayMetadata.warnings)) ?? [];
+    const errors = uniqueStrings(gatewayTrace.errors, stringArray(gatewayMetadata.errors)) ?? [];
+    const calledTools = uniqueStrings(gatewayTrace.calledTools, stringArray(gatewayMetadata.calledTools), stringArray(gatewayMetadata.called_tools)) ?? [];
+    const contextPackId = optionalScopeText(recordOrUndefined(gatewayResult.contextPack), ["id", "contextPackId", "context_pack_id"]) ??
+        optionalScopeText(traceMetadata, ["contextPackId", "context_pack_id"]) ??
+        optionalScopeText(gatewayMetadata, ["contextPackId", "context_pack_id"]);
+    const toolLatencyMs = sumLatencyMs(gatewayTrace.toolCalls);
+    const modelLatencyMs = sumLatencyMs(gatewayTrace.modelCalls);
+    const totalLatencyMs = optionalNumber(gatewayMetadata.latencyMs, gatewayMetadata.latency_ms, traceMetadata.latencyMs, traceMetadata.latency_ms) ??
+        (toolLatencyMs !== undefined || modelLatencyMs !== undefined
+            ? (toolLatencyMs ?? 0) + (modelLatencyMs ?? 0)
+            : undefined);
+    return {
+        schema_version: MSWARM_CODALI_PRODUCT_METADATA_SCHEMA_VERSION,
+        run_id: gatewayResult.runId,
+        trace_id: optionalScopeText(traceMetadata, ["traceId", "trace_id"]) ??
+            optionalScopeText(gatewayMetadata, ["traceId", "trace_id"]) ??
+            gatewayTrace.runId ??
+            gatewayResult.runId,
+        ...(contextPackId ? { context_pack_id: contextPackId } : {}),
+        dataset_collection: datasetCollection,
+        privacy_flags: buildProductPrivacyFlags(gatewayMetadata),
+        record_counts: {
+            ...(datasetCollection.record_count !== undefined
+                ? { dataset_records: datasetCollection.record_count }
+                : {}),
+            sources: gatewayResult.sources.length,
+            evidence: gatewayResult.evidence.length,
+            tool_calls: gatewayTrace.toolCallCount,
+            model_calls: gatewayTrace.modelCallCount,
+            context_packs: gatewayResult.contextPack ? 1 : 0,
+            final_answers: gatewayResult.answer ? 1 : 0,
+            warnings: warnings.length,
+            errors: errors.length,
+        },
+        feedback_ref: {
+            schema_version: feedbackSubmission.schema_version,
+            run_id: feedbackSubmission.run_id,
+            deletion_group_id: feedbackSubmission.deletion_group_id,
+            target: feedbackSubmission.target,
+            candidate_record_count: feedbackSubmission.candidate_records.length,
+            ...(feedbackSubmission.product_scope
+                ? { product_scope: feedbackSubmission.product_scope }
+                : {}),
+            requester_scope: feedbackSubmission.requester_scope,
+            raw_trace_included: false,
+        },
+        called_tools: calledTools,
+        model_tiers: buildProductModelTiers(gatewayResult),
+        warnings,
+        errors,
+        ...(totalLatencyMs !== undefined ? { latency_ms: Math.round(totalLatencyMs) } : {}),
+        latency: {
+            ...(totalLatencyMs !== undefined ? { total_ms: Math.round(totalLatencyMs) } : {}),
+            ...(modelLatencyMs !== undefined ? { model_ms: modelLatencyMs } : {}),
+            ...(toolLatencyMs !== undefined ? { tool_ms: toolLatencyMs } : {}),
+        },
+    };
+}
 function textFromMessageContent(content) {
     if (typeof content === "string") {
         return content;
@@ -134,8 +479,6 @@ function buildRuntimePolicy(agent, policy) {
         appToolContracts: policy?.appToolContracts,
         appVirtualTools: policy?.appVirtualTools,
         appToolGateway: policy?.appToolGateway,
-        okacamToolContracts: policy?.okacamToolContracts,
-        okacamVirtualTools: policy?.okacamVirtualTools,
         maxSteps: allowRuntimeTools ? DEFAULT_MAX_STEPS : 2,
         maxToolCalls: allowRuntimeTools
             ? policy?.maxToolCalls ?? DEFAULT_MAX_TOOL_CALLS
@@ -154,16 +497,19 @@ function buildRuntimeDocdex(workspace, docdex, requestId, attachedMswarmApiKey)
             dagSessionId: requestId,
         };
     }
+    const credentialSource = docdex?.credentialSource;
+    const apiKey = credentialSource === "attached_mswarm_api_key"
+        ? attachedMswarmApiKey
+        : docdex?.apiKey;
     return {
         enabled: docdex.enabled,
         baseUrl: docdex?.baseUrl ?? DEFAULT_DOCDEX_BASE_URL,
         repoRoot: docdex?.repoRoot ?? workspace.root,
         repoId: docdex?.repoId,
         dagSessionId: docdex?.dagSessionId ?? requestId,
-        apiKey: docdex?.credentialSource === "attached_mswarm_api_key"
-            ? attachedMswarmApiKey
-            : undefined,
-        credentialSource: docdex?.credentialSource,
+        apiKey,
+        credentialSource,
+        immutableRuntimeContext: docdex?.immutableRuntimeContext === true || credentialSource === "attached_mswarm_api_key",
         required: docdex?.required,
         allowedOperations: docdex?.allowedOperations,
         capabilities: docdex?.capabilities,
@@ -175,6 +521,22 @@ function buildRuntimeDocdex(workspace, docdex, requestId, attachedMswarmApiKey)
         toolManifest: docdex?.toolManifest,
     };
 }
+function mergeGatewayDocdexContext(gatewayDocdex, runtimeDocdex) {
+    if (!gatewayDocdex)
+        return runtimeDocdex;
+    if (!runtimeDocdex)
+        return gatewayDocdex;
+    const credentialSource = gatewayDocdex.credentialSource ?? runtimeDocdex.credentialSource;
+    return {
+        ...runtimeDocdex,
+        ...gatewayDocdex,
+        credentialSource,
+        apiKey: gatewayDocdex.apiKey ?? runtimeDocdex.apiKey,
+        immutableRuntimeContext: gatewayDocdex.immutableRuntimeContext ??
+            runtimeDocdex.immutableRuntimeContext ??
+            credentialSource === "attached_mswarm_api_key",
+    };
+}
 function runtimeAgent(agent) {
     return {
         slug: agent.slug,
@@ -294,8 +656,8 @@ function mergeToolContracts(...values) {
     return output.length ? output : undefined;
 }
 function buildGatewayPolicy(gatewayPolicy, runtimePolicy) {
-    const appToolContracts = mergeToolContracts(policyToolContracts(gatewayPolicy, "appToolContracts", "app_tool_contracts"), policyToolContracts(gatewayPolicy, "okacamToolContracts", "okacam_tool_contracts"), runtimePolicy.appToolContracts, runtimePolicy.okacamToolContracts);
-    const appVirtualTools = uniqueStrings(policyStringArray(gatewayPolicy, "appVirtualTools", "app_virtual_tools"), policyStringArray(gatewayPolicy, "okacamVirtualTools", "okacam_virtual_tools"), runtimePolicy.appVirtualTools, runtimePolicy.okacamVirtualTools);
+    const appToolContracts = mergeToolContracts(policyToolContracts(gatewayPolicy, "appToolContracts", "app_tool_contracts"), runtimePolicy.appToolContracts);
+    const appVirtualTools = uniqueStrings(policyStringArray(gatewayPolicy, "appVirtualTools", "app_virtual_tools"), runtimePolicy.appVirtualTools);
     const policy = {
         ...(gatewayPolicy ?? {}),
         allowedTools: policyStringArray(gatewayPolicy, "allowedTools", "allowed_tools") ??
@@ -390,7 +752,7 @@ function buildGatewayRequest(input, runtimeInput) {
         query: optionalText(gateway.query) ?? messagesToTask(input.messages),
         mode: gateway.mode ?? "balanced",
         conversation: gateway.conversation ?? buildGatewayConversation(input),
-        docdex: gateway.docdex ?? runtimeInput.docdex,
+        docdex: mergeGatewayDocdexContext(gateway.docdex, runtimeInput.docdex),
         tools: gateway.tools ?? input.docdex?.toolManifest,
         policy: buildGatewayPolicy(gateway.policy, runtimeInput.policy),
         agentPolicy: gateway.agentPolicy ?? {
@@ -414,25 +776,131 @@ function buildGatewayRequest(input, runtimeInput) {
         },
     };
 }
-function buildGatewayAgentInventory(agent) {
+function mergeDefinedGatewayAgentRecord(current, next) {
+    const merged = { ...(current ?? {}) };
+    for (const [key, value] of Object.entries(next)) {
+        if (value !== undefined) {
+            merged[key] = value;
+        }
+    }
+    return merged;
+}
+function gatewayStageAgentContainers(gateway) {
+    const gatewayRecord = recordOrUndefined(gateway);
+    const agentPolicy = recordOrUndefined(gateway?.agentPolicy);
+    const metadata = recordOrUndefined(gateway?.metadata);
     return [
-        {
-            slug: agent.slug,
-            adapter: agent.adapter,
-            provider: providerNameForAgent(agent),
-            model: agent.model,
-            baseUrl: agent.baseUrl,
-            supportsTools: agent.supportsTools,
-            supportsJsonSchema: agent.supportsJsonSchema,
-            supportsStreaming: agent.supportsStreaming,
-            contextWindow: agent.contextWindow,
-            maxOutputTokens: agent.maxOutputTokens,
-            capabilities: agent.capabilities,
-            health_status: "healthy",
-            source: "self_hosted",
-        },
+        recordOrUndefined(gatewayRecord?.stageAgents),
+        recordOrUndefined(gatewayRecord?.stage_agents),
+        recordOrUndefined(agentPolicy?.stageAgents),
+        recordOrUndefined(agentPolicy?.stage_agents),
+        recordOrUndefined(metadata?.stageAgents),
+        recordOrUndefined(metadata?.stage_agents),
     ];
 }
+function gatewayStageAgentRecords(gateway) {
+    const records = [];
+    for (const container of gatewayStageAgentContainers(gateway)) {
+        if (!container) {
+            continue;
+        }
+        for (const candidate of Object.values(container)) {
+            const record = recordOrUndefined(candidate);
+            if (record) {
+                records.push(record);
+            }
+        }
+    }
+    return records;
+}
+function gatewayStageAgentTier(value) {
+    const tier = optionalText(value)?.toLowerCase();
+    return tier === "small" || tier === "medium" || tier === "large" || tier === "image"
+        ? tier
+        : undefined;
+}
+function gatewayStageAgentTierMinContextWindow(tier) {
+    if (tier === "large")
+        return 16000;
+    if (tier === "medium" || tier === "image")
+        return 8000;
+    if (tier === "small")
+        return 4000;
+    return undefined;
+}
+function gatewayStageAgentContextWindow(tier, ...values) {
+    const explicit = values
+        .map((value) => optionalNumber(value))
+        .filter((value) => typeof value === "number" && value > 0)
+        .sort((left, right) => right - left)[0];
+    const minimum = gatewayStageAgentTierMinContextWindow(tier);
+    if (explicit && minimum)
+        return Math.max(explicit, minimum);
+    return explicit ?? minimum;
+}
+function normalizeGatewayStageAgentRecord(value) {
+    const nestedAgent = recordOrUndefined(value.codaliAgent) ?? recordOrUndefined(value.codali_agent);
+    const nestedProvider = recordOrUndefined(value.codaliProvider) ?? recordOrUndefined(value.codali_provider);
+    const capabilities = stringArray(value.capabilities) ?? stringArray(nestedAgent?.capabilities) ?? [];
+    const tier = gatewayStageAgentTier(value.tier) ??
+        gatewayStageAgentTier(value.modelTier) ??
+        gatewayStageAgentTier(value.model_tier) ??
+        gatewayStageAgentTier(nestedAgent?.tier) ??
+        gatewayStageAgentTier(nestedAgent?.modelTier) ??
+        gatewayStageAgentTier(nestedAgent?.model_tier);
+    const contextWindow = gatewayStageAgentContextWindow(tier, value.contextWindow, value.context_window, nestedAgent?.contextWindow, nestedAgent?.context_window, nestedProvider?.contextWindow, nestedProvider?.context_window);
+    const supportsTools = optionalBoolean(value.supportsTools, value.supports_tools, nestedAgent?.supportsTools, nestedAgent?.supports_tools, nestedProvider?.supportsTools, nestedProvider?.supports_tools);
+    const supportsJsonSchema = optionalBoolean(value.supportsJsonSchema, value.supports_json_schema, nestedAgent?.supportsJsonSchema, nestedAgent?.supports_json_schema, nestedProvider?.supportsJsonSchema, nestedProvider?.supports_json_schema);
+    return compactRecord({
+        ...(nestedAgent ?? {}),
+        ...value,
+        capabilities,
+        ...(tier ? { tier, modelTier: tier, model_tier: tier } : {}),
+        ...(contextWindow ? { contextWindow, context_window: contextWindow } : {}),
+        ...(typeof supportsTools === "boolean"
+            ? { supportsTools, supports_tools: supportsTools }
+            : {}),
+        ...(typeof supportsJsonSchema === "boolean"
+            ? { supportsJsonSchema, supports_json_schema: supportsJsonSchema }
+            : {}),
+        healthStatus: optionalText(value.healthStatus) ?? optionalText(value.health_status) ?? "healthy",
+        health_status: optionalText(value.health_status) ?? optionalText(value.healthStatus) ?? "healthy",
+        source: optionalText(value.source) ?? "self_hosted",
+    });
+}
+function buildGatewayAgentInventory(agent, gateway) {
+    const bySlug = new Map();
+    const addCandidate = (candidate) => {
+        if (!candidate) {
+            return;
+        }
+        const slug = optionalText(candidate.slug) ?? optionalText(candidate.id);
+        if (!slug) {
+            return;
+        }
+        bySlug.set(slug, mergeDefinedGatewayAgentRecord(bySlug.get(slug), candidate));
+    };
+    addCandidate({
+        slug: agent.slug,
+        adapter: agent.adapter,
+        provider: providerNameForAgent(agent),
+        model: agent.model,
+        baseUrl: agent.baseUrl,
+        supportsTools: agent.supportsTools,
+        supportsJsonSchema: agent.supportsJsonSchema,
+        supportsStreaming: agent.supportsStreaming,
+        contextWindow: agent.contextWindow,
+        maxOutputTokens: agent.maxOutputTokens,
+        capabilities: agent.capabilities,
+        healthStatus: "healthy",
+        health_status: "healthy",
+        source: "self_hosted",
+    });
+    for (const stageAgent of gatewayStageAgentRecords(gateway)) {
+        addCandidate(normalizeGatewayStageAgentRecord(stageAgent));
+    }
+    return [...bySlug.values()];
+}
 function createGatewayProvider(input) {
     return {
         name: input.providerName,
@@ -644,7 +1112,7 @@ export class MswarmCodaliExecutor {
             gatewayResult = await runCodaliGateway(gatewayRequest, {
                 provider: createGatewayProvider({ providerName, runtimeInput, runCodali }),
                 taskRunner: createGatewayTaskRunner({ runtimeInput, runCodali }),
-                agentInventory: buildGatewayAgentInventory(input.agent),
+                agentInventory: buildGatewayAgentInventory(input.agent, gatewayRequest),
                 workerOptions: {
                     maxRuntimeMs: gatewayRequest.policy?.maxRuntimeMs,
                     maxToolCalls: gatewayRequest.policy?.maxToolCalls,
@@ -697,6 +1165,8 @@ export class MswarmCodaliExecutor {
             }).length;
             const gatewayWarnings = gatewayTrace.warnings ?? [];
             const gatewayErrors = gatewayTrace.errors ?? [];
+            const feedbackSubmission = buildMswarmCodaliFeedbackSubmissionMetadata(input, gatewayResult.runId);
+            const productMetadata = buildMswarmCodaliProductMetadata(gatewayResult, feedbackSubmission);
             return {
                 output: gatewayResult.answer,
                 runtimeResult: gatewayResult,
@@ -742,6 +1212,8 @@ export class MswarmCodaliExecutor {
                     codali_gateway_warnings: gatewayWarnings,
                     codali_gateway_errors: gatewayErrors,
                     codali_gateway_trace: gatewayTrace,
+                    feedback_submission: feedbackSubmission,
+                    codali_product_metadata: productMetadata,
                     touched_files: [],
                     warnings: gatewayWarnings,
                     mode: runtimePolicy.mode,
@@ -755,6 +1227,7 @@ export class MswarmCodaliExecutor {
         }
         const telemetry = invocationResult.telemetry;
         const runtimeTelemetry = runtimeResult?.telemetry;
+        const feedbackSubmission = buildMswarmCodaliFeedbackSubmissionMetadata(input, invocationResult.runId);
         return {
             output: jobResult?.output ?? runtimeResult?.finalMessage ?? "",
             usage: invocationResult.usage,
@@ -781,6 +1254,7 @@ export class MswarmCodaliExecutor {
                 codali_job_stage_count: jobResult?.stages.length,
                 codali_job_stages: jobResult?.telemetry.stages,
                 codali_job_errors: jobResult?.errors,
+                feedback_submission: feedbackSubmission,
                 touched_files: invocationResult.touchedFiles,
                 warnings: invocationResult.warnings,
                 mode: runtimePolicy.mode,