ai-capability-framework 1.0.0-rc.1

package/conformance/valid/evals/conformance.note.get.valid.yaml

@@ -0,0 +1,33 @@
+schema_version: "1.0"
+id: conformance.note.get.valid
+name: Read a conformance note
+capability_under_test: conformance.note.get
+tags:
+  - conformance
+  - tool_selection
+input:
+  user_message: Read conformance note NOTE-1001.
+context:
+  request_context:
+    environment: test
+    user:
+      id: user_example_conformance
+      roles:
+        - reader
+      permissions:
+        - note.read
+      tenant_id: tenant_example
+    autonomy_tier: A1
+expected:
+  selected_capabilities:
+    includes:
+      - conformance.note.get
+  tool_calls:
+    - capability_id: conformance.note.get
+      args_match:
+        note_id: NOTE-1001
+  no_commit: true
+scorers:
+  - type: tool_selection_includes
+  - type: tool_input_json_subset
+  - type: no_unapproved_commit

package/conformance/valid/openai/context.no_permissions.json

@@ -0,0 +1,6 @@
+{
+  "autonomyTier": "A1",
+  "permissions": [],
+  "tenantId": "tenant_example",
+  "userId": "user_example_conformance"
+}

package/dist/adapter-common.d.ts

@@ -0,0 +1,62 @@
+import type { AdapterExcludedCapability, AdapterToolBinding, AicfDiagnostic, CapabilityManifest, DecisionRequest, JsonObject, LoadedCapabilityManifest, ManifestRegistry, ParseAdapterToolCallResult } from "./types.js";
+export declare const strictToolSchemaUnsupportedKeywords: string[];
+export interface BuildAdapterToolsetOptions<TTool, TBinding extends AdapterToolBinding = AdapterToolBinding> {
+    adapterName: string;
+    buildTool(input: {
+        loadedCapability: LoadedCapabilityManifest;
+        normalizedInputSchema: JsonObject;
+        restricted: boolean;
+        toolName: string;
+    }): TTool;
+    context: DecisionRequest["context"];
+    defaultNamePrefix: string;
+    includeRestricted?: boolean;
+    maxToolNameLength?: number;
+    namePrefix?: string;
+    toBinding?(binding: AdapterToolBinding, input: {
+        loadedCapability: LoadedCapabilityManifest;
+        normalizedInputSchema: JsonObject;
+        restricted: boolean;
+        toolName: string;
+    }): TBinding;
+    registry: ManifestRegistry;
+    unsupportedSchemaKeywords?: string[];
+}
+export interface BuiltAdapterToolset<TTool, TBinding extends AdapterToolBinding = AdapterToolBinding> {
+    bindings: TBinding[];
+    diagnostics: AicfDiagnostic[];
+    excluded: AdapterExcludedCapability[];
+    tools: TTool[];
+}
+export declare function buildAdapterToolset<TTool, TBinding extends AdapterToolBinding = AdapterToolBinding>(options: BuildAdapterToolsetOptions<TTool, TBinding>): BuiltAdapterToolset<TTool, TBinding>;
+export declare function selectContextForCapability(capability: CapabilityManifest, context: DecisionRequest["context"]): DecisionRequest["context"];
+export declare function isRestrictedCapability(capability: CapabilityManifest): boolean;
+export declare function adapterToolDescription(capability: CapabilityManifest): string;
+export declare function toAdapterToolName(capabilityId: string, options: {
+    maxLength?: number;
+    namePrefix: string;
+}): string;
+export declare function normalizeInputSchemaForStrictTool(loadedCapability: LoadedCapabilityManifest, options?: {
+    unsupportedSchemaKeywords?: string[];
+}): {
+    diagnostics: AicfDiagnostic[];
+    ok: false;
+} | {
+    diagnostics: AicfDiagnostic[];
+    ok: true;
+    schema: JsonObject;
+};
+export declare function parseAdapterToolCall(input: {
+    argumentsPath: string;
+    bindings: AdapterToolBinding[];
+    callId?: string;
+    id?: string;
+    rawArguments: unknown;
+    rawArgumentsAreJsonString?: boolean;
+    toolName: string;
+    toolNamePath: string;
+}): ParseAdapterToolCallResult;
+export declare function validateAdapterContext(context: DecisionRequest["context"], adapterName: string): string | null;
+export declare function toJsonObject(value: unknown): JsonObject;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+//# sourceMappingURL=adapter-common.d.ts.map

package/dist/adapter-common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-common.d.ts","sourceRoot":"","sources":["../src/adapter-common.ts"],"names":[],"mappings":"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"}

package/dist/adapter-common.js

@@ -0,0 +1,453 @@
+import { createHash } from "node:crypto";
+import Ajv2020 from "ajv/dist/2020.js";
+import { decideCapability } from "./decision.js";
+const hashLength = 8;
+const ajv = new Ajv2020({ allErrors: true, strict: false });
+const autonomyRank = {
+    A0: 0,
+    A1: 1,
+    A2: 2,
+    A3: 3,
+    A4: 4,
+    A5: 5
+};
+export const strictToolSchemaUnsupportedKeywords = [
+    "$ref",
+    "allOf",
+    "anyOf",
+    "dependencies",
+    "dependentRequired",
+    "dependentSchemas",
+    "if",
+    "not",
+    "oneOf",
+    "patternProperties",
+    "prefixItems",
+    "then",
+    "unevaluatedProperties"
+];
+export function buildAdapterToolset(options) {
+    const contextError = validateAdapterContext(options.context, options.adapterName);
+    if (contextError) {
+        return {
+            bindings: [],
+            diagnostics: [{
+                    code: "invalid_context",
+                    message: contextError,
+                    path: "options.context"
+                }],
+            excluded: [],
+            tools: []
+        };
+    }
+    const diagnostics = [];
+    const excluded = [];
+    const bindings = [];
+    const tools = [];
+    const toolNameOwners = new Map();
+    for (const loadedCapability of options.registry.capabilities) {
+        const capability = loadedCapability.manifest;
+        const restricted = isRestrictedCapability(capability);
+        if (restricted && !options.includeRestricted) {
+            const capabilityDiagnostics = [{
+                    code: "capability_excluded",
+                    details: {
+                        restricted: true
+                    },
+                    id: capability.id,
+                    kind: "capability",
+                    message: `Capability "${capability.id}" is restricted and was not exported to ${options.adapterName} tools.`,
+                    path: loadedCapability.path
+                }];
+            diagnostics.push(...capabilityDiagnostics);
+            excluded.push({
+                capabilityId: capability.id,
+                diagnostics: capabilityDiagnostics,
+                path: loadedCapability.path,
+                reason: "restricted"
+            });
+            continue;
+        }
+        const selectDecision = decideCapability(options.registry, {
+            capabilityId: capability.id,
+            context: selectContextForCapability(capability, options.context),
+            operation: "select"
+        });
+        if (selectDecision.status !== "allowed") {
+            const capabilityDiagnostics = decisionDiagnostics(loadedCapability, selectDecision.reasons, options.adapterName);
+            diagnostics.push(...capabilityDiagnostics);
+            excluded.push({
+                capabilityId: capability.id,
+                diagnostics: capabilityDiagnostics,
+                path: loadedCapability.path,
+                reason: "decision_denied"
+            });
+            continue;
+        }
+        const normalizedSchema = normalizeInputSchemaForStrictTool(loadedCapability, {
+            unsupportedSchemaKeywords: options.unsupportedSchemaKeywords
+        });
+        if (!normalizedSchema.ok) {
+            diagnostics.push(...normalizedSchema.diagnostics);
+            excluded.push({
+                capabilityId: capability.id,
+                diagnostics: normalizedSchema.diagnostics,
+                path: loadedCapability.path,
+                reason: "unsupported_schema"
+            });
+            continue;
+        }
+        const toolName = toAdapterToolName(capability.id, {
+            maxLength: options.maxToolNameLength,
+            namePrefix: options.namePrefix ?? options.defaultNamePrefix
+        });
+        const existingOwner = toolNameOwners.get(toolName);
+        if (existingOwner && existingOwner !== capability.id) {
+            const collisionDiagnostics = [{
+                    code: "tool_name_collision",
+                    details: {
+                        existingCapabilityId: existingOwner,
+                        toolName
+                    },
+                    id: capability.id,
+                    kind: "capability",
+                    message: `${options.adapterName} tool name "${toolName}" collides with capability "${existingOwner}".`,
+                    path: loadedCapability.path
+                }];
+            diagnostics.push(...collisionDiagnostics);
+            excluded.push({
+                capabilityId: capability.id,
+                diagnostics: collisionDiagnostics,
+                path: loadedCapability.path,
+                reason: "tool_name_collision"
+            });
+            continue;
+        }
+        toolNameOwners.set(toolName, capability.id);
+        const binding = baseBinding(loadedCapability, {
+            normalizedInputSchema: normalizedSchema.schema,
+            restricted,
+            toolName
+        });
+        const input = {
+            loadedCapability,
+            normalizedInputSchema: normalizedSchema.schema,
+            restricted,
+            toolName
+        };
+        tools.push(options.buildTool(input));
+        bindings.push(options.toBinding ? options.toBinding(binding, input) : binding);
+    }
+    return {
+        bindings,
+        diagnostics,
+        excluded,
+        tools
+    };
+}
+export function selectContextForCapability(capability, context) {
+    if (autonomyRank[context.autonomyTier] <= autonomyRank[capability.autonomy_tier]) {
+        return context;
+    }
+    return {
+        ...context,
+        autonomyTier: capability.autonomy_tier
+    };
+}
+export function isRestrictedCapability(capability) {
+    return capability.lifecycle.commit
+        || capability.capability_type === "write_commit"
+        || capability.capability_type === "external_message_send"
+        || capability.capability_type === "workflow_start"
+        || capability.side_effects.charges_money
+        || capability.side_effects.refunds_money
+        || capability.side_effects.changes_permissions
+        || capability.side_effects.triggers_external_workflow
+        || capability.side_effects.irreversible
+        || capability.side_effects.sends_external_messages;
+}
+export function adapterToolDescription(capability) {
+    const lifecycle = Object.entries(capability.lifecycle)
+        .filter(([, enabled]) => enabled)
+        .map(([name]) => name)
+        .join(", ") || "none";
+    const whenToUse = (capability.when_to_use ?? []).join(" ");
+    const whenNotToUse = (capability.when_not_to_use ?? []).join(" ");
+    return [
+        capability.model_description.trim(),
+        `Capability ID: ${capability.id}.`,
+        `Type: ${capability.capability_type}. Risk: ${capability.risk_tier}. Autonomy: ${capability.autonomy_tier}. Lifecycle: ${lifecycle}.`,
+        whenToUse ? `Use when: ${whenToUse}` : "",
+        whenNotToUse ? `Do not use when: ${whenNotToUse}` : ""
+    ].filter(Boolean).join(" ");
+}
+export function toAdapterToolName(capabilityId, options) {
+    const maxLength = options.maxLength ?? 64;
+    const sanitizedPrefix = sanitizeToolNamePart(options.namePrefix);
+    const sanitizedId = sanitizeToolNamePart(capabilityId);
+    const baseName = `${sanitizedPrefix}${sanitizedId}`;
+    if (baseName.length <= maxLength) {
+        return baseName;
+    }
+    const hash = createHash("sha256").update(capabilityId).digest("hex").slice(0, hashLength);
+    const prefixLength = maxLength - hash.length - 1;
+    return `${baseName.slice(0, prefixLength)}_${hash}`;
+}
+export function normalizeInputSchemaForStrictTool(loadedCapability, options = {}) {
+    const schema = loadedCapability.manifest.input_schema;
+    if (!isRecord(schema)) {
+        return unsupportedSchema(loadedCapability, "/", "Input schema must be a JSON object.");
+    }
+    const normalized = normalizeSchemaObject(loadedCapability, schema, "/", false, options);
+    if (!normalized.ok) {
+        return normalized;
+    }
+    const types = schemaTypes(normalized.schema.type);
+    if (!types.includes("object")) {
+        return unsupportedSchema(loadedCapability, "/", "Tool parameters must be an object schema.");
+    }
+    return normalized;
+}
+export function parseAdapterToolCall(input) {
+    const binding = input.bindings.find((candidate) => candidate.toolName === input.toolName);
+    if (!binding) {
+        return {
+            diagnostics: [{
+                    code: "invalid_tool_call",
+                    details: {
+                        toolName: input.toolName
+                    },
+                    message: `Unknown tool name "${input.toolName}".`,
+                    path: input.toolNamePath
+                }],
+            valid: false
+        };
+    }
+    let args = input.rawArguments;
+    if (input.rawArgumentsAreJsonString) {
+        if (typeof input.rawArguments !== "string") {
+            return invalidToolCall(binding, input.argumentsPath, "Tool call arguments must be a JSON string.");
+        }
+        try {
+            args = JSON.parse(input.rawArguments);
+        }
+        catch (error) {
+            return {
+                diagnostics: [{
+                        code: "invalid_tool_call",
+                        details: error instanceof Error ? error.message : undefined,
+                        id: binding.capabilityId,
+                        message: `Tool call arguments for "${input.toolName}" are not valid JSON.`,
+                        path: input.argumentsPath
+                    }],
+                valid: false
+            };
+        }
+    }
+    if (!isRecord(args)) {
+        return invalidToolCall(binding, input.argumentsPath, `Tool call arguments for "${input.toolName}" must be a JSON object.`);
+    }
+    const validate = ajv.compile(binding.inputSchema);
+    const valid = validate(args);
+    if (!valid) {
+        return {
+            diagnostics: (validate.errors ?? []).map((error) => ({
+                code: "schema",
+                details: error,
+                id: binding.capabilityId,
+                message: `${error.instancePath || "/"}: ${error.message ?? "schema validation failed"}`,
+                path: input.argumentsPath
+            })),
+            valid: false
+        };
+    }
+    return {
+        diagnostics: [],
+        parsed: {
+            args,
+            callId: input.callId,
+            capabilityId: binding.capabilityId,
+            id: input.id,
+            toolName: binding.toolName
+        },
+        valid: true
+    };
+}
+export function validateAdapterContext(context, adapterName) {
+    if (!isRecord(context)) {
+        return `${adapterName} tool export requires a context object.`;
+    }
+    if (!Array.isArray(context.permissions) || context.permissions.some((permission) => typeof permission !== "string")) {
+        return `${adapterName} tool export context.permissions must be an array of strings.`;
+    }
+    if (!["A0", "A1", "A2", "A3", "A4", "A5"].includes(context.autonomyTier)) {
+        return `${adapterName} tool export context.autonomyTier must be A0, A1, A2, A3, A4, or A5.`;
+    }
+    if (context.userId !== undefined && typeof context.userId !== "string") {
+        return `${adapterName} tool export context.userId must be a string when present.`;
+    }
+    if (context.tenantId !== undefined && typeof context.tenantId !== "string") {
+        return `${adapterName} tool export context.tenantId must be a string when present.`;
+    }
+    return null;
+}
+export function toJsonObject(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function baseBinding(loadedCapability, input) {
+    const capability = loadedCapability.manifest;
+    return {
+        autonomyTier: capability.autonomy_tier,
+        capabilityId: capability.id,
+        capabilityType: capability.capability_type,
+        inputSchema: toJsonObject(capability.input_schema),
+        normalizedInputSchema: input.normalizedInputSchema,
+        path: loadedCapability.path,
+        restricted: input.restricted,
+        riskTier: capability.risk_tier,
+        toolName: input.toolName
+    };
+}
+function decisionDiagnostics(loadedCapability, reasons, adapterName) {
+    if (reasons.length === 0) {
+        return [{
+                code: "capability_excluded",
+                id: loadedCapability.manifest.id,
+                kind: "capability",
+                message: `Capability "${loadedCapability.manifest.id}" was not selectable and was not exported to ${adapterName} tools.`,
+                path: loadedCapability.path
+            }];
+    }
+    return reasons.map((reason) => ({
+        code: "capability_excluded",
+        details: reason,
+        id: loadedCapability.manifest.id,
+        kind: "capability",
+        message: `Capability "${loadedCapability.manifest.id}" was not exported: ${reason.message}`,
+        path: loadedCapability.path
+    }));
+}
+function normalizeSchemaObject(loadedCapability, schema, pointer, optional, options) {
+    const unsupportedKeywords = options.unsupportedSchemaKeywords ?? strictToolSchemaUnsupportedKeywords;
+    for (const keyword of unsupportedKeywords) {
+        if (keyword in schema) {
+            return unsupportedSchema(loadedCapability, pointer, `Input schema uses unsupported keyword "${keyword}" for strict tool export.`);
+        }
+    }
+    const normalized = toJsonObject(schema);
+    const types = schemaTypes(schema.type);
+    if (types.includes("object")) {
+        const properties = schema.properties;
+        const required = schema.required;
+        if (properties !== undefined && !isRecord(properties)) {
+            return unsupportedSchema(loadedCapability, `${pointer}/properties`, "Schema properties must be an object.");
+        }
+        if (required !== undefined && !isStringArray(required)) {
+            return unsupportedSchema(loadedCapability, `${pointer}/required`, "Schema required fields must be a string array.");
+        }
+        const propertySchemas = properties ?? {};
+        const requiredFields = new Set(required ?? []);
+        const normalizedProperties = {};
+        for (const [propertyName, propertySchema] of Object.entries(propertySchemas)) {
+            if (!isRecord(propertySchema)) {
+                return unsupportedSchema(loadedCapability, `${pointer}/properties/${propertyName}`, `Property "${propertyName}" must be a schema object.`);
+            }
+            const propertyResult = normalizeSchemaObject(loadedCapability, propertySchema, `${pointer}/properties/${propertyName}`, !requiredFields.has(propertyName), options);
+            if (!propertyResult.ok) {
+                return propertyResult;
+            }
+            normalizedProperties[propertyName] = propertyResult.schema;
+        }
+        normalized.properties = normalizedProperties;
+        normalized.required = Object.keys(normalizedProperties);
+        normalized.additionalProperties = false;
+    }
+    if (types.includes("array")) {
+        const items = schema.items;
+        if (items !== undefined) {
+            if (!isRecord(items)) {
+                return unsupportedSchema(loadedCapability, `${pointer}/items`, "Array items must be a single schema object.");
+            }
+            const itemResult = normalizeSchemaObject(loadedCapability, items, `${pointer}/items`, false, options);
+            if (!itemResult.ok) {
+                return itemResult;
+            }
+            normalized.items = itemResult.schema;
+        }
+    }
+    if (optional) {
+        const nullable = makeNullable(normalized);
+        if (!nullable.ok) {
+            return unsupportedSchema(loadedCapability, pointer, "Optional schema could not be represented as nullable for strict tool export.");
+        }
+    }
+    return {
+        diagnostics: [],
+        ok: true,
+        schema: normalized
+    };
+}
+function makeNullable(schema) {
+    const type = schema.type;
+    if (typeof type === "string") {
+        schema.type = type === "null" ? "null" : [type, "null"];
+    }
+    else if (Array.isArray(type) && type.every((entry) => typeof entry === "string")) {
+        if (!type.includes("null")) {
+            schema.type = [...type, "null"];
+        }
+    }
+    else if (!("enum" in schema)) {
+        return { ok: false };
+    }
+    const enumValue = schema.enum;
+    if (Array.isArray(enumValue) && !enumValue.includes(null)) {
+        schema.enum = [...enumValue, null];
+    }
+    return { ok: true };
+}
+function unsupportedSchema(loadedCapability, pointer, message) {
+    return {
+        diagnostics: [{
+                code: "unsupported",
+                details: {
+                    pointer
+                },
+                id: loadedCapability.manifest.id,
+                kind: "capability",
+                message,
+                path: loadedCapability.path
+            }],
+        ok: false
+    };
+}
+function invalidToolCall(binding, path, message) {
+    return {
+        diagnostics: [{
+                code: "invalid_tool_call",
+                id: binding.capabilityId,
+                message,
+                path
+            }],
+        valid: false
+    };
+}
+function sanitizeToolNamePart(value) {
+    const sanitized = value.replace(/[^A-Za-z0-9_-]/g, "_");
+    return sanitized.length > 0 ? sanitized : "_";
+}
+function schemaTypes(value) {
+    if (typeof value === "string") {
+        return [value];
+    }
+    if (Array.isArray(value) && value.every((entry) => typeof entry === "string")) {
+        return value;
+    }
+    return [];
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}

package/dist/ai-sdk.d.ts

@@ -0,0 +1,5 @@
+import type { AiSdkToolCall, AiSdkToolNameOptions, AiSdkToolset, BuildAiSdkToolsOptions, ManifestRegistry, ParseAiSdkToolCallResult } from "./types.js";
+export declare function buildAiSdkTools(registry: ManifestRegistry, options: BuildAiSdkToolsOptions): AiSdkToolset;
+export declare function parseAiSdkToolCall(toolset: AiSdkToolset, call: AiSdkToolCall): ParseAiSdkToolCallResult;
+export declare function toAiSdkToolName(capabilityId: string, options?: AiSdkToolNameOptions): string;
+//# sourceMappingURL=ai-sdk.d.ts.map

package/dist/ai-sdk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-sdk.d.ts","sourceRoot":"","sources":["../src/ai-sdk.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAEV,aAAa,EACb,oBAAoB,EACpB,YAAY,EACZ,sBAAsB,EACtB,gBAAgB,EAChB,wBAAwB,EACzB,MAAM,YAAY,CAAC;AAKpB,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE,sBAAsB,GAC9B,YAAY,CA8Bd;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,YAAY,EACrB,IAAI,EAAE,aAAa,GAClB,wBAAwB,CAqB1B;AAED,wBAAgB,eAAe,CAC7B,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,oBAAyB,GACjC,MAAM,CAKR"}

package/dist/ai-sdk.js

@@ -0,0 +1,71 @@
+import { adapterToolDescription, buildAdapterToolset, isRecord, parseAdapterToolCall, toAdapterToolName } from "./adapter-common.js";
+const defaultNamePrefix = "aicf_";
+const maxToolNameLength = 64;
+export function buildAiSdkTools(registry, options) {
+    const built = buildAdapterToolset({
+        adapterName: "Vercel AI SDK",
+        buildTool: ({ loadedCapability, normalizedInputSchema }) => ({
+            description: adapterToolDescription(loadedCapability.manifest),
+            inputSchema: normalizedInputSchema,
+            strict: true
+        }),
+        context: options.context,
+        defaultNamePrefix,
+        includeRestricted: options.includeRestricted,
+        maxToolNameLength,
+        namePrefix: options.namePrefix,
+        registry
+    });
+    const tools = {};
+    for (const [index, binding] of built.bindings.entries()) {
+        const tool = built.tools[index];
+        if (tool) {
+            tools[binding.toolName] = tool;
+        }
+    }
+    return {
+        bindings: built.bindings,
+        diagnostics: built.diagnostics,
+        excluded: built.excluded,
+        tools
+    };
+}
+export function parseAiSdkToolCall(toolset, call) {
+    const shapeError = validateAiSdkToolCall(call);
+    if (shapeError) {
+        return {
+            diagnostics: [{
+                    code: "invalid_tool_call",
+                    message: shapeError,
+                    path: "toolCall"
+                }],
+            valid: false
+        };
+    }
+    return parseAdapterToolCall({
+        argumentsPath: call.input !== undefined ? "toolCall.input" : "toolCall.args",
+        bindings: toolset.bindings,
+        callId: call.toolCallId,
+        rawArguments: call.input ?? call.args,
+        toolName: call.toolName,
+        toolNamePath: "toolCall.toolName"
+    });
+}
+export function toAiSdkToolName(capabilityId, options = {}) {
+    return toAdapterToolName(capabilityId, {
+        maxLength: maxToolNameLength,
+        namePrefix: options.namePrefix ?? defaultNamePrefix
+    });
+}
+function validateAiSdkToolCall(call) {
+    if (!isRecord(call)) {
+        return "AI SDK tool call must be an object.";
+    }
+    if (typeof call.toolName !== "string" || call.toolName.length === 0) {
+        return "AI SDK tool call toolName is required.";
+    }
+    if (!isRecord(call.input ?? call.args)) {
+        return "AI SDK tool call input or args must be a JSON object.";
+    }
+    return null;
+}

package/dist/anthropic-claude.d.ts

@@ -0,0 +1,5 @@
+import type { AnthropicClaudeToolNameOptions, AnthropicClaudeToolset, AnthropicClaudeToolUse, BuildAnthropicClaudeToolsOptions, ManifestRegistry, ParseAnthropicClaudeToolUseResult } from "./types.js";
+export declare function buildAnthropicClaudeTools(registry: ManifestRegistry, options: BuildAnthropicClaudeToolsOptions): AnthropicClaudeToolset;
+export declare function parseAnthropicClaudeToolUse(toolset: AnthropicClaudeToolset, toolUse: AnthropicClaudeToolUse): ParseAnthropicClaudeToolUseResult;
+export declare function toAnthropicClaudeToolName(capabilityId: string, options?: AnthropicClaudeToolNameOptions): string;
+//# sourceMappingURL=anthropic-claude.d.ts.map

package/dist/anthropic-claude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic-claude.d.ts","sourceRoot":"","sources":["../src/anthropic-claude.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAEV,8BAA8B,EAC9B,sBAAsB,EACtB,sBAAsB,EACtB,gCAAgC,EAChC,gBAAgB,EAChB,iCAAiC,EAClC,MAAM,YAAY,CAAC;AAKpB,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE,gCAAgC,GACxC,sBAAsB,CAgBxB;AAED,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,sBAAsB,EAC/B,OAAO,EAAE,sBAAsB,GAC9B,iCAAiC,CAqBnC;AAED,wBAAgB,yBAAyB,CACvC,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,8BAAmC,GAC3C,MAAM,CAKR"}