ai-capability-framework 1.0.0-rc.1

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { decideCapability, evaluateLifecycle, evaluatePolicy } from "./decision.js";
+export { formatEvalSuiteResult, loadEvalResults, runEvalSuite, scoreEvalCase } from "./eval-runner.js";
+export { buildAiSdkTools, parseAiSdkToolCall, toAiSdkToolName } from "./ai-sdk.js";
+export { buildAnthropicClaudeTools, parseAnthropicClaudeToolUse, toAnthropicClaudeToolName } from "./anthropic-claude.js";
+export { buildGeminiFunctionDeclarations, parseGeminiFunctionCall, toGeminiFunctionName } from "./gemini.js";
+export { buildLangChainToolDescriptors, parseLangChainToolCall, toLangChainToolName } from "./langchain.js";
+export { loadManifests, kindFromPath } from "./loader.js";
+export { buildMcpToolDescriptors, parseMcpToolCall, toMcpToolName } from "./mcp.js";
+export { buildOpenAIResponsesTools, parseOpenAIResponsesToolCall, toOpenAIResponsesToolName } from "./openai-responses.js";
+export { buildRegistry, formatInspection, inspectRegistry } from "./registry.js";
+export { runCli } from "./cli.js";
+export { buildSemanticKernelFunctions, parseSemanticKernelFunctionCall, toSemanticKernelFunctionName } from "./semantic-kernel.js";
+export { validateManifests } from "./validator.js";
+export type { AdapterExcludedCapability, AdapterToolBinding, AicfDiagnostic, AicfErrorCode, AicfSchemaDiagnostic, AicfWarningCode, AiSdkTool, AiSdkToolCall, AiSdkToolNameOptions, AiSdkToolset, AnthropicClaudeTool, AnthropicClaudeToolNameOptions, AnthropicClaudeToolset, AnthropicClaudeToolUse, BuildAdapterToolsOptions, BuildAiSdkToolsOptions, BuildAnthropicClaudeToolsOptions, BuildGeminiFunctionDeclarationsOptions, BuildLangChainToolDescriptorsOptions, BuildMcpToolDescriptorsOptions, CapabilityManifest, DecisionAuditPreview, DecisionFact, DecisionOperation, DecisionReason, DecisionReasonCode, DecisionRequest, DecisionResult, DecisionStatus, EvalCandidateResult, EntityManifest, EvalCase, EvalCaseResult, EvalResultFixture, EvalRunStatus, EvalScorerResult, EvalSuiteResult, GeminiFunctionCall, GeminiFunctionDeclaration, GeminiFunctionDeclarationSet, GeminiFunctionNameOptions, LangChainToolCall, LangChainToolDescriptor, LangChainToolDescriptorSet, LangChainToolNameOptions, LifecycleEvaluation, LoadEvalResultsResult, LoadedCapabilityManifest, LoadedEntityManifest, LoadedEvalCase, LoadedManifest, LoadManifestsOptions, LoadManifestsResult, ManifestKind, ManifestRegistry, McpToolCall, McpToolDescriptor, McpToolDescriptorSet, McpToolNameOptions, BuildOpenAIResponsesToolsOptions, BuildSemanticKernelFunctionsOptions, JsonObject, JsonValue, OpenAIResponsesExcludedCapability, OpenAIResponsesFunctionCall, OpenAIResponsesFunctionTool, OpenAIResponsesToolBinding, OpenAIResponsesToolNameOptions, OpenAIResponsesToolset, ParsedAdapterToolCall, ParsedAiSdkToolCall, ParsedAnthropicClaudeToolUse, ParsedGeminiFunctionCall, ParsedLangChainToolCall, ParsedMcpToolCall, ParsedOpenAIResponsesToolCall, ParsedSemanticKernelFunctionCall, ParseAdapterToolCallResult, ParseAiSdkToolCallResult, ParseAnthropicClaudeToolUseResult, ParseGeminiFunctionCallResult, ParseLangChainToolCallResult, ParseMcpToolCallResult, ParseOpenAIResponsesToolCallResult, ParseSemanticKernelFunctionCallResult, PolicyEvaluation, RegistryInspection, RunEvalSuiteOptions, SemanticKernelFunction, SemanticKernelFunctionCall, SemanticKernelFunctionNameOptions, SemanticKernelFunctionSet, ValidateManifestsOptions, ValidationResult } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpF,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACvG,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnF,OAAO,EAAE,yBAAyB,EAAE,2BAA2B,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAC1H,OAAO,EAAE,+BAA+B,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAC7G,OAAO,EAAE,6BAA6B,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC5G,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACpF,OAAO,EAAE,yBAAyB,EAAE,4BAA4B,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAC3H,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACjF,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,4BAA4B,EAAE,+BAA+B,EAAE,4BAA4B,EAAE,MAAM,sBAAsB,CAAC;AACnI,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,YAAY,EACV,yBAAyB,EACzB,kBAAkB,EAClB,cAAc,EACd,aAAa,EACb,oBAAoB,EACpB,eAAe,EACf,SAAS,EACT,aAAa,EACb,oBAAoB,EACpB,YAAY,EACZ,mBAAmB,EACnB,8BAA8B,EAC9B,sBAAsB,EACtB,sBAAsB,EACtB,wBAAwB,EACxB,sBAAsB,EACtB,gCAAgC,EAChC,sCAAsC,EACtC,oCAAoC,EACpC,8BAA8B,EAC9B,kBAAkB,EAClB,oBAAoB,EACpB,YAAY,EACZ,iBAAiB,EACjB,cAAc,EACd,kBAAkB,EAClB,eAAe,EACf,cAAc,EACd,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,QAAQ,EACR,cAAc,EACd,iBAAiB,EACjB,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,kBAAkB,EAClB,yBAAyB,EACzB,4BAA4B,EAC5B,yBAAyB,EACzB,iBAAiB,EACjB,uBAAuB,EACvB,0BAA0B,EAC1B,wBAAwB,EACxB,mBAAmB,EACnB,qBAAqB,EACrB,wBAAwB,EACxB,oBAAoB,EACpB,cAAc,EACd,cAAc,EACd,oBAAoB,EACpB,mBAAmB,EACnB,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACX,iBAAiB,EACjB,oBAAoB,EACpB,kBAAkB,EAClB,gCAAgC,EAChC,mCAAmC,EACnC,UAAU,EACV,SAAS,EACT,iCAAiC,EACjC,2BAA2B,EAC3B,2BAA2B,EAC3B,0BAA0B,EAC1B,8BAA8B,EAC9B,sBAAsB,EACtB,qBAAqB,EACrB,mBAAmB,EACnB,4BAA4B,EAC5B,wBAAwB,EACxB,uBAAuB,EACvB,iBAAiB,EACjB,6BAA6B,EAC7B,gCAAgC,EAChC,0BAA0B,EAC1B,wBAAwB,EACxB,iCAAiC,EACjC,6BAA6B,EAC7B,4BAA4B,EAC5B,sBAAsB,EACtB,kCAAkC,EAClC,qCAAqC,EACrC,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,EACnB,sBAAsB,EACtB,0BAA0B,EAC1B,iCAAiC,EACjC,yBAAyB,EACzB,wBAAwB,EACxB,gBAAgB,EACjB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,13 @@
+export { decideCapability, evaluateLifecycle, evaluatePolicy } from "./decision.js";
+export { formatEvalSuiteResult, loadEvalResults, runEvalSuite, scoreEvalCase } from "./eval-runner.js";
+export { buildAiSdkTools, parseAiSdkToolCall, toAiSdkToolName } from "./ai-sdk.js";
+export { buildAnthropicClaudeTools, parseAnthropicClaudeToolUse, toAnthropicClaudeToolName } from "./anthropic-claude.js";
+export { buildGeminiFunctionDeclarations, parseGeminiFunctionCall, toGeminiFunctionName } from "./gemini.js";
+export { buildLangChainToolDescriptors, parseLangChainToolCall, toLangChainToolName } from "./langchain.js";
+export { loadManifests, kindFromPath } from "./loader.js";
+export { buildMcpToolDescriptors, parseMcpToolCall, toMcpToolName } from "./mcp.js";
+export { buildOpenAIResponsesTools, parseOpenAIResponsesToolCall, toOpenAIResponsesToolName } from "./openai-responses.js";
+export { buildRegistry, formatInspection, inspectRegistry } from "./registry.js";
+export { runCli } from "./cli.js";
+export { buildSemanticKernelFunctions, parseSemanticKernelFunctionCall, toSemanticKernelFunctionName } from "./semantic-kernel.js";
+export { validateManifests } from "./validator.js";

package/dist/langchain.d.ts

@@ -0,0 +1,5 @@
+import type { BuildLangChainToolDescriptorsOptions, LangChainToolCall, LangChainToolDescriptorSet, LangChainToolNameOptions, ManifestRegistry, ParseLangChainToolCallResult } from "./types.js";
+export declare function buildLangChainToolDescriptors(registry: ManifestRegistry, options: BuildLangChainToolDescriptorsOptions): LangChainToolDescriptorSet;
+export declare function parseLangChainToolCall(descriptorSet: LangChainToolDescriptorSet, call: LangChainToolCall): ParseLangChainToolCallResult;
+export declare function toLangChainToolName(capabilityId: string, options?: LangChainToolNameOptions): string;
+//# sourceMappingURL=langchain.d.ts.map

package/dist/langchain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"langchain.d.ts","sourceRoot":"","sources":["../src/langchain.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,oCAAoC,EACpC,iBAAiB,EAEjB,0BAA0B,EAC1B,wBAAwB,EACxB,gBAAgB,EAChB,4BAA4B,EAC7B,MAAM,YAAY,CAAC;AAKpB,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE,oCAAoC,GAC5C,0BAA0B,CAsB5B;AAED,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,0BAA0B,EACzC,IAAI,EAAE,iBAAiB,GACtB,4BAA4B,CAqB9B;AAED,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,wBAA6B,GACrC,MAAM,CAKR"}

package/dist/langchain.js

@@ -0,0 +1,65 @@
+import { adapterToolDescription, buildAdapterToolset, isRecord, parseAdapterToolCall, toAdapterToolName } from "./adapter-common.js";
+const defaultNamePrefix = "aicf_";
+const maxToolNameLength = 64;
+export function buildLangChainToolDescriptors(registry, options) {
+    return buildAdapterToolset({
+        adapterName: "LangChain",
+        buildTool: ({ loadedCapability, normalizedInputSchema, restricted, toolName }) => ({
+            description: adapterToolDescription(loadedCapability.manifest),
+            metadata: {
+                autonomyTier: loadedCapability.manifest.autonomy_tier,
+                capabilityId: loadedCapability.manifest.id,
+                capabilityType: loadedCapability.manifest.capability_type,
+                restricted,
+                riskTier: loadedCapability.manifest.risk_tier
+            },
+            name: toolName,
+            schema: normalizedInputSchema
+        }),
+        context: options.context,
+        defaultNamePrefix,
+        includeRestricted: options.includeRestricted,
+        maxToolNameLength,
+        namePrefix: options.namePrefix,
+        registry
+    });
+}
+export function parseLangChainToolCall(descriptorSet, call) {
+    const shapeError = validateLangChainToolCall(call);
+    if (shapeError) {
+        return {
+            diagnostics: [{
+                    code: "invalid_tool_call",
+                    message: shapeError,
+                    path: "tool_call"
+                }],
+            valid: false
+        };
+    }
+    return parseAdapterToolCall({
+        argumentsPath: "tool_call.args",
+        bindings: descriptorSet.bindings,
+        callId: call.id,
+        rawArguments: call.args,
+        toolName: call.name,
+        toolNamePath: "tool_call.name"
+    });
+}
+export function toLangChainToolName(capabilityId, options = {}) {
+    return toAdapterToolName(capabilityId, {
+        maxLength: maxToolNameLength,
+        namePrefix: options.namePrefix ?? defaultNamePrefix
+    });
+}
+function validateLangChainToolCall(call) {
+    if (!isRecord(call)) {
+        return "LangChain tool call must be an object.";
+    }
+    if (typeof call.name !== "string" || call.name.length === 0) {
+        return "LangChain tool call name is required.";
+    }
+    if (!isRecord(call.args)) {
+        return "LangChain tool call args must be a JSON object.";
+    }
+    return null;
+}

package/dist/loader.d.ts

@@ -0,0 +1,4 @@
+import type { LoadManifestsOptions, LoadManifestsResult, ManifestKind } from "./types.js";
+export declare function loadManifests(options?: LoadManifestsOptions): Promise<LoadManifestsResult>;
+export declare function kindFromPath(filePath: string): ManifestKind | null;
+//# sourceMappingURL=loader.d.ts.map

package/dist/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../src/loader.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAGV,oBAAoB,EACpB,mBAAmB,EACnB,YAAY,EACb,MAAM,YAAY,CAAC;AAKpB,wBAAsB,aAAa,CAAC,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAqDpG;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAQlE"}

package/dist/loader.js

@@ -0,0 +1,94 @@
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import YAML from "yaml";
+const structuredExtensions = new Set([".json", ".yaml", ".yml"]);
+const ignoredDirectories = new Set([".git", "_private", "node_modules"]);
+export async function loadManifests(options = {}) {
+    const root = path.resolve(options.root ?? process.cwd());
+    const basePath = path.resolve(root, options.path ?? "examples");
+    const manifests = [];
+    const errors = [];
+    let files;
+    try {
+        files = await listStructuredFiles(basePath);
+    }
+    catch (error) {
+        return {
+            basePath,
+            errors: [{
+                    code: "unsupported",
+                    message: error instanceof Error ? error.message : "Unable to read manifest path.",
+                    path: toRelativePath(root, basePath)
+                }],
+            manifests,
+            root
+        };
+    }
+    for (const absolutePath of files) {
+        const kind = kindFromPath(absolutePath);
+        if (!kind) {
+            continue;
+        }
+        const relativePath = toRelativePath(root, absolutePath);
+        try {
+            const manifest = await readStructuredFile(absolutePath);
+            manifests.push({
+                absolutePath,
+                kind,
+                manifest,
+                path: relativePath
+            });
+        }
+        catch (error) {
+            errors.push({
+                code: "parse",
+                kind,
+                message: error instanceof Error ? error.message : "Unable to parse manifest.",
+                path: relativePath
+            });
+        }
+    }
+    return {
+        basePath,
+        errors,
+        manifests,
+        root
+    };
+}
+export function kindFromPath(filePath) {
+    const parts = filePath.replaceAll("\\", "/").split("/");
+    if (parts.includes("capabilities"))
+        return "capability";
+    if (parts.includes("entities"))
+        return "entity";
+    if (parts.includes("evals"))
+        return "eval";
+    return null;
+}
+async function listStructuredFiles(directory) {
+    const entries = await readdir(directory, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            if (!ignoredDirectories.has(entry.name)) {
+                files.push(...await listStructuredFiles(path.join(directory, entry.name)));
+            }
+            continue;
+        }
+        if (entry.isFile() && structuredExtensions.has(path.extname(entry.name).toLowerCase())) {
+            files.push(path.join(directory, entry.name));
+        }
+    }
+    return files.sort((left, right) => left.localeCompare(right));
+}
+async function readStructuredFile(filePath) {
+    const content = await readFile(filePath, "utf8");
+    const extension = path.extname(filePath).toLowerCase();
+    if (extension === ".json") {
+        return JSON.parse(content);
+    }
+    return YAML.parse(content);
+}
+function toRelativePath(root, absolutePath) {
+    return path.relative(root, absolutePath).replaceAll("\\", "/");
+}

package/dist/mcp.d.ts

@@ -0,0 +1,5 @@
+import type { BuildMcpToolDescriptorsOptions, ManifestRegistry, McpToolCall, McpToolDescriptorSet, McpToolNameOptions, ParseMcpToolCallResult } from "./types.js";
+export declare function buildMcpToolDescriptors(registry: ManifestRegistry, options: BuildMcpToolDescriptorsOptions): McpToolDescriptorSet;
+export declare function parseMcpToolCall(descriptorSet: McpToolDescriptorSet, call: McpToolCall): ParseMcpToolCallResult;
+export declare function toMcpToolName(capabilityId: string, options?: McpToolNameOptions): string;
+//# sourceMappingURL=mcp.d.ts.map

package/dist/mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../src/mcp.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,8BAA8B,EAE9B,gBAAgB,EAChB,WAAW,EAEX,oBAAoB,EACpB,kBAAkB,EAClB,sBAAsB,EACvB,MAAM,YAAY,CAAC;AAKpB,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE,8BAA8B,GACtC,oBAAoB,CAkBtB;AAED,wBAAgB,gBAAgB,CAC9B,aAAa,EAAE,oBAAoB,EACnC,IAAI,EAAE,WAAW,GAChB,sBAAsB,CAoBxB;AAED,wBAAgB,aAAa,CAC3B,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,kBAAuB,GAC/B,MAAM,CAKR"}

package/dist/mcp.js

@@ -0,0 +1,82 @@
+import { adapterToolDescription, buildAdapterToolset, isRecord, parseAdapterToolCall, toAdapterToolName, toJsonObject } from "./adapter-common.js";
+const defaultNamePrefix = "aicf_";
+const maxToolNameLength = 64;
+export function buildMcpToolDescriptors(registry, options) {
+    return buildAdapterToolset({
+        adapterName: "Model Context Protocol",
+        buildTool: ({ loadedCapability, normalizedInputSchema, toolName }) => ({
+            annotations: mcpAnnotations(loadedCapability.manifest),
+            description: adapterToolDescription(loadedCapability.manifest),
+            inputSchema: normalizedInputSchema,
+            name: toolName,
+            outputSchema: toJsonObject(loadedCapability.manifest.output_schema),
+            title: loadedCapability.manifest.name
+        }),
+        context: options.context,
+        defaultNamePrefix,
+        includeRestricted: options.includeRestricted,
+        maxToolNameLength,
+        namePrefix: options.namePrefix,
+        registry
+    });
+}
+export function parseMcpToolCall(descriptorSet, call) {
+    const shapeError = validateMcpToolCall(call);
+    if (shapeError) {
+        return {
+            diagnostics: [{
+                    code: "invalid_tool_call",
+                    message: shapeError,
+                    path: "tools/call"
+                }],
+            valid: false
+        };
+    }
+    return parseAdapterToolCall({
+        argumentsPath: "tools/call.params.arguments",
+        bindings: descriptorSet.bindings,
+        rawArguments: call.params.arguments,
+        toolName: call.params.name,
+        toolNamePath: "tools/call.params.name"
+    });
+}
+export function toMcpToolName(capabilityId, options = {}) {
+    return toAdapterToolName(capabilityId, {
+        maxLength: maxToolNameLength,
+        namePrefix: options.namePrefix ?? defaultNamePrefix
+    });
+}
+function validateMcpToolCall(call) {
+    if (!isRecord(call)) {
+        return "MCP tools/call request must be an object.";
+    }
+    if (!isRecord(call.params)) {
+        return "MCP tools/call params must be an object.";
+    }
+    if (typeof call.params.name !== "string" || call.params.name.length === 0) {
+        return "MCP tools/call params.name is required.";
+    }
+    if (!isRecord(call.params.arguments)) {
+        return "MCP tools/call params.arguments must be a JSON object.";
+    }
+    return null;
+}
+function mcpAnnotations(capability) {
+    const writes = capability.side_effects.writes_data
+        || capability.side_effects.creates_records
+        || capability.side_effects.updates_records
+        || capability.side_effects.deletes_records;
+    const openWorld = capability.side_effects.sends_external_messages
+        || capability.side_effects.triggers_external_workflow;
+    const destructive = capability.side_effects.deletes_records
+        || capability.side_effects.changes_permissions
+        || capability.side_effects.irreversible
+        || capability.side_effects.charges_money
+        || capability.side_effects.refunds_money;
+    return {
+        destructiveHint: destructive,
+        idempotentHint: !destructive && (!writes || capability.idempotency?.required === true),
+        openWorldHint: openWorld,
+        readOnlyHint: capability.side_effects.reads_data && !writes && !openWorld && !destructive
+    };
+}

package/dist/openai-responses.d.ts

@@ -0,0 +1,6 @@
+import type { BuildOpenAIResponsesToolsOptions, OpenAIResponsesFunctionCall, OpenAIResponsesToolNameOptions, OpenAIResponsesToolset, ParseOpenAIResponsesToolCallResult } from "./types.js";
+import type { ManifestRegistry } from "./types.js";
+export declare function buildOpenAIResponsesTools(registry: ManifestRegistry, options: BuildOpenAIResponsesToolsOptions): OpenAIResponsesToolset;
+export declare function parseOpenAIResponsesToolCall(toolset: OpenAIResponsesToolset, call: OpenAIResponsesFunctionCall): ParseOpenAIResponsesToolCallResult;
+export declare function toOpenAIResponsesToolName(capabilityId: string, options?: OpenAIResponsesToolNameOptions): string;
+//# sourceMappingURL=openai-responses.d.ts.map

package/dist/openai-responses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-responses.d.ts","sourceRoot":"","sources":["../src/openai-responses.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,gCAAgC,EAChC,2BAA2B,EAE3B,8BAA8B,EAC9B,sBAAsB,EACtB,kCAAkC,EACnC,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAKnD,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE,gCAAgC,GACxC,sBAAsB,CAiBxB;AAED,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,sBAAsB,EAC/B,IAAI,EAAE,2BAA2B,GAChC,kCAAkC,CAuBpC;AAED,wBAAgB,yBAAyB,CACvC,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,8BAAmC,GAC3C,MAAM,CAKR"}

package/dist/openai-responses.js

@@ -0,0 +1,65 @@
+import { adapterToolDescription, buildAdapterToolset, isRecord, parseAdapterToolCall, toAdapterToolName } from "./adapter-common.js";
+const defaultNamePrefix = "aicf_";
+const maxOpenAIToolNameLength = 64;
+export function buildOpenAIResponsesTools(registry, options) {
+    return buildAdapterToolset({
+        adapterName: "OpenAI",
+        buildTool: ({ loadedCapability, normalizedInputSchema, toolName }) => ({
+            description: adapterToolDescription(loadedCapability.manifest),
+            name: toolName,
+            parameters: normalizedInputSchema,
+            strict: true,
+            type: "function"
+        }),
+        context: options.context,
+        defaultNamePrefix,
+        includeRestricted: options.includeRestricted,
+        maxToolNameLength: maxOpenAIToolNameLength,
+        namePrefix: options.namePrefix,
+        registry
+    });
+}
+export function parseOpenAIResponsesToolCall(toolset, call) {
+    const callShapeError = validateToolCallShape(call);
+    if (callShapeError) {
+        return {
+            diagnostics: [{
+                    code: "invalid_tool_call",
+                    message: callShapeError,
+                    path: "tool_call"
+                }],
+            valid: false
+        };
+    }
+    return parseAdapterToolCall({
+        argumentsPath: "tool_call.arguments",
+        bindings: toolset.bindings,
+        callId: call.call_id,
+        id: call.id,
+        rawArguments: call.arguments,
+        rawArgumentsAreJsonString: true,
+        toolName: call.name,
+        toolNamePath: "tool_call.name"
+    });
+}
+export function toOpenAIResponsesToolName(capabilityId, options = {}) {
+    return toAdapterToolName(capabilityId, {
+        maxLength: maxOpenAIToolNameLength,
+        namePrefix: options.namePrefix ?? defaultNamePrefix
+    });
+}
+function validateToolCallShape(call) {
+    if (!isRecord(call)) {
+        return "OpenAI tool call must be an object.";
+    }
+    if (call.type !== "function_call") {
+        return "OpenAI tool call type must be function_call.";
+    }
+    if (typeof call.name !== "string" || call.name.length === 0) {
+        return "OpenAI tool call name is required.";
+    }
+    if (typeof call.arguments !== "string") {
+        return "OpenAI tool call arguments must be a JSON string.";
+    }
+    return null;
+}

package/dist/registry.d.ts

@@ -0,0 +1,6 @@
+import type { LoadedManifest, ManifestRegistry, RegistryInspection } from "./types.js";
+export declare function buildRegistry(manifests: LoadedManifest[]): ManifestRegistry;
+export declare function inspectRegistry(registry: ManifestRegistry): RegistryInspection;
+export declare function formatInspection(inspection: RegistryInspection): string;
+export declare function resolveManifestReference(basePath: string, reference: string): string;
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAKV,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAEpB,wBAAgB,aAAa,CAAC,SAAS,EAAE,cAAc,EAAE,GAAG,gBAAgB,CAkB3E;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,gBAAgB,GAAG,kBAAkB,CAsB9E;AAED,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,kBAAkB,GAAG,MAAM,CAsBvE;AA8FD,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEpF"}

package/dist/registry.js

@@ -0,0 +1,134 @@
+import path from "node:path";
+export function buildRegistry(manifests) {
+    const capabilities = manifests.filter(isCapability);
+    const entities = manifests.filter(isEntity);
+    const evals = manifests.filter(isEval);
+    const capabilityById = new Map(capabilities.map((entry) => [entry.manifest.id, entry]));
+    const entityById = new Map(entities.map((entry) => [entry.manifest.id, entry]));
+    const evalById = new Map(evals.map((entry) => [entry.manifest.id, entry]));
+    const warnings = buildWarnings(entities, evals, capabilityById);
+    return {
+        capabilities,
+        capabilityById,
+        entities,
+        entityById,
+        evalById,
+        evals,
+        warnings
+    };
+}
+export function inspectRegistry(registry) {
+    const evalCoverage = registry.capabilities
+        .map((entry) => ({
+        capabilityId: entry.manifest.id,
+        golden: entry.manifest.evals?.golden?.length ?? 0,
+        redTeam: entry.manifest.evals?.red_team?.length ?? 0
+    }))
+        .sort((left, right) => left.capabilityId.localeCompare(right.capabilityId));
+    return {
+        capabilitiesByRisk: groupCapabilities(registry.capabilities, "risk_tier"),
+        capabilitiesByType: groupCapabilities(registry.capabilities, "capability_type"),
+        counts: {
+            capabilities: registry.capabilities.length,
+            entities: registry.entities.length,
+            evals: registry.evals.length,
+            manifests: registry.capabilities.length + registry.entities.length + registry.evals.length
+        },
+        entities: registry.entities.map((entry) => entry.manifest.id).sort(),
+        evalCoverage,
+        warnings: registry.warnings
+    };
+}
+export function formatInspection(inspection) {
+    const lines = [
+        "AICF Registry",
+        `Manifests: ${inspection.counts.manifests} (${inspection.counts.capabilities} capabilities, ${inspection.counts.entities} entities, ${inspection.counts.evals} evals)`,
+        "",
+        "Capabilities by type:",
+        ...formatGroups(inspection.capabilitiesByType),
+        "",
+        "Capabilities by risk:",
+        ...formatGroups(inspection.capabilitiesByRisk),
+        "",
+        "Entities:",
+        ...formatList(inspection.entities),
+        "",
+        "Eval coverage:",
+        ...inspection.evalCoverage.map((coverage) => `- ${coverage.capabilityId}: golden ${coverage.golden}, red_team ${coverage.redTeam}`),
+        "",
+        "Warnings:",
+        ...formatWarnings(inspection.warnings)
+    ];
+    return `${lines.join("\n")}\n`;
+}
+function buildWarnings(entities, evals, capabilityById) {
+    const warnings = [];
+    for (const entity of entities) {
+        for (const capabilityId of entity.manifest.allowed_actions) {
+            if (!capabilityById.has(capabilityId)) {
+                warnings.push({
+                    code: "unknown_allowed_action",
+                    id: entity.manifest.id,
+                    kind: "entity",
+                    message: `Allowed action "${capabilityId}" does not match a loaded capability.`,
+                    path: entity.path
+                });
+            }
+        }
+        // Lookup capabilities can be owned by another manifest bundle. Phase 2 only
+        // warns on action/eval references that affect this loaded registry.
+    }
+    for (const evalCase of evals) {
+        const capabilityId = evalCase.manifest.capability_under_test;
+        if (capabilityId && !capabilityById.has(capabilityId)) {
+            warnings.push({
+                code: "unknown_capability_under_test",
+                id: evalCase.manifest.id,
+                kind: "eval",
+                message: `Capability under test "${capabilityId}" does not match a loaded capability.`,
+                path: evalCase.path
+            });
+        }
+    }
+    return warnings.sort((left, right) => left.path.localeCompare(right.path) || left.message.localeCompare(right.message));
+}
+function groupCapabilities(capabilities, key) {
+    const groups = {};
+    for (const capability of capabilities) {
+        const group = capability.manifest[key];
+        groups[group] ??= [];
+        groups[group].push(capability.manifest.id);
+    }
+    for (const ids of Object.values(groups)) {
+        ids.sort();
+    }
+    return Object.fromEntries(Object.entries(groups).sort(([left], [right]) => left.localeCompare(right)));
+}
+function formatGroups(groups) {
+    const entries = Object.entries(groups);
+    if (entries.length === 0) {
+        return ["- none"];
+    }
+    return entries.map(([group, ids]) => `- ${group}: ${ids.join(", ")}`);
+}
+function formatList(items) {
+    return items.length > 0 ? items.map((item) => `- ${item}`) : ["- none"];
+}
+function formatWarnings(warnings) {
+    if (warnings.length === 0) {
+        return ["- none"];
+    }
+    return warnings.map((warning) => `- ${warning.path}: ${warning.message}`);
+}
+function isCapability(manifest) {
+    return manifest.kind === "capability";
+}
+function isEntity(manifest) {
+    return manifest.kind === "entity";
+}
+function isEval(manifest) {
+    return manifest.kind === "eval";
+}
+export function resolveManifestReference(basePath, reference) {
+    return path.normalize(path.resolve(path.dirname(basePath), reference));
+}

package/dist/semantic-kernel.d.ts

@@ -0,0 +1,5 @@
+import type { BuildSemanticKernelFunctionsOptions, ManifestRegistry, ParseSemanticKernelFunctionCallResult, SemanticKernelFunctionCall, SemanticKernelFunctionNameOptions, SemanticKernelFunctionSet } from "./types.js";
+export declare function buildSemanticKernelFunctions(registry: ManifestRegistry, options: BuildSemanticKernelFunctionsOptions): SemanticKernelFunctionSet;
+export declare function parseSemanticKernelFunctionCall(functionSet: SemanticKernelFunctionSet, call: SemanticKernelFunctionCall): ParseSemanticKernelFunctionCallResult;
+export declare function toSemanticKernelFunctionName(capabilityId: string, options?: SemanticKernelFunctionNameOptions): string;
+//# sourceMappingURL=semantic-kernel.d.ts.map

package/dist/semantic-kernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic-kernel.d.ts","sourceRoot":"","sources":["../src/semantic-kernel.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,mCAAmC,EACnC,gBAAgB,EAChB,qCAAqC,EAErC,0BAA0B,EAC1B,iCAAiC,EACjC,yBAAyB,EAC1B,MAAM,YAAY,CAAC;AAMpB,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE,mCAAmC,GAC3C,yBAAyB,CA8B3B;AAED,wBAAgB,+BAA+B,CAC7C,WAAW,EAAE,yBAAyB,EACtC,IAAI,EAAE,0BAA0B,GAC/B,qCAAqC,CAuBvC;AAED,wBAAgB,4BAA4B,CAC1C,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,iCAAsC,GAC9C,MAAM,CAKR"}

package/dist/semantic-kernel.js

@@ -0,0 +1,79 @@
+import { adapterToolDescription, buildAdapterToolset, isRecord, parseAdapterToolCall, toAdapterToolName } from "./adapter-common.js";
+const defaultNamePrefix = "aicf_";
+const maxFunctionNameLength = 64;
+const pluginName = "aicf";
+export function buildSemanticKernelFunctions(registry, options) {
+    const built = buildAdapterToolset({
+        adapterName: "Semantic Kernel",
+        buildTool: ({ loadedCapability, normalizedInputSchema, restricted, toolName }) => ({
+            description: adapterToolDescription(loadedCapability.manifest),
+            metadata: {
+                autonomyTier: loadedCapability.manifest.autonomy_tier,
+                capabilityId: loadedCapability.manifest.id,
+                capabilityType: loadedCapability.manifest.capability_type,
+                restricted,
+                riskTier: loadedCapability.manifest.risk_tier
+            },
+            name: toolName,
+            parameters: normalizedInputSchema,
+            pluginName
+        }),
+        context: options.context,
+        defaultNamePrefix,
+        includeRestricted: options.includeRestricted,
+        maxToolNameLength: maxFunctionNameLength,
+        namePrefix: options.namePrefix,
+        registry
+    });
+    return {
+        bindings: built.bindings,
+        diagnostics: built.diagnostics,
+        excluded: built.excluded,
+        functions: built.tools
+    };
+}
+export function parseSemanticKernelFunctionCall(functionSet, call) {
+    const shapeError = validateSemanticKernelFunctionCall(call);
+    if (shapeError) {
+        return {
+            diagnostics: [{
+                    code: "invalid_tool_call",
+                    message: shapeError,
+                    path: "function_call"
+                }],
+            valid: false
+        };
+    }
+    const functionName = call.functionName ?? call.name ?? "";
+    return parseAdapterToolCall({
+        argumentsPath: "function_call.arguments",
+        bindings: functionSet.bindings,
+        callId: call.id,
+        rawArguments: call.arguments,
+        toolName: stripPluginPrefix(functionName),
+        toolNamePath: "function_call.functionName"
+    });
+}
+export function toSemanticKernelFunctionName(capabilityId, options = {}) {
+    return toAdapterToolName(capabilityId, {
+        maxLength: maxFunctionNameLength,
+        namePrefix: options.namePrefix ?? defaultNamePrefix
+    });
+}
+function validateSemanticKernelFunctionCall(call) {
+    if (!isRecord(call)) {
+        return "Semantic Kernel function call must be an object.";
+    }
+    const name = call.functionName ?? call.name;
+    if (typeof name !== "string" || name.length === 0) {
+        return "Semantic Kernel function call functionName or name is required.";
+    }
+    if (!isRecord(call.arguments)) {
+        return "Semantic Kernel function call arguments must be a JSON object.";
+    }
+    return null;
+}
+function stripPluginPrefix(functionName) {
+    const prefix = `${pluginName}.`;
+    return functionName.startsWith(prefix) ? functionName.slice(prefix.length) : functionName;
+}