ai-capability-framework 1.0.0-rc.1

package/dist/anthropic-claude.js

@@ -0,0 +1,62 @@
+import { adapterToolDescription, buildAdapterToolset, isRecord, parseAdapterToolCall, toAdapterToolName } from "./adapter-common.js";
+const defaultNamePrefix = "aicf_";
+const maxToolNameLength = 64;
+export function buildAnthropicClaudeTools(registry, options) {
+    return buildAdapterToolset({
+        adapterName: "Anthropic Claude",
+        buildTool: ({ loadedCapability, normalizedInputSchema, toolName }) => ({
+            description: adapterToolDescription(loadedCapability.manifest),
+            input_schema: normalizedInputSchema,
+            name: toolName,
+            strict: true
+        }),
+        context: options.context,
+        defaultNamePrefix,
+        includeRestricted: options.includeRestricted,
+        maxToolNameLength,
+        namePrefix: options.namePrefix,
+        registry
+    });
+}
+export function parseAnthropicClaudeToolUse(toolset, toolUse) {
+    const shapeError = validateAnthropicToolUse(toolUse);
+    if (shapeError) {
+        return {
+            diagnostics: [{
+                    code: "invalid_tool_call",
+                    message: shapeError,
+                    path: "tool_use"
+                }],
+            valid: false
+        };
+    }
+    return parseAdapterToolCall({
+        argumentsPath: "tool_use.input",
+        bindings: toolset.bindings,
+        callId: toolUse.id,
+        rawArguments: toolUse.input,
+        toolName: toolUse.name,
+        toolNamePath: "tool_use.name"
+    });
+}
+export function toAnthropicClaudeToolName(capabilityId, options = {}) {
+    return toAdapterToolName(capabilityId, {
+        maxLength: maxToolNameLength,
+        namePrefix: options.namePrefix ?? defaultNamePrefix
+    });
+}
+function validateAnthropicToolUse(toolUse) {
+    if (!isRecord(toolUse)) {
+        return "Anthropic Claude tool_use must be an object.";
+    }
+    if (toolUse.type !== undefined && toolUse.type !== "tool_use") {
+        return "Anthropic Claude tool_use type must be tool_use when present.";
+    }
+    if (typeof toolUse.name !== "string" || toolUse.name.length === 0) {
+        return "Anthropic Claude tool_use name is required.";
+    }
+    if (!isRecord(toolUse.input)) {
+        return "Anthropic Claude tool_use input must be a JSON object.";
+    }
+    return null;
+}

package/dist/cli.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+interface WritableLike {
+    write(message: string): unknown;
+}
+export interface CliRunOptions {
+    stderr?: WritableLike;
+    stdout?: WritableLike;
+}
+export declare function runCli(argv: string[], options?: CliRunOptions): Promise<number>;
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAkBA,UAAU,YAAY;IACpB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;CACjC;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB;AA4BD,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,CAqIzF"}

package/dist/cli.js

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { buildAiSdkTools } from "./ai-sdk.js";
+import { buildAnthropicClaudeTools } from "./anthropic-claude.js";
+import { decideCapability } from "./decision.js";
+import { formatEvalSuiteResult, loadEvalResults, runEvalSuite } from "./eval-runner.js";
+import { buildGeminiFunctionDeclarations } from "./gemini.js";
+import { buildLangChainToolDescriptors } from "./langchain.js";
+import { loadManifests } from "./loader.js";
+import { buildMcpToolDescriptors } from "./mcp.js";
+import { buildOpenAIResponsesTools } from "./openai-responses.js";
+import { buildRegistry, formatInspection, inspectRegistry } from "./registry.js";
+import { buildSemanticKernelFunctions } from "./semantic-kernel.js";
+import { validateManifests } from "./validator.js";
+const adapterCommands = new Set([
+    "ai-sdk-tools",
+    "anthropic-tools",
+    "gemini-tools",
+    "langchain-tools",
+    "mcp-tools",
+    "openai-tools",
+    "semantic-kernel-functions"
+]);
+export async function runCli(argv, options = {}) {
+    const stdout = options.stdout ?? process.stdout;
+    const stderr = options.stderr ?? process.stderr;
+    const [command] = argv;
+    if (!command || command === "help" || command === "--help" || command === "-h") {
+        stdout.write(helpText());
+        return command ? 0 : 1;
+    }
+    if (command !== "validate" && command !== "inspect" && command !== "decide" && command !== "eval" && !adapterCommands.has(command)) {
+        stderr.write(`Unknown command "${command}".\n\n${helpText()}`);
+        return 1;
+    }
+    const parsedArgs = parseCommandArgs(argv.slice(1));
+    if (parsedArgs.error) {
+        stderr.write(`${parsedArgs.error}\n\n${helpText()}`);
+        return 1;
+    }
+    const targetPath = parsedArgs.targetPath ?? "examples";
+    const loadResult = await loadManifests({ path: targetPath });
+    const validation = validateManifests(loadResult.manifests);
+    const errors = [...loadResult.errors, ...validation.errors];
+    if (errors.length > 0) {
+        stderr.write(formatDiagnostics(errors));
+        return 1;
+    }
+    const registry = buildRegistry(loadResult.manifests);
+    if (command === "validate") {
+        stdout.write(`Validated ${loadResult.manifests.length} manifest(s).\n`);
+        return 0;
+    }
+    if (command === "decide") {
+        if (!parsedArgs.requestPath) {
+            stderr.write("Missing required --request <decision.json>.\n");
+            return 1;
+        }
+        const request = await readDecisionRequest(parsedArgs.requestPath);
+        if (!request.ok) {
+            stderr.write(`${request.error}\n`);
+            return 1;
+        }
+        const requestError = validateDecisionRequestShape(request.value);
+        if (requestError) {
+            stderr.write(`${requestError}\n`);
+            return 1;
+        }
+        if (!registry.capabilityById.has(request.value.capabilityId)) {
+            stderr.write(`Unknown capability id "${request.value.capabilityId}".\n`);
+            return 1;
+        }
+        stdout.write(`${JSON.stringify(decideCapability(registry, request.value), null, 2)}\n`);
+        return 0;
+    }
+    if (adapterCommands.has(command)) {
+        if (!parsedArgs.contextPath) {
+            stderr.write("Missing required --context <context.json>.\n");
+            return 1;
+        }
+        const context = await readToolContext(parsedArgs.contextPath);
+        if (!context.ok) {
+            stderr.write(`${context.error}\n`);
+            return 1;
+        }
+        const contextError = validateToolContextShape(context.value, adapterLabel(command));
+        if (contextError) {
+            stderr.write(`${contextError}\n`);
+            return 1;
+        }
+        const toolset = buildAdapterCliToolset(command, registry, {
+            context: context.value,
+            includeRestricted: parsedArgs.includeRestricted
+        });
+        const fatalDiagnostics = toolset.diagnostics.filter((diagnostic) => diagnostic.code === "tool_name_collision");
+        if (fatalDiagnostics.length > 0) {
+            stderr.write(formatDiagnostics(fatalDiagnostics));
+            return 1;
+        }
+        stdout.write(`${JSON.stringify(toolset, null, 2)}\n`);
+        if (adapterExportedCount(toolset) === 0) {
+            stderr.write(`No ${adapterLabel(command)} tools were exportable.\n`);
+            return 1;
+        }
+        return 0;
+    }
+    if (command === "eval") {
+        if (!parsedArgs.resultsPath) {
+            stderr.write("Missing required --results <results.json>.\n");
+            return 1;
+        }
+        if (parsedArgs.format !== "text" && parsedArgs.format !== "json") {
+            stderr.write("Eval format must be text or json.\n");
+            return 1;
+        }
+        const evalResults = await loadEvalResults(parsedArgs.resultsPath);
+        if (evalResults.errors.length > 0) {
+            stderr.write(formatDiagnostics(evalResults.errors));
+            return 1;
+        }
+        const suite = runEvalSuite(registry, evalResults.results);
+        if (parsedArgs.format === "json") {
+            stdout.write(`${JSON.stringify(suite, null, 2)}\n`);
+        }
+        else {
+            stdout.write(formatEvalSuiteResult(suite));
+        }
+        return suite.passed ? 0 : 1;
+    }
+    stdout.write(formatInspection(inspectRegistry(registry)));
+    return 0;
+}
+function helpText() {
+    return [
+        "Usage: aicf <command> [path]",
+        "",
+        "Commands:",
+        "  decide <path> --request <file>  Evaluate a decision request.",
+        "  eval <path> --results <file> [--format text|json]  Run deterministic evals.",
+        "  ai-sdk-tools <path> --context <file>  Export Vercel AI SDK tool descriptors.",
+        "  anthropic-tools <path> --context <file>  Export Anthropic Claude tool definitions.",
+        "  gemini-tools <path> --context <file>  Export Gemini function declarations.",
+        "  langchain-tools <path> --context <file>  Export LangChain/LangGraph tool descriptors.",
+        "  mcp-tools <path> --context <file>  Export Model Context Protocol tool descriptors.",
+        "  openai-tools <path> --context <file>  Export OpenAI Responses function tools.",
+        "  semantic-kernel-functions <path> --context <file>  Export Semantic Kernel function metadata.",
+        "  validate [path]  Validate AICF manifests. Defaults to examples.",
+        "  inspect [path]   Print a registry summary. Defaults to examples.",
+        ""
+    ].join("\n");
+}
+function parseCommandArgs(args) {
+    let contextPath;
+    let format = "text";
+    let includeRestricted = false;
+    let requestPath;
+    let resultsPath;
+    let targetPath;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--request") {
+            const nextArg = args[index + 1];
+            if (!nextArg) {
+                return { error: "Missing value for --request." };
+            }
+            requestPath = nextArg;
+            index += 1;
+            continue;
+        }
+        if (arg === "--results") {
+            const nextArg = args[index + 1];
+            if (!nextArg) {
+                return { error: "Missing value for --results." };
+            }
+            resultsPath = nextArg;
+            index += 1;
+            continue;
+        }
+        if (arg === "--format") {
+            const nextArg = args[index + 1];
+            if (!nextArg) {
+                return { error: "Missing value for --format." };
+            }
+            format = nextArg;
+            index += 1;
+            continue;
+        }
+        if (arg === "--context") {
+            const nextArg = args[index + 1];
+            if (!nextArg) {
+                return { error: "Missing value for --context." };
+            }
+            contextPath = nextArg;
+            index += 1;
+            continue;
+        }
+        if (arg === "--include-restricted") {
+            includeRestricted = true;
+            continue;
+        }
+        if (arg?.startsWith("--")) {
+            return { error: `Unknown option "${arg}".` };
+        }
+        if (targetPath) {
+            return { error: `Unexpected argument "${arg}".` };
+        }
+        targetPath = arg;
+    }
+    return {
+        contextPath,
+        format,
+        includeRestricted,
+        requestPath,
+        resultsPath,
+        targetPath
+    };
+}
+async function readDecisionRequest(filePath) {
+    try {
+        const content = await readFile(filePath, "utf8");
+        return {
+            ok: true,
+            value: JSON.parse(content)
+        };
+    }
+    catch (error) {
+        return {
+            error: error instanceof Error ? error.message : "Unable to read decision request.",
+            ok: false
+        };
+    }
+}
+async function readToolContext(filePath) {
+    try {
+        const content = await readFile(filePath, "utf8");
+        return {
+            ok: true,
+            value: JSON.parse(content)
+        };
+    }
+    catch (error) {
+        return {
+            error: error instanceof Error ? error.message : "Unable to read tool context.",
+            ok: false
+        };
+    }
+}
+function validateDecisionRequestShape(value) {
+    if (typeof value !== "object" || value === null) {
+        return "Decision request must be a JSON object.";
+    }
+    if (typeof value.capabilityId !== "string" || value.capabilityId.length === 0) {
+        return "Decision request requires capabilityId.";
+    }
+    if (value.operation !== "select" && value.operation !== "prepare" && value.operation !== "commit") {
+        return "Decision request operation must be select, prepare, or commit.";
+    }
+    if (typeof value.context !== "object" || value.context === null) {
+        return "Decision request requires context.";
+    }
+    if (!Array.isArray(value.context.permissions) || value.context.permissions.some((permission) => typeof permission !== "string")) {
+        return "Decision request context.permissions must be an array of strings.";
+    }
+    if (!["A0", "A1", "A2", "A3", "A4", "A5"].includes(value.context.autonomyTier)) {
+        return "Decision request context.autonomyTier must be A0, A1, A2, A3, A4, or A5.";
+    }
+    return null;
+}
+function validateToolContextShape(value, label) {
+    if (typeof value !== "object" || value === null) {
+        return `${label} tool context must be a JSON object.`;
+    }
+    if (!Array.isArray(value.permissions) || value.permissions.some((permission) => typeof permission !== "string")) {
+        return `${label} tool context.permissions must be an array of strings.`;
+    }
+    if (!["A0", "A1", "A2", "A3", "A4", "A5"].includes(value.autonomyTier)) {
+        return `${label} tool context.autonomyTier must be A0, A1, A2, A3, A4, or A5.`;
+    }
+    if (value.userId !== undefined && typeof value.userId !== "string") {
+        return `${label} tool context.userId must be a string when present.`;
+    }
+    if (value.tenantId !== undefined && typeof value.tenantId !== "string") {
+        return `${label} tool context.tenantId must be a string when present.`;
+    }
+    return null;
+}
+function buildAdapterCliToolset(command, registry, options) {
+    switch (command) {
+        case "ai-sdk-tools":
+            return buildAiSdkTools(registry, options);
+        case "anthropic-tools":
+            return buildAnthropicClaudeTools(registry, options);
+        case "gemini-tools":
+            return buildGeminiFunctionDeclarations(registry, options);
+        case "langchain-tools":
+            return buildLangChainToolDescriptors(registry, options);
+        case "mcp-tools":
+            return buildMcpToolDescriptors(registry, options);
+        case "semantic-kernel-functions":
+            return buildSemanticKernelFunctions(registry, options);
+        case "openai-tools":
+            return buildOpenAIResponsesTools(registry, options);
+    }
+}
+function adapterExportedCount(toolset) {
+    if (Array.isArray(toolset.tools)) {
+        return toolset.tools.length;
+    }
+    if (toolset.tools && typeof toolset.tools === "object") {
+        return Object.keys(toolset.tools).length;
+    }
+    if (toolset.functionDeclarations) {
+        return toolset.functionDeclarations.length;
+    }
+    if (toolset.functions) {
+        return toolset.functions.length;
+    }
+    return 0;
+}
+function adapterLabel(command) {
+    switch (command) {
+        case "ai-sdk-tools":
+            return "AI SDK";
+        case "anthropic-tools":
+            return "Anthropic Claude";
+        case "gemini-tools":
+            return "Gemini";
+        case "langchain-tools":
+            return "LangChain";
+        case "mcp-tools":
+            return "MCP";
+        case "openai-tools":
+            return "OpenAI";
+        case "semantic-kernel-functions":
+            return "Semantic Kernel";
+    }
+}
+function formatDiagnostics(errors) {
+    return errors
+        .map((error) => {
+        const kind = error.kind ? ` ${error.kind}` : "";
+        const id = error.id ? ` ${error.id}` : "";
+        return `${error.path}:${kind}${id}: ${error.message}`;
+    })
+        .join("\n")
+        .concat("\n");
+}
+if (isDirectCliRun()) {
+    const exitCode = await runCli(process.argv.slice(2));
+    process.exitCode = exitCode;
+}
+function isDirectCliRun() {
+    const invokedPath = process.argv[1];
+    if (!invokedPath) {
+        return false;
+    }
+    return path.resolve(invokedPath) === fileURLToPath(import.meta.url);
+}

package/dist/decision.d.ts

@@ -0,0 +1,6 @@
+import type { CapabilityManifest } from "./generated/manifest-types.js";
+import type { DecisionRequest, DecisionResult, LifecycleEvaluation, LoadedCapabilityManifest, ManifestRegistry, PolicyEvaluation } from "./types.js";
+export declare function decideCapability(registry: ManifestRegistry, request: DecisionRequest): DecisionResult;
+export declare function evaluatePolicy(capability: LoadedCapabilityManifest | CapabilityManifest, request: DecisionRequest): PolicyEvaluation;
+export declare function evaluateLifecycle(capability: LoadedCapabilityManifest | CapabilityManifest, request: DecisionRequest): LifecycleEvaluation;
+//# sourceMappingURL=decision.d.ts.map

package/dist/decision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decision.d.ts","sourceRoot":"","sources":["../src/decision.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,KAAK,EAIV,eAAe,EACf,cAAc,EAEd,mBAAmB,EACnB,wBAAwB,EACxB,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAWpB,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE,eAAe,GACvB,cAAc,CAuBhB;AAED,wBAAgB,cAAc,CAC5B,UAAU,EAAE,wBAAwB,GAAG,kBAAkB,EACzD,OAAO,EAAE,eAAe,GACvB,gBAAgB,CAsGlB;AAED,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,wBAAwB,GAAG,kBAAkB,EACzD,OAAO,EAAE,eAAe,GACvB,mBAAmB,CA6BrB"}

package/dist/decision.js

@@ -0,0 +1,237 @@
+const autonomyRank = {
+    A0: 0,
+    A1: 1,
+    A2: 2,
+    A3: 3,
+    A4: 4,
+    A5: 5
+};
+export function decideCapability(registry, request) {
+    const loadedCapability = registry.capabilityById.get(request.capabilityId);
+    if (!loadedCapability) {
+        const reasons = [{
+                code: "capability_not_found",
+                message: `Capability "${request.capabilityId}" was not found.`
+            }];
+        return buildDecisionResult(request, "denied", {
+            reasons,
+            requiredApprovals: [],
+            status: "denied"
+        }, {
+            reasons: [],
+            status: "allowed"
+        });
+    }
+    const policy = evaluatePolicy(loadedCapability, request);
+    const lifecycle = evaluateLifecycle(loadedCapability, request);
+    const status = combineStatuses(policy.status, lifecycle.status);
+    return buildDecisionResult(request, status, policy, lifecycle);
+}
+export function evaluatePolicy(capability, request) {
+    const manifest = unwrapCapability(capability);
+    const reasons = [];
+    const requiredApprovals = [];
+    for (const permission of manifest.authorization.permissions) {
+        if (!request.context.permissions.includes(permission)) {
+            reasons.push({
+                code: "missing_permission",
+                message: `Missing required permission "${permission}".`
+            });
+        }
+    }
+    const maxAutonomyTier = manifest.policy.max_autonomy_tier ?? manifest.autonomy_tier;
+    if (autonomyRank[request.context.autonomyTier] > autonomyRank[manifest.autonomy_tier]) {
+        reasons.push({
+            code: "autonomy_exceeded",
+            message: `Request autonomy tier ${request.context.autonomyTier} exceeds capability tier ${manifest.autonomy_tier}.`
+        });
+    }
+    if (autonomyRank[request.context.autonomyTier] > autonomyRank[maxAutonomyTier]) {
+        reasons.push({
+            code: "autonomy_exceeded",
+            message: `Request autonomy tier ${request.context.autonomyTier} exceeds policy max tier ${maxAutonomyTier}.`
+        });
+    }
+    if (request.operation !== "select") {
+        for (const rule of manifest.policy.deny_if ?? []) {
+            const fact = readFact(request.facts?.[rule.rule]);
+            if (!fact.known) {
+                reasons.push({
+                    code: "missing_fact",
+                    message: `Deny rule "${rule.rule}" could not be evaluated and failed closed.`,
+                    rule: rule.rule
+                });
+                continue;
+            }
+            if (fact.value) {
+                reasons.push({
+                    code: "deny_rule_matched",
+                    message: fact.reason ?? rule.reason,
+                    rule: rule.rule
+                });
+            }
+        }
+        for (const rule of manifest.policy.approval_required_if ?? []) {
+            if (doesRuleMatch(rule, request.args ?? {})) {
+                const approvalReason = {
+                    code: "approval_required",
+                    message: rule.reason,
+                    rule: rule.rule
+                };
+                if (request.operation === "commit" && !isApproved(request)) {
+                    reasons.push(approvalReason);
+                }
+                else {
+                    requiredApprovals.push(approvalReason);
+                }
+            }
+        }
+    }
+    if (request.operation === "commit" && manifest.policy.approval_required && !isApproved(request)) {
+        reasons.push({
+            code: "approval_required",
+            message: "Capability commit requires approval."
+        });
+    }
+    if (request.operation === "commit" && manifest.idempotency?.required && !request.idempotencyKey) {
+        reasons.push({
+            code: "idempotency_required",
+            message: "Capability commit requires an idempotency key."
+        });
+    }
+    if (reasons.length > 0) {
+        return {
+            reasons,
+            requiredApprovals,
+            status: "denied"
+        };
+    }
+    if (requiredApprovals.length > 0 && !isApproved(request)) {
+        return {
+            reasons,
+            requiredApprovals,
+            status: "approval_required"
+        };
+    }
+    return {
+        reasons,
+        requiredApprovals,
+        status: "allowed"
+    };
+}
+export function evaluateLifecycle(capability, request) {
+    const manifest = unwrapCapability(capability);
+    const reasons = [];
+    if (request.operation === "select") {
+        return {
+            reasons,
+            status: "allowed"
+        };
+    }
+    if (request.operation === "prepare" && !manifest.lifecycle.prepare) {
+        reasons.push({
+            code: "lifecycle_not_supported",
+            message: `Capability "${manifest.id}" does not support prepare.`
+        });
+    }
+    if (request.operation === "commit" && !manifest.lifecycle.commit) {
+        reasons.push({
+            code: "lifecycle_not_supported",
+            message: `Capability "${manifest.id}" does not support commit.`
+        });
+    }
+    return {
+        reasons,
+        status: reasons.length > 0 ? "denied" : "allowed"
+    };
+}
+function buildDecisionResult(request, status, policy, lifecycle) {
+    const reasons = [...policy.reasons, ...policy.requiredApprovals, ...lifecycle.reasons];
+    const audit = {
+        capabilityId: request.capabilityId,
+        operation: request.operation,
+        reasons,
+        status
+    };
+    if (request.idempotencyKey) {
+        audit.idempotencyKey = request.idempotencyKey;
+    }
+    return {
+        audit,
+        capabilityId: request.capabilityId,
+        diagnostics: [],
+        lifecycle,
+        operation: request.operation,
+        policy,
+        reasons,
+        requiredApprovals: policy.requiredApprovals,
+        status
+    };
+}
+function combineStatuses(...statuses) {
+    if (statuses.includes("denied"))
+        return "denied";
+    if (statuses.includes("approval_required"))
+        return "approval_required";
+    return "allowed";
+}
+function unwrapCapability(capability) {
+    return "manifest" in capability ? capability.manifest : capability;
+}
+function readFact(fact) {
+    if (typeof fact === "boolean") {
+        return {
+            known: true,
+            value: fact
+        };
+    }
+    if (typeof fact === "object" && fact !== null) {
+        return {
+            known: true,
+            reason: fact.reason,
+            value: fact.value
+        };
+    }
+    return {
+        known: false,
+        value: false
+    };
+}
+function doesRuleMatch(rule, args) {
+    if (!rule.field || !rule.operator) {
+        return false;
+    }
+    const value = getFieldValue(rule.field, args);
+    switch (rule.operator) {
+        case "eq":
+            return value === rule.value;
+        case "neq":
+            return value !== rule.value;
+        case "gt":
+            return typeof value === "number" && typeof rule.value === "number" && value > rule.value;
+        case "gte":
+            return typeof value === "number" && typeof rule.value === "number" && value >= rule.value;
+        case "lt":
+            return typeof value === "number" && typeof rule.value === "number" && value < rule.value;
+        case "lte":
+            return typeof value === "number" && typeof rule.value === "number" && value <= rule.value;
+        case "in":
+            return Array.isArray(rule.value) && rule.value.includes(value);
+        case "not_in":
+            return Array.isArray(rule.value) && !rule.value.includes(value);
+        case "exists":
+            return value !== undefined;
+    }
+}
+function getFieldValue(field, args) {
+    const normalizedField = field.startsWith("args.") ? field.slice("args.".length) : field;
+    return normalizedField.split(".").reduce((current, segment) => {
+        if (typeof current !== "object" || current === null) {
+            return undefined;
+        }
+        return current[segment];
+    }, args);
+}
+function isApproved(request) {
+    return request.approval?.approved === true && Boolean(request.approval.approvalId);
+}

package/dist/eval-runner.d.ts

@@ -0,0 +1,6 @@
+import type { EvalCandidateResult, EvalCase, EvalCaseResult, EvalSuiteResult, LoadedEvalCase, LoadEvalResultsResult, ManifestRegistry, RunEvalSuiteOptions } from "./types.js";
+export declare function loadEvalResults(resultPath: string): Promise<LoadEvalResultsResult>;
+export declare function runEvalSuite(registry: ManifestRegistry, candidates: EvalCandidateResult[], options?: RunEvalSuiteOptions): EvalSuiteResult;
+export declare function scoreEvalCase(evalCase: LoadedEvalCase | EvalCase, candidate: EvalCandidateResult, registry: ManifestRegistry): EvalCaseResult;
+export declare function formatEvalSuiteResult(result: EvalSuiteResult): string;
+//# sourceMappingURL=eval-runner.d.ts.map