@vibesdotdev/tools 0.0.0-stage → 1.0.0-rc.4

package/dist/agents/schemas/types.js

@@ -0,0 +1,3 @@
+// Re-export shim — moved to @vibesdotdev/ai-schemas (contract floor).
+export * from '@vibesdotdev/ai-schemas/agents/schemas/types';
+//# sourceMappingURL=types.js.map

package/dist/agents/schemas/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/agents/schemas/types.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,cAAc,8CAA8C,CAAC"}

package/dist/agents/storage.d.ts

@@ -0,0 +1,20 @@
+import type { KindContext } from '@vibesdotdev/kernel/schemas/kind';
+import type { StorageManifestDescriptor } from '@vibesdotdev/storage/schemas/manifest-descriptor';
+import type { AIAgentInstanceDescriptor } from './schemas/index.ts';
+import type { AgentConfigurations } from './agents.storage.schema.ts';
+export declare class AIAgentsStorage {
+    private readonly manifest;
+    constructor(descriptor: StorageManifestDescriptor | string, context: KindContext);
+    load(): Promise<AgentConfigurations | null>;
+    save(data: AgentConfigurations): Promise<void>;
+    private loadInstances;
+    getEnabled(): Promise<AIAgentInstanceDescriptor[]>;
+    getByType(agentType: string): Promise<AIAgentInstanceDescriptor[]>;
+    getById(id: string): Promise<AIAgentInstanceDescriptor | null>;
+    getDefault(): Promise<AIAgentInstanceDescriptor | null>;
+    add(agent: AIAgentInstanceDescriptor): Promise<void>;
+    updateAgent(id: string, updates: Partial<AIAgentInstanceDescriptor>): Promise<void>;
+    remove(id: string): Promise<void>;
+    setDefault(id: string): Promise<void>;
+}
+//# sourceMappingURL=storage.d.ts.map

package/dist/agents/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../src/agents/storage.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,kDAAkD,CAAC;AAClG,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAuC;gBAIpD,UAAU,EAAE,yBAAyB,GAAG,MAAM,EAAE,OAAO,EAAE,WAAW;IAI1E,IAAI,IAAI,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;IAI3C,IAAI,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;YAItC,aAAa;IAIrB,UAAU,IAAI,OAAO,CAAC,yBAAyB,EAAE,CAAC;IAKlD,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,yBAAyB,EAAE,CAAC;IAKlE,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,yBAAyB,GAAG,IAAI,CAAC;IAK9D,UAAU,IAAI,OAAO,CAAC,yBAAyB,GAAG,IAAI,CAAC;IAKvD,GAAG,CAAC,KAAK,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;IAIpD,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,yBAAyB,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAMnF,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMjC,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAQ5C"}

package/dist/agents/storage.js

@@ -0,0 +1,53 @@
+// Runtime-first storage access for tools.agents manifest. Delegates to
+// `@vibesdotdev/storage`'s StorageManifest base, which performs lazy descriptor
+// resolution and load/save/update against the bound adapter.
+import { StorageManifest } from '@vibesdotdev/storage';
+export class AIAgentsStorage {
+    manifest;
+    // Constructed by the `storage/manifest` kind with its runtime's context: a
+    // manifest resolves only against the runtime that constructs it.
+    constructor(descriptor, context) {
+        this.manifest = new StorageManifest(descriptor, context);
+    }
+    async load() {
+        return this.manifest.load();
+    }
+    async save(data) {
+        return this.manifest.save(data);
+    }
+    async loadInstances() {
+        return (await this.manifest.load()) ?? [];
+    }
+    async getEnabled() {
+        const instances = await this.loadInstances();
+        return instances.filter((agent) => agent.enabled !== false);
+    }
+    async getByType(agentType) {
+        const instances = await this.loadInstances();
+        return instances.filter((agent) => agent.agentType === agentType && agent.enabled !== false);
+    }
+    async getById(id) {
+        const instances = await this.loadInstances();
+        return instances.find((agent) => agent.id === id) ?? null;
+    }
+    async getDefault() {
+        const instances = await this.loadInstances();
+        return instances.find((agent) => agent.isDefault && agent.enabled !== false) ?? null;
+    }
+    async add(agent) {
+        await this.manifest.update((current) => [...(current ?? []), agent]);
+    }
+    async updateAgent(id, updates) {
+        await this.manifest.update((current) => (current ?? []).map((agent) => (agent.id === id ? { ...agent, ...updates } : agent)));
+    }
+    async remove(id) {
+        await this.manifest.update((current) => (current ?? []).filter((agent) => agent.id !== id));
+    }
+    async setDefault(id) {
+        await this.manifest.update((current) => (current ?? []).map((agent) => ({
+            ...agent,
+            isDefault: agent.id === id
+        })));
+    }
+}
+//# sourceMappingURL=storage.js.map

package/dist/agents/storage.js.map

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

package/dist/agents/tool-policy.d.ts

@@ -0,0 +1,22 @@
+import type { AgentToolPolicy as RequestToolPolicy } from '@vibesdotdev/ai-schemas/generation/contracts';
+/**
+ * The policy a run applies to an agent's tools: the request's `only` / `add` / `remove`
+ * (`AgentToolPolicySchema`), or the agent-execution tool's form, `toolIds` with
+ * `inheritAgentTools` (false replaces the agent's tools, otherwise they extend them).
+ */
+export type AgentToolPolicy = RequestToolPolicy & {
+    toolIds?: string[];
+    inheritAgentTools?: boolean;
+};
+export type ResolveEffectiveToolIdsInput = {
+    agentToolIds: string[];
+    agentType?: string | null;
+    requestToolPolicy?: AgentToolPolicy;
+};
+/**
+ * The tools an agent runs with: `only` (else the agent's own), plus `add`, minus `remove` (last,
+ * so a removed tool is gone whatever added it). A chat agent whose tools were not replaced also
+ * gets `generate-image`, unless it is removed.
+ */
+export declare function resolveEffectiveToolIds({ agentToolIds, agentType, requestToolPolicy }: ResolveEffectiveToolIdsInput): string[];
+//# sourceMappingURL=tool-policy.d.ts.map

package/dist/agents/tool-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-policy.d.ts","sourceRoot":"","sources":["../../src/agents/tool-policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,IAAI,iBAAiB,EAAE,MAAM,8CAA8C,CAAC;AAEzG;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,iBAAiB,GAAG;IACjD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IAC1C,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,iBAAiB,CAAC,EAAE,eAAe,CAAC;CACpC,CAAC;AAcF;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,EACvC,YAAY,EACZ,SAAS,EACT,iBAAiB,EACjB,EAAE,4BAA4B,GAAG,MAAM,EAAE,CAWzC"}

package/dist/agents/tool-policy.js

@@ -0,0 +1,30 @@
+function uniqueNonEmpty(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        const trimmed = value.trim();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        result.push(trimmed);
+    }
+    return result;
+}
+/**
+ * The tools an agent runs with: `only` (else the agent's own), plus `add`, minus `remove` (last,
+ * so a removed tool is gone whatever added it). A chat agent whose tools were not replaced also
+ * gets `generate-image`, unless it is removed.
+ */
+export function resolveEffectiveToolIds({ agentToolIds, agentType, requestToolPolicy }) {
+    const policy = requestToolPolicy ?? {};
+    const legacy = Array.isArray(policy.toolIds) ? uniqueNonEmpty(policy.toolIds) : undefined;
+    const only = policy.only ?? (legacy && policy.inheritAgentTools === false ? legacy : undefined);
+    const add = [...(policy.add ?? []), ...(legacy && policy.inheritAgentTools !== false ? legacy : [])];
+    const removed = new Set(uniqueNonEmpty(policy.remove ?? []));
+    const base = only ? uniqueNonEmpty(only) : uniqueNonEmpty(agentToolIds);
+    const extended = uniqueNonEmpty([...base, ...add]);
+    if (agentType === 'chat' && !only && !extended.includes('generate-image'))
+        extended.push('generate-image');
+    return extended.filter((toolId) => !removed.has(toolId));
+}
+//# sourceMappingURL=tool-policy.js.map

package/dist/agents/tool-policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-policy.js","sourceRoot":"","sources":["../../src/agents/tool-policy.ts"],"names":[],"mappings":"AAkBA,SAAS,cAAc,CAAC,MAAgB;IACvC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC5B,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;QAC7B,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC;YAAE,SAAS;QAC5C,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAClB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACtB,CAAC;IACD,OAAO,MAAM,CAAC;AACf,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,uBAAuB,CAAC,EACvC,YAAY,EACZ,SAAS,EACT,iBAAiB,EACa;IAC9B,MAAM,MAAM,GAAG,iBAAiB,IAAI,EAAE,CAAC;IACvC,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC1F,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,iBAAiB,KAAK,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAChG,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,GAAG,CAAC,MAAM,IAAI,MAAM,CAAC,iBAAiB,KAAK,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACrG,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC;IAE7D,MAAM,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC;IACxE,MAAM,QAAQ,GAAG,cAAc,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC;IACnD,IAAI,SAAS,KAAK,MAAM,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,gBAAgB,CAAC;QAAE,QAAQ,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IAC3G,OAAO,QAAQ,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;AAC1D,CAAC"}

package/dist/agents/tool-provider-runtime.d.ts

@@ -0,0 +1,57 @@
+import { type VibesRuntime } from '@vibesdotdev/kernel';
+import type { ToolCallMetadata } from '@vibesdotdev/kernel/schemas/tool-call';
+import type { ToolProvider } from './contracts/tool-provider.ts';
+import type { AIAgentInstanceDescriptor } from '@vibesdotdev/ai-schemas/agents/schemas/descriptor';
+import { type OrgScopedToolTaggedItem, type OrgScopedToolSlugResolver, type OrgScopedToolVisibilityPrincipal } from '../schemas/access.ts';
+export { normalizeMcpDescription } from '../schemas/mcp-description.ts';
+/**
+ * Build the SYSTEM-tool-only base provider directly from the runtime's
+ * `tools/tool` registry — the same manifests/execute path every agent has
+ * always used. Exported so an app-local `context`/`toolProvider` loader
+ * (e.g. ai-web's) can compose it with app-specific tool sources (DB-backed
+ * custom/marketplace tools) WITHOUT calling `resolveRequestToolProvider`.
+ *
+ * CRITICAL: `resolveRequestToolProvider`'s first branch IS
+ * `runtime.context('toolProvider')` — i.e. exactly the loader this factory
+ * feeds. A `context('toolProvider')` implementation that called
+ * `resolveRequestToolProvider` internally to get its "system base" would
+ * recurse into itself forever (context → resolveRequestToolProvider →
+ * context → ...) on every single agent request. Always build the system
+ * base from this direct factory, never from `resolveRequestToolProvider`.
+ */
+export declare function createRuntimeToolProvider(runtime: VibesRuntime): ToolProvider;
+export interface ToolProviderVisibilityOptions {
+    orgScoped?: {
+        principal: OrgScopedToolVisibilityPrincipal | null | undefined;
+        resolveOrgIdBySlug: OrgScopedToolSlugResolver;
+    };
+}
+export interface ResolveRequestToolProviderOptions {
+    visibility?: ToolProviderVisibilityOptions;
+    resolveMissingToolProvider?: (missingIds: string[], baseProvider: ToolProvider) => ToolProvider | undefined | Promise<ToolProvider | undefined>;
+}
+export interface ToolProviderOptionsContext {
+    metadata?: ToolCallMetadata;
+}
+export declare function readToolProviderOptionsFromContext(ctx: ToolProviderOptionsContext | null | undefined): ResolveRequestToolProviderOptions | undefined;
+export declare function filterToolDescriptorsForVisibility<T extends OrgScopedToolTaggedItem>(items: readonly T[], visibility: ToolProviderVisibilityOptions | undefined): Promise<T[]>;
+/**
+ * ToolProvider that also reports which DECLARED tools could not be resolved.
+ * A declared tool is a contract (constitution rule 13): consumers must make
+ * a non-empty `missingToolIds` impossible for the agent to miss — the native
+ * tool loop injects it into the agent's system context so the model reports
+ * the breakage instead of silently working around it.
+ */
+export interface ScopedToolProvider extends ToolProvider {
+    missingToolIds: string[];
+}
+export declare function readMissingToolIds(provider: ToolProvider | undefined): string[];
+/**
+ * Scope a provider to the requested tools. A requested tool with no registered
+ * manifest lands in `missingToolIds` (never dropped silently); the caller
+ * surfaces it.
+ */
+export declare function createScopedToolProvider(baseProvider: ToolProvider, requestedToolIds: string[]): ScopedToolProvider;
+export declare function resolveRequestedToolIds(instance: AIAgentInstanceDescriptor | undefined, requestedToolIds?: string[]): string[];
+export declare function resolveRequestToolProvider(runtime: VibesRuntime, requestedToolIds?: string[], options?: ResolveRequestToolProviderOptions): Promise<ToolProvider | undefined>;
+//# sourceMappingURL=tool-provider-runtime.d.ts.map

package/dist/agents/tool-provider-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-provider-runtime.d.ts","sourceRoot":"","sources":["../../src/agents/tool-provider-runtime.ts"],"names":[],"mappings":"AACA,OAAO,EAKN,KAAK,YAAY,EACjB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uCAAuC,CAAC;AAG9E,OAAO,KAAK,EAAE,YAAY,EAAsC,MAAM,8BAA8B,CAAC;AACrG,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mDAAmD,CAAC;AASnG,OAAO,EAEN,KAAK,uBAAuB,EAC5B,KAAK,yBAAyB,EAC9B,KAAK,gCAAgC,EACrC,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAoFxE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,YAAY,GAAG,YAAY,CA4B7E;AAED,MAAM,WAAW,6BAA6B;IAC7C,SAAS,CAAC,EAAE;QACX,SAAS,EAAE,gCAAgC,GAAG,IAAI,GAAG,SAAS,CAAC;QAC/D,kBAAkB,EAAE,yBAAyB,CAAC;KAC9C,CAAC;CACF;AAED,MAAM,WAAW,iCAAiC;IACjD,UAAU,CAAC,EAAE,6BAA6B,CAAC;IAC3C,0BAA0B,CAAC,EAAE,CAC5B,UAAU,EAAE,MAAM,EAAE,EACpB,YAAY,EAAE,YAAY,KACtB,YAAY,GAAG,SAAS,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAAC;CAClE;AAED,MAAM,WAAW,0BAA0B;IAC1C,QAAQ,CAAC,EAAE,gBAAgB,CAAC;CAC5B;AA2BD,wBAAgB,kCAAkC,CACjD,GAAG,EAAE,0BAA0B,GAAG,IAAI,GAAG,SAAS,GAChD,iCAAiC,GAAG,SAAS,CAG/C;AAED,wBAAsB,kCAAkC,CAAC,CAAC,SAAS,uBAAuB,EACzF,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,UAAU,EAAE,6BAA6B,GAAG,SAAS,GACnD,OAAO,CAAC,CAAC,EAAE,CAAC,CAGd;AAwDD;;;;;;GAMG;AACH,MAAM,WAAW,kBAAmB,SAAQ,YAAY;IACvD,cAAc,EAAE,MAAM,EAAE,CAAC;CACzB;AAID,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,YAAY,GAAG,SAAS,GAAG,MAAM,EAAE,CAG/E;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,EAAE,GAAG,kBAAkB,CAmCnH;AAmDD,wBAAgB,uBAAuB,CACtC,QAAQ,EAAE,yBAAyB,GAAG,SAAS,EAC/C,gBAAgB,CAAC,EAAE,MAAM,EAAE,GACzB,MAAM,EAAE,CAKV;AAyDD,wBAAsB,0BAA0B,CAC/C,OAAO,EAAE,YAAY,EACrB,gBAAgB,GAAE,MAAM,EAAO,EAC/B,OAAO,GAAE,iCAAsC,GAC7C,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAqDnC"}

package/dist/agents/tool-provider-runtime.js

@@ -0,0 +1,404 @@
+import * as z from 'zod/v4';
+import { CapabilityError, CaughtFailureSchema, valueFreeFailure } from '@vibesdotdev/kernel';
+import { getLogger } from '@vibesdotdev/logging';
+import { toolManifestSchemasSchema } from '@vibesdotdev/ai-schemas/schemas/internal/manifest';
+import { createToolManifest } from "../manifest/factory.js";
+import { ToolSafetyCategorySchema } from '@vibesdotdev/ai-schemas/schemas/runtime/descriptors';
+import { invokeTool } from "../execution/invoke.js";
+import { ToolExecutionInputSchema } from "../kinds/schemas/tool.js";
+import { resolveToolName } from "./resolve-tool-name.js";
+import { filterOrgScopedToolDescriptors } from "../schemas/access.js";
+import { normalizeMcpDescription } from "../schemas/mcp-description.js";
+import { AGENT_TOOL_PROVIDER_CONTEXT_ID } from "./tool-provider.context.js";
+export { normalizeMcpDescription } from "../schemas/mcp-description.js";
+function providerLogger(runtime) {
+    return getLogger('tools:tool-provider', runtime);
+}
+function isManifestHardware(value) {
+    return value === 'consumer' || value === 'cloud';
+}
+/** A descriptor's safety, bare or with hints, reduced to the manifest's safety category. */
+const ManifestSafetySchema = z.union([
+    ToolSafetyCategorySchema,
+    z.object({ category: ToolSafetyCategorySchema }).transform((safety) => safety.category)
+]);
+function toManifestSafety(safety) {
+    const category = ManifestSafetySchema.safeParse(safety);
+    return category.success ? category.data : undefined;
+}
+const ToolTimeoutMsSchema = z.number().finite().positive();
+/** A per-call timeout the caller supplied in the call context, in whole milliseconds. */
+function readToolTimeoutMs(context) {
+    const timeoutMs = ToolTimeoutMsSchema.safeParse(context.timeoutMs);
+    return timeoutMs.success ? Math.floor(timeoutMs.data) : undefined;
+}
+/** The manifest options a runtime `tools/tool` descriptor declares; absent fields stay absent. */
+function manifestOptionsOf(descriptor) {
+    const hardware = (descriptor.hardware ?? []).filter(isManifestHardware);
+    const options = {
+        id: descriptor.id,
+        hardware: hardware.length > 0 ? hardware : ['consumer'],
+        purpose: descriptor.purpose && descriptor.purpose.length > 0 ? descriptor.purpose : ['agent'],
+        schemas: toolManifestSchemasSchema.parse(descriptor.schemas)
+    };
+    const mcpDescription = normalizeMcpDescription(descriptor.mcpDescription);
+    const safety = toManifestSafety(descriptor.safety);
+    if (descriptor.name)
+        options.name = descriptor.name;
+    if (descriptor.description)
+        options.description = descriptor.description;
+    if (mcpDescription)
+        options.mcpDescription = mcpDescription;
+    if (descriptor.category)
+        options.category = descriptor.category;
+    if (descriptor.subcategory)
+        options.subcategory = descriptor.subcategory;
+    if (descriptor.tags)
+        options.tags = [...descriptor.tags];
+    if (descriptor.permissions)
+        options.permissions = descriptor.permissions;
+    if (descriptor.requiresApproval !== undefined)
+        options.requiresApproval = descriptor.requiresApproval;
+    if (safety)
+        options.safety = safety;
+    if (descriptor.schemas?.actionSafety)
+        options.actionSafety = descriptor.schemas.actionSafety;
+    if (descriptor.examples)
+        options.examples = descriptor.examples;
+    return options;
+}
+function createRuntimeBackedManifest(runtime, descriptor) {
+    return createToolManifest(manifestOptionsOf(descriptor), async () => {
+        return async (context, input, options) => {
+            const ctx = {
+                callId: `tool_${globalThis.crypto.randomUUID()}`,
+                logger: getLogger(`ai:tool:${descriptor.id}`, runtime),
+                metadata: context,
+                signal: options?.signal
+            };
+            // invokeTool fires contextBuild/beforeExecute/afterExecute/error
+            // on the tools/tool hook bus and propagates subscriber-mutated
+            // recovery hints back onto thrown errors.
+            return invokeTool({
+                runtime,
+                toolId: descriptor.id,
+                input,
+                ctx,
+                timeoutMs: readToolTimeoutMs(context)
+            });
+        };
+    });
+}
+/** A tool the provider does not have, or does not offer for this request. */
+function toolUnavailable(toolId, reason, message) {
+    return new CapabilityError(message, 'NOT_FOUND', { reason, details: { toolId } });
+}
+/**
+ * Build the SYSTEM-tool-only base provider directly from the runtime's
+ * `tools/tool` registry — the same manifests/execute path every agent has
+ * always used. Exported so an app-local `context`/`toolProvider` loader
+ * (e.g. ai-web's) can compose it with app-specific tool sources (DB-backed
+ * custom/marketplace tools) WITHOUT calling `resolveRequestToolProvider`.
+ *
+ * CRITICAL: `resolveRequestToolProvider`'s first branch IS
+ * `runtime.context('toolProvider')` — i.e. exactly the loader this factory
+ * feeds. A `context('toolProvider')` implementation that called
+ * `resolveRequestToolProvider` internally to get its "system base" would
+ * recurse into itself forever (context → resolveRequestToolProvider →
+ * context → ...) on every single agent request. Always build the system
+ * base from this direct factory, never from `resolveRequestToolProvider`.
+ */
+export function createRuntimeToolProvider(runtime) {
+    const descriptors = runtime.query('tools/tool').enabled().descriptors();
+    const manifests = descriptors.map((descriptor) => createRuntimeBackedManifest(runtime, descriptor));
+    const manifestById = new Map(manifests.map((manifest) => [manifest.id, manifest]));
+    // Recover separator-mangled names (slash-for-dot etc.) emitted by some
+    // function-calling models before reporting the tool not found.
+    const resolve = (id) => resolveToolName(id, manifestById.keys()) ?? id;
+    return {
+        getManifests: () => manifests,
+        getManifest: (id) => manifestById.get(resolve(id)),
+        hasManifest: (id) => manifestById.has(resolve(id)),
+        async execute(toolId, input, contextOverrides, options) {
+            const manifest = manifestById.get(resolve(toolId));
+            if (!manifest) {
+                throw toolUnavailable(toolId, 'tool-not-found', `Tool "${toolId}" not found in runtime`);
+            }
+            const handler = await manifest.load();
+            const result = await handler({ ...contextOverrides }, ToolExecutionInputSchema.parse(input), options);
+            // SAFETY: the provider contract lets the caller name the tool's output type; the handler's
+            // result is that tool's output as its implementation returned it.
+            return result;
+        },
+        async load(toolId) {
+            const manifest = manifestById.get(resolve(toolId));
+            return manifest ? manifest.load() : undefined;
+        }
+    };
+}
+function isCallable(value) {
+    return typeof value === 'function';
+}
+function isPrincipalOrAbsent(value) {
+    return value === null || value === undefined || (typeof value === 'object' && !Array.isArray(value));
+}
+/** The tool-provider options a caller passes through a call context's metadata. */
+const ToolProviderOptionsSchema = z.looseObject({
+    visibility: z
+        .looseObject({
+        orgScoped: z
+            .looseObject({
+            principal: z.custom(isPrincipalOrAbsent),
+            resolveOrgIdBySlug: z.custom(isCallable)
+        })
+            .optional()
+    })
+        .optional(),
+    resolveMissingToolProvider: z
+        .custom(isCallable)
+        .optional()
+});
+export function readToolProviderOptionsFromContext(ctx) {
+    const parsed = ToolProviderOptionsSchema.safeParse(ctx?.metadata?.toolProviderOptions);
+    return parsed.success ? parsed.data : undefined;
+}
+export async function filterToolDescriptorsForVisibility(items, visibility) {
+    if (!visibility?.orgScoped)
+        return [...items];
+    return filterOrgScopedToolDescriptors(items, visibility.orgScoped.principal, visibility.orgScoped.resolveOrgIdBySlug);
+}
+async function applyToolProviderVisibility(baseProvider, visibility) {
+    if (!visibility?.orgScoped)
+        return baseProvider;
+    const visibleManifests = await filterToolDescriptorsForVisibility(baseProvider.getManifests(), visibility);
+    const manifestById = new Map(visibleManifests.map((manifest) => [manifest.id, manifest]));
+    const resolve = (id) => resolveToolName(id, manifestById.keys()) ?? id;
+    return {
+        getManifests: () => visibleManifests,
+        getManifest: (id) => manifestById.get(resolve(id)),
+        hasManifest: (id) => manifestById.has(resolve(id)),
+        execute: async (toolId, input, contextOverrides, options) => {
+            const resolvedId = resolve(toolId);
+            if (!manifestById.has(resolvedId)) {
+                throw toolUnavailable(toolId, 'tool-not-visible', `Tool "${toolId}" is not visible for this request`);
+            }
+            return baseProvider.execute(resolvedId, input, contextOverrides, options);
+        },
+        load(toolId) {
+            const resolvedId = resolve(toolId);
+            if (!manifestById.has(resolvedId))
+                return undefined;
+            return baseProvider.load(resolvedId);
+        }
+    };
+}
+const ToolProviderMethodsSchema = z.looseObject({
+    getManifests: z.custom(isCallable),
+    getManifest: z.custom(isCallable),
+    hasManifest: z.custom(isCallable),
+    execute: z.custom(isCallable),
+    load: z.custom(isCallable)
+});
+function isToolProvider(value) {
+    return ToolProviderMethodsSchema.safeParse(value).success;
+}
+/** Which provider methods a candidate implements, for the fallback diagnostic. */
+function describeToolProviderMethods(value) {
+    const declared = ToolProviderMethodsSchema.partial().safeParse(value);
+    const methods = declared.success ? declared.data : {};
+    return {
+        getManifests: methods.getManifests !== undefined,
+        getManifest: methods.getManifest !== undefined,
+        hasManifest: methods.hasManifest !== undefined,
+        execute: methods.execute !== undefined,
+        load: methods.load !== undefined
+    };
+}
+const MissingToolIdsSchema = z.looseObject({ missingToolIds: z.array(z.string()) });
+export function readMissingToolIds(provider) {
+    const scoped = MissingToolIdsSchema.safeParse(provider);
+    return scoped.success ? scoped.data.missingToolIds : [];
+}
+/**
+ * Scope a provider to the requested tools. A requested tool with no registered
+ * manifest lands in `missingToolIds` (never dropped silently); the caller
+ * surfaces it.
+ */
+export function createScopedToolProvider(baseProvider, requestedToolIds) {
+    const allowedIds = Array.from(new Set(requestedToolIds.filter((id) => id.length > 0)));
+    const allowedSet = new Set(allowedIds);
+    const missingToolIds = allowedIds.filter((id) => !baseProvider.getManifest(id));
+    const scopedManifests = allowedIds.flatMap((id) => {
+        const manifest = baseProvider.getManifest(id);
+        return manifest ? [manifest] : [];
+    });
+    const manifestById = new Map(scopedManifests.map((manifest) => [manifest.id, manifest]));
+    // Resolve a (possibly separator-mangled) requested name to an allowed id.
+    // Some function-calling models emit `casework/catalog.match` for the dotted
+    // id `casework.catalog.match`; recover from that without ever matching
+    // across genuinely different tools. Falls back to the raw name so the
+    // not-enabled / not-found paths still fire for truly unknown names.
+    const resolve = (toolId) => resolveToolName(toolId, allowedSet) ?? toolId;
+    return {
+        missingToolIds,
+        getManifests: () => scopedManifests,
+        getManifest: (id) => manifestById.get(resolve(id)),
+        hasManifest: (id) => manifestById.has(resolve(id)),
+        execute: (toolId, input, contextOverrides, options) => {
+            const resolvedId = resolve(toolId);
+            if (!allowedSet.has(resolvedId)) {
+                throw toolUnavailable(toolId, 'tool-not-enabled', `Tool "${toolId}" is not enabled for this request`);
+            }
+            return baseProvider.execute(resolvedId, input, contextOverrides, options);
+        },
+        load: (toolId) => {
+            const resolvedId = resolve(toolId);
+            if (!allowedSet.has(resolvedId))
+                return undefined;
+            return baseProvider.load(resolvedId);
+        }
+    };
+}
+function findMissingToolIds(baseProvider, requestedToolIds) {
+    const uniqueRequestedIds = Array.from(new Set(requestedToolIds.filter((toolId) => toolId.length > 0)));
+    return uniqueRequestedIds.filter((toolId) => !baseProvider.hasManifest(toolId));
+}
+/**
+ * The `tools.allowList` an agent instance's configuration declares. Every entry
+ * must be a tool id: a malformed declaration refuses instead of being read as
+ * "no restriction".
+ */
+const AllowListConfigurationSchema = z.looseObject({
+    tools: z.looseObject({ allowList: z.array(z.string().min(1)).optional() }).optional()
+});
+function readAllowList(instance) {
+    const configuration = AllowListConfigurationSchema.safeParse(instance.configuration ?? {});
+    if (!configuration.success) {
+        throw new CapabilityError(`Agent "${instance.id}" declares a malformed tools.allowList; every entry must be a tool id`, 'INVALID_INPUT', {
+            reason: 'tool-allow-list-invalid',
+            details: {
+                agentId: instance.id,
+                paths: configuration.error.issues.map((issue) => issue.path.map(String).join('.'))
+            }
+        });
+    }
+    return configuration.data.tools?.allowList ?? [];
+}
+function readConfiguredToolIds(instance) {
+    if (!instance)
+        return [];
+    const boundToolIds = (instance.tools ?? [])
+        .filter((binding) => binding.enabled !== false)
+        .map((binding) => binding.toolId)
+        .filter((toolId) => toolId.length > 0);
+    const allowList = readAllowList(instance);
+    if (boundToolIds.length > 0 && allowList.length > 0) {
+        const allowed = new Set(allowList);
+        return boundToolIds.filter((toolId) => allowed.has(toolId));
+    }
+    if (boundToolIds.length > 0)
+        return boundToolIds;
+    return allowList;
+}
+export function resolveRequestedToolIds(instance, requestedToolIds) {
+    if (requestedToolIds !== undefined) {
+        return Array.from(new Set(requestedToolIds.filter((toolId) => toolId.length > 0)));
+    }
+    return Array.from(new Set(readConfiguredToolIds(instance)));
+}
+async function contextToolProvider(runtime) {
+    let candidate;
+    try {
+        candidate = await runtime.context(AGENT_TOOL_PROVIDER_CONTEXT_ID);
+    }
+    catch (error) {
+        const unavailable = {
+            provider: null,
+            failure: valueFreeFailure(CaughtFailureSchema.parse(error))
+        };
+        return unavailable;
+    }
+    if (isToolProvider(candidate))
+        return { provider: candidate };
+    return { provider: null, methods: describeToolProviderMethods(candidate) };
+}
+function directToolProvider(runtime) {
+    try {
+        return { provider: createRuntimeToolProvider(runtime) };
+    }
+    catch (error) {
+        const failed = {
+            provider: null,
+            failure: valueFreeFailure(CaughtFailureSchema.parse(error))
+        };
+        return failed;
+    }
+}
+/** A provider with no tools: every requested tool lands in `missingToolIds`. */
+function unavailableToolProvider() {
+    return {
+        getManifests: () => [],
+        getManifest: () => undefined,
+        hasManifest: () => false,
+        execute: async (toolId) => {
+            throw toolUnavailable(toolId, 'tool-provider-unavailable', `Tool provider unavailable — cannot execute "${toolId}". Register tools/tool plugins in this app's vibes.config chain.`);
+        },
+        load: async () => undefined
+    };
+}
+export async function resolveRequestToolProvider(runtime, requestedToolIds = [], options = {}) {
+    const logger = providerLogger(runtime);
+    const fromContext = await contextToolProvider(runtime);
+    let baseProvider = fromContext.provider;
+    if (baseProvider) {
+        logger.debug('resolved tool provider from runtime context', { toolCount: baseProvider.getManifests().length });
+    }
+    else {
+        if ('failure' in fromContext) {
+            logger.debug('runtime context tool provider unavailable, falling back to the direct factory', {
+                failure: fromContext.failure
+            });
+        }
+        else if ('methods' in fromContext) {
+            logger.debug('runtime context tool provider did not satisfy the tool provider contract, falling back', {
+                methods: fromContext.methods
+            });
+        }
+        const direct = directToolProvider(runtime);
+        if (!direct.provider) {
+            // Constitution rule 13: when tools were requested, never return bare
+            // undefined (which consumers treat as "no tools intended"). Return an
+            // empty scoped provider so every requested id lands in missingToolIds
+            // and the agent loop injects a degraded notice.
+            logger.warn('failed to resolve the tools/tool provider from the direct factory', {
+                requestedToolIds,
+                failure: 'failure' in direct ? direct.failure : undefined
+            });
+            if (requestedToolIds.length === 0)
+                return undefined;
+            return createScopedToolProvider(unavailableToolProvider(), requestedToolIds);
+        }
+        baseProvider = direct.provider;
+        logger.debug('resolved tool provider from direct factory', { toolCount: baseProvider.getManifests().length });
+    }
+    baseProvider = await applyToolProviderVisibility(baseProvider, options.visibility);
+    if (requestedToolIds.length === 0)
+        return baseProvider;
+    const missingToolIds = findMissingToolIds(baseProvider, requestedToolIds);
+    if (missingToolIds.length > 0 && options.resolveMissingToolProvider) {
+        const enrichedProvider = await options.resolveMissingToolProvider(missingToolIds, baseProvider);
+        if (enrichedProvider)
+            baseProvider = await applyToolProviderVisibility(enrichedProvider, options.visibility);
+    }
+    const scoped = createScopedToolProvider(baseProvider, requestedToolIds);
+    if (scoped.missingToolIds.length > 0) {
+        // A tool the agent requested has no registered manifest in this runtime:
+        // the single highest-leverage signal for "wired in the agent's allowList
+        // but never registered in this app's vibes.config plugin chain".
+        logger.warn('requested tools have no registered manifest and were dropped from the tool set', {
+            missingToolIds: scoped.missingToolIds
+        });
+    }
+    return scoped;
+}
+//# sourceMappingURL=tool-provider-runtime.js.map