@praxis-ai/praxis 0.1.0 → 0.1.1

package/dist/agentCore/agent_executionEngine/promptPack/promptDefiner.js

@@ -1,281 +0,0 @@
-/*
- * 文件定位：Agent 执行引擎 / PromptPack 提示包层。
- * 核心目的：承载 prompt Definer 这一能力位点。
- * 能力要求1：需要把文件名表达的能力落实成清晰的类型、输入输出和最小行为。
- * 能力要求2：如果后续发现语义不足，应优先补接口契约，而不是把逻辑散落到相邻文件。
- * 边界：维护 Praxis PromptPack 语义，不被某一家 provider 的 prompt 字段绑死。
- * 对接：需要被 runtime.execEngine 拉起，并和 mainLoop、stateEngine、事件暴露、工具调用策略接通。
- * 实现提示：先补稳定类型契约、最小可测行为和清晰错误边界，再接入真实执行逻辑。
- */
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-export const PROMPT_PACK_INTERNAL_MATERIAL_KINDS = [
-    "system",
-    "user",
-    "tool",
-    "command",
-    "cmp",
-    "memory",
-    "file",
-    "retrieval",
-    "event",
-    "runtime",
-];
-export const PROMPT_PACK_SEGMENT_KINDS = [
-    "stableSystemCore",
-    "declaredRuntimeContext",
-    "toolDeclarations",
-    "projectContext",
-    "sessionSummary",
-    "memoryContext",
-    "retrievedContext",
-    "observations",
-    "userTurn",
-    "assistantScratchpadPlan",
-];
-export const PROMPT_PACK_PROVIDER_VISIBLE_SEGMENT_KINDS = PROMPT_PACK_SEGMENT_KINDS.filter((segmentKind) => segmentKind !== "assistantScratchpadPlan");
-export const BASIC_CORE_PROMPT_MATERIAL_ID = "praxis:basic-core-prompt";
-export const BASIC_CORE_PROMPT_SOURCE = "runtime.basicCorePrompt";
-export const PROMPT_PACK_TOOL_MATERIAL_TYPES = [
-    "policy",
-    "declaration",
-    "result",
-    "call-state",
-];
-export const promptPackDefinerDescriptor = {
-    capability: "prompt-definer",
-    route: "agent_executionEngine.promptPack",
-    purpose: "define Praxis internal PromptPack constructs and the protected basic core prompt head",
-    internalMaterialKinds: PROMPT_PACK_INTERNAL_MATERIAL_KINDS,
-    sourceCategories: ["declared-built-in", "process-product", "user-request"],
-    orderedSegmentKinds: PROMPT_PACK_SEGMENT_KINDS,
-    providerVisibleSegmentKinds: PROMPT_PACK_PROVIDER_VISIBLE_SEGMENT_KINDS,
-    basicCorePromptMaterialId: BASIC_CORE_PROMPT_MATERIAL_ID,
-    providerPayloadCreated: false,
-    unsafeSideEffects: false,
-};
-function isBlank(value) {
-    return typeof value !== "string" || value.trim().length === 0;
-}
-function cleanList(values) {
-    return [...new Set((values ?? []).map((value) => value.trim()).filter(Boolean))];
-}
-function promptPackFailure(code, message, boundary) {
-    return {
-        ok: false,
-        error: { code, message, boundary, safeForRuntimeInspection: true },
-        events: ["promptPack.definition.rejected"],
-    };
-}
-function hasInvalidBudget(budget) {
-    return [budget?.maxMaterials, budget?.maxEstimatedTokens, budget?.maxMaterialCharacters].some((value) => value !== undefined && (!Number.isInteger(value) || value <= 0));
-}
-function guardScopes(requestedScopes, allowedScopes) {
-    const requested = cleanList(requestedScopes);
-    const allowed = cleanList(allowedScopes);
-    if (requested.length === 0 || allowed.length === 0) {
-        return undefined;
-    }
-    const denied = requested.find((scope) => !allowed.includes(scope));
-    if (denied) {
-        return promptPackFailure("SCOPE_DENIED", `PromptPack scope ${denied} is outside runtime governance`, "scope");
-    }
-    return undefined;
-}
-export function inferPromptMaterialSourceCategory(material) {
-    if (material.sourceCategory !== undefined) {
-        return material.sourceCategory;
-    }
-    if (material.kind === "user" || material.source?.trim() === "user") {
-        return "user-request";
-    }
-    if (material.kind === "event" ||
-        material.kind === "runtime" ||
-        material.kind === "tool-summary" ||
-        material.kind === "command-injection" ||
-        material.source?.startsWith("observation.")) {
-        return "process-product";
-    }
-    return "declared-built-in";
-}
-function readPromptSegmentMetadata(material) {
-    if (material.promptSegmentKind !== undefined) {
-        return material.promptSegmentKind;
-    }
-    const value = material.metadata?.promptSegmentKind;
-    return typeof value === "string" && PROMPT_PACK_SEGMENT_KINDS.includes(value)
-        ? value
-        : undefined;
-}
-export function inferPromptPackSegmentKind(material) {
-    const explicit = readPromptSegmentMetadata(material);
-    if (explicit !== undefined) {
-        return explicit;
-    }
-    if (material.id?.trim() === BASIC_CORE_PROMPT_MATERIAL_ID || material.metadata?.protected === true) {
-        return "stableSystemCore";
-    }
-    const toolType = typeof material.metadata?.toolMaterialType === "string" ? material.metadata.toolMaterialType : undefined;
-    if (material.kind === "tool" && (toolType === "declaration" || toolType === "policy" || toolType === undefined)) {
-        return "toolDeclarations";
-    }
-    if (material.kind === "user" || material.source?.trim() === "user") {
-        return "userTurn";
-    }
-    if (material.kind === "cmp") {
-        return "sessionSummary";
-    }
-    if (material.kind === "memory") {
-        return "memoryContext";
-    }
-    if (material.kind === "retrieval" || material.kind === "file") {
-        return "retrievedContext";
-    }
-    if (material.kind === "event" ||
-        material.kind === "runtime" ||
-        material.kind === "tool-summary" ||
-        material.kind === "command" ||
-        material.kind === "command-injection" ||
-        material.source?.startsWith("observation.")) {
-        return "observations";
-    }
-    if (material.kind === "system" && material.source?.startsWith("manifest.")) {
-        return "declaredRuntimeContext";
-    }
-    if (material.kind === "system") {
-        return "stableSystemCore";
-    }
-    return "projectContext";
-}
-export function estimatePromptTokens(text) {
-    const normalized = text.trim();
-    if (normalized.length === 0) {
-        return 0;
-    }
-    return Math.max(1, Math.ceil(normalized.length / 4));
-}
-export function detectPromptInjectionRisk(text) {
-    return /\b(ignore (previous|all)|reveal (the )?(system|developer) prompt|override system|bypass governance)\b/i.test(text);
-}
-function loadBasicCorePromptFromDisk() {
-    const currentDir = dirname(fileURLToPath(import.meta.url));
-    try {
-        const text = readFileSync(join(currentDir, "basicCorePrompt.md"), "utf8").trim();
-        if (text.length > 0) {
-            return text;
-        }
-    }
-    catch {
-        // Fall through to the embedded minimum so a missing asset does not create an empty root contract.
-    }
-    return "You are Praxis agentCore. Keep runtime governance, PromptPack boundaries, and provider-neutral semantics intact.";
-}
-export function createBasicCorePromptMaterial(textOverride) {
-    const text = textOverride?.trim() || loadBasicCorePromptFromDisk();
-    return {
-        id: BASIC_CORE_PROMPT_MATERIAL_ID,
-        kind: "system",
-        text,
-        source: BASIC_CORE_PROMPT_SOURCE,
-        sourceCategory: "declared-built-in",
-        priority: 1000,
-        trusted: true,
-        scope: "runtime.core",
-        metadata: {
-            protected: true,
-            coreHead: true,
-            promptPackHead: true,
-        },
-    };
-}
-function hasBasicCorePromptMaterial(materials) {
-    return materials.some((material) => material.id?.trim() === BASIC_CORE_PROMPT_MATERIAL_ID);
-}
-export function definePromptPack(request) {
-    if (request === undefined || isBlank(request.runtimeId)) {
-        return promptPackFailure("MISSING_RUNTIME_ID", "runtimeId is required before defining a PromptPack", "input");
-    }
-    if (isBlank(request.sessionId)) {
-        return promptPackFailure("MISSING_SESSION_ID", "sessionId is required before defining a PromptPack", "input");
-    }
-    if (request.runtimeReady === false) {
-        return promptPackFailure("RUNTIME_NOT_READY", "PromptPack can only be defined for a ready runtime", "input");
-    }
-    if (request.contract?.accepted === false) {
-        return promptPackFailure("CONTRACT_REJECTED", request.contract.reason ?? "PromptPack definition was rejected by runtime contract surface", "contract");
-    }
-    if (request.governance?.accepted === false) {
-        return promptPackFailure("GOVERNANCE_REJECTED", request.governance.reason ?? "PromptPack definition was rejected by runtime governance", "governance");
-    }
-    const scopeFailure = guardScopes(request.requestedScopes, request.allowedScopes);
-    if (scopeFailure) {
-        return scopeFailure;
-    }
-    if (hasInvalidBudget(request.budget)) {
-        return promptPackFailure("INVALID_BUDGET", "PromptPack budget values must be positive integers", "budget");
-    }
-    const inputMaterials = request.materials ?? [];
-    const includeBasicCorePrompt = request.includeBasicCorePrompt !== false;
-    const materials = includeBasicCorePrompt && !hasBasicCorePromptMaterial(inputMaterials)
-        ? [createBasicCorePromptMaterial(request.basicCorePromptText), ...inputMaterials]
-        : inputMaterials;
-    if (materials.length === 0) {
-        return promptPackFailure("EMPTY_MATERIALS", "PromptPack definition requires at least one material", "material");
-    }
-    if (request.budget?.maxMaterials !== undefined && materials.length > request.budget.maxMaterials) {
-        return promptPackFailure("BUDGET_EXCEEDED", `PromptPack definition received ${materials.length} materials but maxMaterials is ${request.budget.maxMaterials}`, "budget");
-    }
-    const definedMaterials = [];
-    let totalEstimatedTokens = 0;
-    for (const [index, material] of materials.entries()) {
-        const text = material.text.trim();
-        if (text.length === 0) {
-            return promptPackFailure("EMPTY_MATERIAL_TEXT", `PromptPack material ${material.id ?? index} must contain text`, "material");
-        }
-        const estimatedTokens = material.estimatedTokens ?? estimatePromptTokens(text);
-        totalEstimatedTokens += estimatedTokens;
-        definedMaterials.push({
-            id: material.id?.trim() || `material:${index + 1}`,
-            kind: material.kind,
-            text,
-            source: material.source?.trim() || "runtime",
-            sourceCategory: inferPromptMaterialSourceCategory(material),
-            priority: material.priority ?? 0,
-            estimatedTokens,
-            trusted: material.trusted === true,
-            scope: material.scope?.trim() || undefined,
-            promptSegmentKind: inferPromptPackSegmentKind(material),
-            internalOnly: material.internalOnly === true || inferPromptPackSegmentKind(material) === "assistantScratchpadPlan",
-            metadata: material.metadata ?? {},
-        });
-    }
-    if (request.budget?.maxEstimatedTokens !== undefined &&
-        totalEstimatedTokens > request.budget.maxEstimatedTokens) {
-        return promptPackFailure("BUDGET_EXCEEDED", `PromptPack definition estimates ${totalEstimatedTokens} tokens but maxEstimatedTokens is ${request.budget.maxEstimatedTokens}`, "budget");
-    }
-    const runtimeId = request.runtimeId?.trim() ?? "";
-    const sessionId = request.sessionId?.trim() ?? "";
-    return {
-        ok: true,
-        definition: {
-            kind: "prompt-pack-definition",
-            runtimeId,
-            sessionId,
-            targetModel: request.targetModel?.trim() || undefined,
-            loweringHint: request.loweringHint?.trim() || undefined,
-            materials: definedMaterials,
-            materialKinds: [...new Set(definedMaterials.map((material) => material.kind))],
-            materialSourceCategories: [...new Set(definedMaterials.map((material) => material.sourceCategory))],
-            orderedSegmentKinds: PROMPT_PACK_SEGMENT_KINDS,
-            providerVisibleSegmentKinds: PROMPT_PACK_PROVIDER_VISIBLE_SEGMENT_KINDS,
-            basicCorePromptMaterialId: BASIC_CORE_PROMPT_MATERIAL_ID,
-            budget: request.budget ?? {},
-            requestedScopes: cleanList(request.requestedScopes),
-            providerPayloadCreated: false,
-            governanceRequired: true,
-            unsafeSideEffects: false,
-        },
-        events: ["promptPack.definition.accepted"],
-    };
-}

package/dist/agentCore/agent_modelAdapter/abstractionLayer/capabilityCompatibilityCore/compatibilityProtector.d.ts

@@ -1,53 +0,0 @@
-import type { InterfaceCapabilityDescriptor } from "./interfaceCapabilityExtraction.js";
-import type { InterfaceFormatDescriptor } from "./interfaceFormatExtraction.js";
-import type { InterfaceScopeDecision } from "./interfaceScope.js";
-export type CompatibilityProtectorTrace = {
-    correlationId?: string;
-    bridgeId?: string;
-};
-export type CompatibilityProtectorRequest = {
-    providerId?: string;
-    interfaceId?: string;
-    availableCapabilities?: readonly InterfaceCapabilityDescriptor[];
-    requiredCapabilities?: readonly string[];
-    availableFormats?: readonly InterfaceFormatDescriptor[];
-    requiredFormats?: readonly string[];
-    scopeDecision?: InterfaceScopeDecision;
-    trace?: CompatibilityProtectorTrace;
-};
-export type CompatibilityGapKind = "capability" | "format" | "scope";
-export type CompatibilityGap = {
-    kind: CompatibilityGapKind;
-    requested: string;
-    reason: string;
-};
-export type CompatibilityProtectionReport = {
-    providerId: string;
-    interfaceId: string;
-    compatible: boolean;
-    requiredCapabilities: readonly string[];
-    requiredFormats: readonly string[];
-    capabilityGaps: readonly CompatibilityGap[];
-    formatGaps: readonly CompatibilityGap[];
-    scopeGaps: readonly CompatibilityGap[];
-    bridgeable: boolean;
-    trace: CompatibilityProtectorTrace;
-    unsafeSideEffects: false;
-};
-export type CompatibilityProtectorErrorCode = "MISSING_PROVIDER_ID" | "MISSING_INTERFACE_ID" | "MISSING_AVAILABLE_CAPABILITIES" | "MISSING_AVAILABLE_FORMATS";
-export type CompatibilityProtectorError = {
-    code: CompatibilityProtectorErrorCode;
-    message: string;
-    boundary: "input" | "contract";
-    publicSafe: true;
-};
-export type CompatibilityProtectorResult = {
-    ok: true;
-    report: CompatibilityProtectionReport;
-    events: readonly string[];
-} | {
-    ok: false;
-    error: CompatibilityProtectorError;
-    events: readonly string[];
-};
-export declare function protectCapabilityCompatibility(request?: CompatibilityProtectorRequest): CompatibilityProtectorResult;

package/dist/agentCore/agent_modelAdapter/abstractionLayer/capabilityCompatibilityCore/compatibilityProtector.js

@@ -1,110 +0,0 @@
-/*
- * 文件定位：Agent 模型适配层 / 模型抽象层 / 能力兼容核心。
- * 核心目的：承载 compatibility Protector 这一能力位点。
- * 能力要求1：需要把文件名表达的能力落实成清晰的类型、输入输出和最小行为。
- * 能力要求2：如果后续发现语义不足，应优先补接口契约，而不是把逻辑散落到相邻文件。
- * 边界：负责把任意厂商/格式抽象到 DSL 定义的能力形态，不直接做 agentCore 内部最终调用。
- * 对接：需要被 runtime.modelAdapter 拉起，并和 provider/carrier、PromptPack lowering、能力抽象链路接通。
- * 实现提示：先补稳定类型契约、最小可测行为和清晰错误边界，再接入真实执行逻辑。
- */
-function isBlank(value) {
-    return typeof value !== "string" || value.trim().length === 0;
-}
-function toCompatibilityToken(value) {
-    return value
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-|-$/g, "");
-}
-function cleanList(values) {
-    return [...new Set((values ?? []).map((value) => toCompatibilityToken(value)).filter(Boolean))];
-}
-function failure(code, message, boundary) {
-    return {
-        ok: false,
-        error: { code, message, boundary, publicSafe: true },
-        events: ["agentCore.modelAdapter.compatibilityProtector.rejected"],
-    };
-}
-function cleanTrace(trace) {
-    return {
-        correlationId: trace?.correlationId?.trim() || undefined,
-        bridgeId: trace?.bridgeId?.trim() || undefined,
-    };
-}
-function capabilityTokens(capability) {
-    return [capability.id, capability.name, ...capability.aliases].map((value) => toCompatibilityToken(value));
-}
-function buildMissingGaps(kind, requestedValues, availableValues) {
-    return requestedValues
-        .filter((requested) => !availableValues.includes(requested))
-        .map((requested) => ({
-        kind,
-        requested,
-        reason: `${kind} is not present in the extracted interface abstraction`,
-    }));
-}
-export function protectCapabilityCompatibility(request) {
-    if (request === undefined || isBlank(request.providerId)) {
-        return failure("MISSING_PROVIDER_ID", "compatibility protector requires a providerId", "input");
-    }
-    if (isBlank(request.interfaceId)) {
-        return failure("MISSING_INTERFACE_ID", "compatibility protector requires an interfaceId", "input");
-    }
-    if (request.availableCapabilities === undefined) {
-        return failure("MISSING_AVAILABLE_CAPABILITIES", "compatibility protector requires extracted capability descriptors", "contract");
-    }
-    if (request.availableFormats === undefined) {
-        return failure("MISSING_AVAILABLE_FORMATS", "compatibility protector requires extracted format descriptors", "contract");
-    }
-    const requiredCapabilities = cleanList(request.requiredCapabilities);
-    const requiredFormats = cleanList(request.requiredFormats);
-    const availableCapabilityTokens = [
-        ...new Set(request.availableCapabilities.flatMap((capability) => capabilityTokens(capability))),
-    ];
-    const availableFormatTokens = [
-        ...new Set(request.availableFormats.flatMap((format) => [format.id, format.name].map((value) => toCompatibilityToken(value)))),
-    ];
-    const capabilityGaps = buildMissingGaps("capability", requiredCapabilities, availableCapabilityTokens);
-    const formatGaps = buildMissingGaps("format", requiredFormats, availableFormatTokens);
-    const scopeGaps = [];
-    if (request.scopeDecision !== undefined && !request.scopeDecision.accepted) {
-        for (const capability of request.scopeDecision.missingCapabilities) {
-            scopeGaps.push({
-                kind: "scope",
-                requested: capability,
-                reason: "capability is outside the approved interface scope",
-            });
-        }
-        for (const format of request.scopeDecision.missingFormats) {
-            scopeGaps.push({
-                kind: "scope",
-                requested: format,
-                reason: "format is outside the approved interface scope",
-            });
-        }
-    }
-    const compatible = capabilityGaps.length === 0 && formatGaps.length === 0 && scopeGaps.length === 0;
-    return {
-        ok: true,
-        report: {
-            providerId: (request.providerId ?? "").trim(),
-            interfaceId: (request.interfaceId ?? "").trim(),
-            compatible,
-            requiredCapabilities,
-            requiredFormats,
-            capabilityGaps,
-            formatGaps,
-            scopeGaps,
-            bridgeable: compatible,
-            trace: cleanTrace(request.trace),
-            unsafeSideEffects: false,
-        },
-        events: [
-            compatible
-                ? "agentCore.modelAdapter.compatibilityProtector.compatible"
-                : "agentCore.modelAdapter.compatibilityProtector.gapDetected",
-        ],
-    };
-}

package/dist/agentCore/agent_modelAdapter/abstractionLayer/capabilityCompatibilityCore/interfaceCapabilityExtraction.d.ts

@@ -1,57 +0,0 @@
-export type InterfaceCapabilityKind = "text" | "image" | "audio" | "video" | "tool" | "structured-output" | "custom";
-export type InterfaceCapabilitySignal = {
-    name?: string;
-    kind?: InterfaceCapabilityKind | string;
-    required?: boolean;
-    aliases?: readonly string[];
-    limits?: Readonly<Record<string, string | number | boolean>>;
-    sourceField?: string;
-};
-export type InterfaceCapabilityExtractionTrace = {
-    correlationId?: string;
-    carrierId?: string;
-};
-export type InterfaceCapabilityExtractionGate = {
-    accepted: boolean;
-    reason?: string;
-};
-export type InterfaceCapabilityExtractionRequest = {
-    providerId?: string;
-    interfaceId?: string;
-    capabilitySignals?: readonly InterfaceCapabilitySignal[];
-    dslIntentCapabilities?: readonly string[];
-    governance?: InterfaceCapabilityExtractionGate;
-    trace?: InterfaceCapabilityExtractionTrace;
-};
-export type InterfaceCapabilityDescriptor = {
-    id: string;
-    name: string;
-    kind: InterfaceCapabilityKind | "unknown";
-    required: boolean;
-    aliases: readonly string[];
-    limits: Readonly<Record<string, string | number | boolean>>;
-    sourceField?: string;
-    matchedDslIntent: boolean;
-};
-export type InterfaceCapabilityExtractionErrorCode = "MISSING_PROVIDER_ID" | "MISSING_INTERFACE_ID" | "MISSING_CAPABILITY_SIGNALS" | "EMPTY_CAPABILITY_NAME" | "GOVERNANCE_REJECTED";
-export type InterfaceCapabilityExtractionError = {
-    code: InterfaceCapabilityExtractionErrorCode;
-    message: string;
-    boundary: "input" | "contract" | "governance";
-    publicSafe: true;
-};
-export type InterfaceCapabilityExtractionResult = {
-    ok: true;
-    providerId: string;
-    interfaceId: string;
-    capabilities: readonly InterfaceCapabilityDescriptor[];
-    requestedDslCapabilities: readonly string[];
-    trace: InterfaceCapabilityExtractionTrace;
-    unsafeSideEffects: false;
-    events: readonly string[];
-} | {
-    ok: false;
-    error: InterfaceCapabilityExtractionError;
-    events: readonly string[];
-};
-export declare function extractInterfaceCapabilities(request?: InterfaceCapabilityExtractionRequest): InterfaceCapabilityExtractionResult;

package/dist/agentCore/agent_modelAdapter/abstractionLayer/capabilityCompatibilityCore/interfaceCapabilityExtraction.js

@@ -1,98 +0,0 @@
-/*
- * 文件定位：Agent 模型适配层 / 模型抽象层 / 能力兼容核心。
- * 核心目的：承载 interface Capability Extraction 这一能力位点。
- * 能力要求1：需要把文件名表达的能力落实成清晰的类型、输入输出和最小行为。
- * 能力要求2：如果后续发现语义不足，应优先补接口契约，而不是把逻辑散落到相邻文件。
- * 边界：负责把任意厂商/格式抽象到 DSL 定义的能力形态，不直接做 agentCore 内部最终调用。
- * 对接：需要被 runtime.modelAdapter 拉起，并和 provider/carrier、PromptPack lowering、能力抽象链路接通。
- * 实现提示：先补稳定类型契约、最小可测行为和清晰错误边界，再接入真实执行逻辑。
- */
-const knownCapabilityKinds = new Set([
-    "text",
-    "image",
-    "audio",
-    "video",
-    "tool",
-    "structured-output",
-    "custom",
-]);
-function isBlank(value) {
-    return typeof value !== "string" || value.trim().length === 0;
-}
-function cleanList(values) {
-    return [...new Set((values ?? []).map((value) => value.trim()).filter(Boolean))];
-}
-function toCapabilityId(name) {
-    return name
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-|-$/g, "");
-}
-function normalizeKind(kind) {
-    if (kind === undefined) {
-        return "unknown";
-    }
-    const normalized = kind.trim().toLowerCase();
-    return knownCapabilityKinds.has(normalized)
-        ? normalized
-        : "unknown";
-}
-function failure(code, message, boundary) {
-    return {
-        ok: false,
-        error: { code, message, boundary, publicSafe: true },
-        events: ["agentCore.modelAdapter.capabilityExtraction.rejected"],
-    };
-}
-function cleanTrace(trace) {
-    return {
-        correlationId: trace?.correlationId?.trim() || undefined,
-        carrierId: trace?.carrierId?.trim() || undefined,
-    };
-}
-export function extractInterfaceCapabilities(request) {
-    if (request === undefined || isBlank(request.providerId)) {
-        return failure("MISSING_PROVIDER_ID", "interface capability extraction requires a providerId", "input");
-    }
-    if (isBlank(request.interfaceId)) {
-        return failure("MISSING_INTERFACE_ID", "interface capability extraction requires an interfaceId", "input");
-    }
-    if (request.governance?.accepted === false) {
-        return failure("GOVERNANCE_REJECTED", request.governance.reason ?? "interface capability extraction was rejected by governance", "governance");
-    }
-    if (request.capabilitySignals === undefined || request.capabilitySignals.length === 0) {
-        return failure("MISSING_CAPABILITY_SIGNALS", "interface capability extraction requires at least one upstream capability signal", "input");
-    }
-    const requestedDslCapabilities = cleanList(request.dslIntentCapabilities).map((value) => toCapabilityId(value));
-    const capabilities = [];
-    for (const signal of request.capabilitySignals) {
-        if (isBlank(signal.name)) {
-            return failure("EMPTY_CAPABILITY_NAME", "interface capability extraction cannot normalize an unnamed capability signal", "contract");
-        }
-        const name = (signal.name ?? "").trim();
-        const id = toCapabilityId(name);
-        const aliases = cleanList(signal.aliases);
-        const searchableIds = [id, ...aliases.map((alias) => toCapabilityId(alias))];
-        capabilities.push({
-            id,
-            name,
-            kind: normalizeKind(signal.kind),
-            required: signal.required === true,
-            aliases,
-            limits: signal.limits ?? {},
-            sourceField: signal.sourceField?.trim() || undefined,
-            matchedDslIntent: requestedDslCapabilities.some((intent) => searchableIds.includes(intent)),
-        });
-    }
-    return {
-        ok: true,
-        providerId: (request.providerId ?? "").trim(),
-        interfaceId: (request.interfaceId ?? "").trim(),
-        capabilities,
-        requestedDslCapabilities,
-        trace: cleanTrace(request.trace),
-        unsafeSideEffects: false,
-        events: ["agentCore.modelAdapter.capabilityExtraction.ready"],
-    };
-}

package/dist/agentCore/agent_modelAdapter/abstractionLayer/capabilityCompatibilityCore/interfaceFormatExtraction.d.ts

@@ -1,57 +0,0 @@
-export type InterfaceFormatDirection = "input" | "output" | "bidirectional";
-export type InterfaceFormatSignal = {
-    name?: string;
-    direction?: InterfaceFormatDirection;
-    mediaType?: string;
-    schemaName?: string;
-    fields?: readonly string[];
-    sourceField?: string;
-};
-export type InterfaceFormatExtractionTrace = {
-    correlationId?: string;
-    carrierId?: string;
-};
-export type InterfaceFormatExtractionGate = {
-    accepted: boolean;
-    reason?: string;
-};
-export type InterfaceFormatExtractionRequest = {
-    providerId?: string;
-    interfaceId?: string;
-    formatSignals?: readonly InterfaceFormatSignal[];
-    dslIntentFormats?: readonly string[];
-    governance?: InterfaceFormatExtractionGate;
-    trace?: InterfaceFormatExtractionTrace;
-};
-export type InterfaceFormatDescriptor = {
-    id: string;
-    name: string;
-    direction: InterfaceFormatDirection;
-    mediaType?: string;
-    schemaName?: string;
-    fields: readonly string[];
-    sourceField?: string;
-    matchedDslIntent: boolean;
-};
-export type InterfaceFormatExtractionErrorCode = "MISSING_PROVIDER_ID" | "MISSING_INTERFACE_ID" | "MISSING_FORMAT_SIGNALS" | "EMPTY_FORMAT_NAME" | "GOVERNANCE_REJECTED";
-export type InterfaceFormatExtractionError = {
-    code: InterfaceFormatExtractionErrorCode;
-    message: string;
-    boundary: "input" | "contract" | "governance";
-    publicSafe: true;
-};
-export type InterfaceFormatExtractionResult = {
-    ok: true;
-    providerId: string;
-    interfaceId: string;
-    formats: readonly InterfaceFormatDescriptor[];
-    requestedDslFormats: readonly string[];
-    trace: InterfaceFormatExtractionTrace;
-    unsafeSideEffects: false;
-    events: readonly string[];
-} | {
-    ok: false;
-    error: InterfaceFormatExtractionError;
-    events: readonly string[];
-};
-export declare function extractInterfaceFormats(request?: InterfaceFormatExtractionRequest): InterfaceFormatExtractionResult;