palpal-core 0.1.0

package/dist/src/safety.js

@@ -0,0 +1,348 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SafetyGate = exports.InMemoryPolicyStore = exports.ModelSafetyAgent = exports.SafetyAgent = void 0;
+exports.deriveAgentCapabilitySnapshot = deriveAgentCapabilitySnapshot;
+const errors_1 = require("./errors");
+class SafetyAgent {
+    evaluator;
+    constructor(evaluator) {
+        this.evaluator =
+            evaluator ??
+                (() => ({
+                    decision: "allow",
+                    reason: "default-allow",
+                    risk_level: 1
+                }));
+    }
+    static allowAll() {
+        return new SafetyAgent();
+    }
+    async evaluate(agent, request, policy) {
+        try {
+            const raw = await this.evaluator(agent, request, policy);
+            return normalizeDecision(raw, policy.name);
+        }
+        catch (error) {
+            throw new errors_1.AgentsError("AGENTS-E-GATE-EVAL", "SafetyAgent evaluation failed.", error);
+        }
+    }
+}
+exports.SafetyAgent = SafetyAgent;
+class ModelSafetyAgent {
+    model;
+    rubricLines;
+    name;
+    includeUserIntent;
+    constructor(options) {
+        (0, errors_1.ensure)(options?.model, "AGENTS-E-GATE-EVAL", "ModelSafetyAgent.model is required.");
+        const rubricLines = normalizeRubric(options.rubric);
+        (0, errors_1.ensure)(rubricLines.length > 0, "AGENTS-E-GATE-EVAL", "ModelSafetyAgent.rubric must include at least one rule.");
+        this.model = options.model;
+        this.rubricLines = rubricLines;
+        this.name = options.name?.trim() || "model-safety-agent";
+        this.includeUserIntent = options.includeUserIntent === true;
+    }
+    async evaluate(agent, request, policy) {
+        const capabilitySnapshot = request.capability_snapshot ?? deriveAgentCapabilitySnapshot(agent);
+        const toolCatalog = request.tool_catalog ?? capabilitySnapshot.tool_catalog;
+        const targetTool = request.target_tool ??
+            toolCatalog.find((tool) => tool.name === request.tool_name);
+        const prompt = buildModelSafetyPrompt({
+            rubricLines: this.rubricLines,
+            includeUserIntent: this.includeUserIntent,
+            policy,
+            request: {
+                ...request,
+                capability_snapshot: capabilitySnapshot,
+                tool_catalog: toolCatalog,
+                target_tool: targetTool
+            }
+        });
+        const safetyAgentLike = {
+            name: this.name,
+            instructions: [
+                "You are a safety evaluator for tool execution.",
+                "Return JSON only. Do not include markdown."
+            ].join(" "),
+            tools: []
+        };
+        const result = await this.model.generate({
+            agent: safetyAgentLike,
+            inputText: prompt,
+            toolCalls: [],
+            stream: false
+        });
+        const outputText = result.outputText?.trim() ?? "";
+        (0, errors_1.ensure)(outputText.length > 0, "AGENTS-E-GATE-EVAL", "ModelSafetyAgent returned empty output.");
+        const parsed = parseModelSafetyDecision(outputText);
+        return normalizeDecision(parsed, policy.name);
+    }
+}
+exports.ModelSafetyAgent = ModelSafetyAgent;
+class InMemoryPolicyStore {
+    profiles = new Map();
+    constructor() {
+        this.setProfile({
+            name: "strict",
+            approval_mode: "always",
+            allowed_tool_scopes: ["function", "skill", "mcp"]
+        });
+        this.setProfile({
+            name: "balanced",
+            approval_mode: "risk_based",
+            allowed_tool_scopes: ["function", "skill", "mcp"]
+        });
+        this.setProfile({
+            name: "fast",
+            approval_mode: "never",
+            allowed_tool_scopes: ["function", "skill", "mcp"]
+        });
+    }
+    getProfile(name) {
+        const profile = this.profiles.get(name);
+        (0, errors_1.ensure)(profile, "AGENTS-E-POLICY-INVALID", `Unknown policy profile: ${name}`);
+        return profile;
+    }
+    setProfile(profile) {
+        this.profiles.set(profile.name, profile);
+    }
+}
+exports.InMemoryPolicyStore = InMemoryPolicyStore;
+class SafetyGate {
+    safetyAgent;
+    policyStore;
+    constructor(safetyAgent, policyStore) {
+        this.safetyAgent = safetyAgent;
+        this.policyStore = policyStore ?? new InMemoryPolicyStore();
+    }
+    async evaluate(agent, request, context) {
+        const profile = this.policyStore.getProfile(context.policyProfile);
+        const capabilitySnapshot = deriveAgentCapabilitySnapshot(agent);
+        const targetTool = capabilitySnapshot.tool_catalog.find((tool) => tool.name === request.tool_name);
+        const enrichedRequest = {
+            ...request,
+            capability_snapshot: capabilitySnapshot,
+            tool_catalog: capabilitySnapshot.tool_catalog,
+            target_tool: targetTool
+        };
+        const rawDecision = await this.safetyAgent.evaluate(agent, enrichedRequest, profile);
+        validateSafetyDecision(rawDecision);
+        return {
+            decision: rawDecision.decision,
+            reason: rawDecision.reason,
+            risk_level: rawDecision.risk_level
+        };
+    }
+}
+exports.SafetyGate = SafetyGate;
+function deriveAgentCapabilitySnapshot(agent) {
+    (0, errors_1.ensure)(agent, "AGENTS-E-AGENT-CAPABILITY-RESOLVE", "Agent is required.");
+    (0, errors_1.ensure)(Array.isArray(agent.tools), "AGENTS-E-AGENT-CAPABILITY-RESOLVE", "Agent.tools must be an array.");
+    const toolNames = agent.tools.map((tool) => tool.name);
+    const skillIds = new Set();
+    const mcpCapabilities = [];
+    const toolCatalog = [];
+    for (const tool of agent.tools) {
+        if (!tool.name) {
+            throw new errors_1.AgentsError("AGENTS-E-AGENT-CAPABILITY-RESOLVE", "Agent has a tool without a name.");
+        }
+        if (tool.kind === "skill") {
+            const skillId = readString(tool, "skill_id") ?? readString(tool, "skillId");
+            if (skillId) {
+                skillIds.add(skillId);
+            }
+        }
+        if (tool.kind === "mcp") {
+            const capabilities = readCapabilities(tool);
+            if (capabilities.length === 0) {
+                mcpCapabilities.push({
+                    name: tool.name,
+                    description: tool.description,
+                    risk_level: 3
+                });
+            }
+            else {
+                mcpCapabilities.push(...capabilities);
+            }
+        }
+        toolCatalog.push(buildToolCapability(tool));
+    }
+    return {
+        agent_name: agent.name,
+        tool_names: toolNames,
+        skill_ids: [...skillIds],
+        mcp_capabilities: mcpCapabilities,
+        tool_catalog: toolCatalog
+    };
+}
+function validateSafetyDecision(decision) {
+    const allowed = new Set(["allow", "deny", "needs_human"]);
+    (0, errors_1.ensure)(decision, "AGENTS-E-GATE-EVAL", "SafetyAgent decision is missing.");
+    (0, errors_1.ensure)(allowed.has(decision.decision), "AGENTS-E-GATE-EVAL", "SafetyAgent decision.decision is invalid.", decision);
+    (0, errors_1.ensure)(Number.isInteger(decision.risk_level) && decision.risk_level >= 1 && decision.risk_level <= 5, "AGENTS-E-GATE-EVAL", "SafetyAgent decision.risk_level must be an integer between 1 and 5.", decision);
+    (0, errors_1.ensure)(typeof decision.reason === "string" && decision.reason.length > 0, "AGENTS-E-GATE-EVAL", "SafetyAgent decision.reason is required.", decision);
+    (0, errors_1.ensure)(typeof decision.policy_ref === "string" && decision.policy_ref.length > 0, "AGENTS-E-GATE-EVAL", "SafetyAgent decision.policy_ref is required.", decision);
+}
+function readString(tool, key) {
+    const value = tool.metadata?.[key];
+    if (typeof value === "string" && value.length > 0) {
+        return value;
+    }
+    return undefined;
+}
+function readCapabilities(tool) {
+    const value = tool.metadata?.capabilities;
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const list = [];
+    for (const item of value) {
+        if (!item || typeof item !== "object") {
+            continue;
+        }
+        const record = item;
+        if (typeof record.name === "string" &&
+            typeof record.description === "string" &&
+            typeof record.risk_level === "number") {
+            list.push({
+                name: record.name,
+                description: record.description,
+                risk_level: Math.max(1, Math.min(5, Math.floor(record.risk_level)))
+            });
+        }
+    }
+    return list;
+}
+function buildToolCapability(tool) {
+    const capability = {
+        name: tool.name,
+        kind: tool.kind,
+        description: tool.description,
+        parameters_schema: tool.parameters
+    };
+    if (tool.kind === "skill") {
+        const skillId = readString(tool, "skill_id") ?? readString(tool, "skillId");
+        const overview = readString(tool, "skill_overview");
+        const constraints = readStringArray(tool, "skill_constraints");
+        const tags = readStringArray(tool, "skill_tags");
+        capability.skill = {
+            skill_id: skillId,
+            overview,
+            constraints: constraints.length > 0 ? constraints : undefined,
+            tags: tags.length > 0 ? tags : undefined
+        };
+    }
+    if (tool.kind === "mcp") {
+        capability.mcp_capabilities = readCapabilities(tool);
+    }
+    return capability;
+}
+function readStringArray(tool, key) {
+    const value = tool.metadata?.[key];
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => typeof item === "string");
+}
+function normalizeDecision(decision, policyRefFallback) {
+    return {
+        decision: decision.decision,
+        reason: decision.reason,
+        risk_level: decision.risk_level,
+        policy_ref: decision.policy_ref ?? policyRefFallback
+    };
+}
+function normalizeRubric(rubric) {
+    if (typeof rubric === "string") {
+        return rubric
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+    }
+    if (!Array.isArray(rubric)) {
+        return [];
+    }
+    return rubric
+        .map((line) => (typeof line === "string" ? line.trim() : ""))
+        .filter((line) => line.length > 0);
+}
+function buildModelSafetyPrompt(params) {
+    const rubric = params.rubricLines.map((line, index) => `${index + 1}. ${line}`).join("\n");
+    const requestPayload = {
+        tool_name: params.request.tool_name,
+        tool_kind: params.request.tool_kind,
+        args: params.request.args
+    };
+    if (params.includeUserIntent) {
+        requestPayload.user_intent = params.request.user_intent;
+    }
+    const payload = {
+        policy: {
+            name: params.policy.name,
+            approval_mode: params.policy.approval_mode,
+            allowed_tool_scopes: params.policy.allowed_tool_scopes
+        },
+        request: requestPayload,
+        target_tool: params.request.target_tool ?? null,
+        tool_catalog: params.request.tool_catalog ?? [],
+        capability_snapshot: params.request.capability_snapshot ?? null
+    };
+    return [
+        "Evaluate whether the requested tool call should be allowed.",
+        "",
+        "Rubric:",
+        rubric,
+        "",
+        "Decision rules:",
+        "1) Return exactly one JSON object.",
+        "2) decision must be one of: allow, deny, needs_human.",
+        "3) risk_level must be integer 1..5.",
+        "4) reason must be concise and specific.",
+        "5) policy_ref must reference current policy name.",
+        "",
+        "Input:",
+        safeJson(payload),
+        "",
+        "Output schema:",
+        "{\"decision\":\"allow|deny|needs_human\",\"reason\":\"...\",\"risk_level\":1,\"policy_ref\":\"...\"}"
+    ].join("\n");
+}
+function parseModelSafetyDecision(outputText) {
+    const jsonText = extractJsonObject(outputText);
+    (0, errors_1.ensure)(jsonText.length > 0, "AGENTS-E-GATE-EVAL", "ModelSafetyAgent output does not contain a JSON object.");
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonText);
+    }
+    catch (error) {
+        throw new errors_1.AgentsError("AGENTS-E-GATE-EVAL", "ModelSafetyAgent returned invalid JSON.", error);
+    }
+    (0, errors_1.ensure)(parsed && typeof parsed === "object" && !Array.isArray(parsed), "AGENTS-E-GATE-EVAL", "ModelSafetyAgent output must be a JSON object.");
+    const record = parsed;
+    (0, errors_1.ensure)(typeof record.decision === "string", "AGENTS-E-GATE-EVAL", "ModelSafetyAgent decision.decision is required.");
+    (0, errors_1.ensure)(typeof record.reason === "string" && record.reason.length > 0, "AGENTS-E-GATE-EVAL", "ModelSafetyAgent decision.reason is required.");
+    (0, errors_1.ensure)(typeof record.risk_level === "number", "AGENTS-E-GATE-EVAL", "ModelSafetyAgent decision.risk_level is required.");
+    const policyRef = typeof record.policy_ref === "string" ? record.policy_ref : undefined;
+    return {
+        decision: record.decision,
+        reason: record.reason,
+        risk_level: Math.floor(record.risk_level),
+        policy_ref: policyRef
+    };
+}
+function extractJsonObject(text) {
+    const start = text.indexOf("{");
+    const end = text.lastIndexOf("}");
+    if (start < 0 || end < start) {
+        return "";
+    }
+    return text.slice(start, end + 1).trim();
+}
+function safeJson(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return "{\"error\":\"json_serialization_failed\"}";
+    }
+}

package/dist/src/skills.d.ts

@@ -0,0 +1,19 @@
+import { Skill, SkillManifest, SkillMode, SkillSummary, Tool } from "./types";
+export interface LoadSkillsOptions {
+    dir: string;
+    mode?: SkillMode;
+}
+export declare class SkillRegistry {
+    loadSkills(options: LoadSkillsOptions): Promise<Skill[]>;
+    toTools(skills: Skill[]): Tool[];
+}
+export declare class SkillMetadataExtractor {
+    listSkills(skills: Skill[]): Promise<SkillSummary[]>;
+    describeSkill(skills: Skill[], skillId: string, detailLevel?: "summary" | "full"): Promise<SkillManifest>;
+    toIntrospectionTools(skills: Skill[]): Tool[];
+}
+export declare function loadSkills(options: LoadSkillsOptions): Promise<Skill[]>;
+export declare function toTools(skills: Skill[]): Tool[];
+export declare function listSkills(skills: Skill[]): Promise<SkillSummary[]>;
+export declare function describeSkill(skills: Skill[], skillId: string, detailLevel?: "summary" | "full"): Promise<SkillManifest>;
+export declare function toIntrospectionTools(skills: Skill[]): Tool[];

package/dist/src/skills.js

@@ -0,0 +1,269 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillMetadataExtractor = exports.SkillRegistry = void 0;
+exports.loadSkills = loadSkills;
+exports.toTools = toTools;
+exports.listSkills = listSkills;
+exports.describeSkill = describeSkill;
+exports.toIntrospectionTools = toIntrospectionTools;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("./errors");
+const tools_1 = require("./tools");
+class SkillRegistry {
+    async loadSkills(options) {
+        (0, errors_1.ensure)(options?.dir, "AGENTS-E-SKILL-NOT-LOADED", "loadSkills requires dir.");
+        const mode = options.mode ?? "function_tool";
+        const stats = await node_fs_1.promises.stat(options.dir).catch(() => null);
+        (0, errors_1.ensure)(stats?.isDirectory(), "AGENTS-E-SKILL-NOT-LOADED", `Directory not found: ${options.dir}`);
+        const files = await findSkillFiles(options.dir);
+        const skills = [];
+        for (const filePath of files) {
+            const source = await node_fs_1.promises.readFile(filePath, "utf8");
+            skills.push(parseSkillFile(source, filePath, mode));
+        }
+        return skills;
+    }
+    toTools(skills) {
+        validateSkills(skills);
+        return skills.map((skill) => {
+            const name = `skill.${skill.descriptor.skill_id}`;
+            return {
+                name,
+                description: skill.manifest.overview,
+                kind: "skill",
+                parameters: skill.descriptor.input_schema,
+                metadata: {
+                    skill_id: skill.descriptor.skill_id,
+                    mode: skill.descriptor.mode,
+                    source_path: skill.source_path,
+                    skill_overview: skill.manifest.overview,
+                    skill_constraints: skill.manifest.constraints,
+                    skill_tags: skill.manifest.tags
+                },
+                execute: async (args) => ({
+                    skill_id: skill.descriptor.skill_id,
+                    mode: skill.descriptor.mode,
+                    args
+                })
+            };
+        });
+    }
+}
+exports.SkillRegistry = SkillRegistry;
+class SkillMetadataExtractor {
+    async listSkills(skills) {
+        validateSkills(skills);
+        return skills.map((skill) => ({
+            skill_id: skill.descriptor.skill_id,
+            name: skill.manifest.name,
+            overview: skill.manifest.overview,
+            tags: skill.manifest.tags
+        }));
+    }
+    async describeSkill(skills, skillId, detailLevel = "summary") {
+        validateSkills(skills);
+        const skill = skills.find((item) => item.descriptor.skill_id === skillId);
+        (0, errors_1.ensure)(skill, "AGENTS-E-SKILL-NOT-FOUND", `Skill not found: ${skillId}`);
+        if (detailLevel === "full") {
+            return skill.manifest;
+        }
+        return {
+            ...skill.manifest,
+            usage_examples: skill.manifest.usage_examples.slice(0, 1)
+        };
+    }
+    toIntrospectionTools(skills) {
+        validateSkills(skills);
+        return [
+            (0, tools_1.tool)({
+                name: "skill.list",
+                description: "List loaded skills with summary.",
+                execute: async () => this.listSkills(skills)
+            }),
+            (0, tools_1.tool)({
+                name: "skill.describe",
+                description: "Describe a skill in summary or full detail.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        skill_id: { type: "string" },
+                        detail_level: { type: "string", enum: ["summary", "full"] }
+                    },
+                    required: ["skill_id"]
+                },
+                execute: async (args) => {
+                    const skillId = typeof args.skill_id === "string" ? args.skill_id : "";
+                    const detail = args.detail_level === "full" || args.detail_level === "summary"
+                        ? args.detail_level
+                        : "summary";
+                    return this.describeSkill(skills, skillId, detail);
+                }
+            })
+        ];
+    }
+}
+exports.SkillMetadataExtractor = SkillMetadataExtractor;
+const defaultRegistry = new SkillRegistry();
+const defaultExtractor = new SkillMetadataExtractor();
+async function loadSkills(options) {
+    return defaultRegistry.loadSkills(options);
+}
+function toTools(skills) {
+    return defaultRegistry.toTools(skills);
+}
+async function listSkills(skills) {
+    return defaultExtractor.listSkills(skills);
+}
+async function describeSkill(skills, skillId, detailLevel = "summary") {
+    return defaultExtractor.describeSkill(skills, skillId, detailLevel);
+}
+function toIntrospectionTools(skills) {
+    return defaultExtractor.toIntrospectionTools(skills);
+}
+async function findSkillFiles(dir) {
+    const entries = await node_fs_1.promises.readdir(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = node_path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            const nested = await findSkillFiles(fullPath);
+            files.push(...nested);
+        }
+        else if (entry.isFile() && entry.name.toUpperCase() === "SKILL.MD") {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function parseSkillFile(source, sourcePath, mode) {
+    const heading = matchGroup(source, /^#\s+(.+)$/m) ?? node_path_1.default.basename(node_path_1.default.dirname(sourcePath));
+    const skillId = slugify(heading);
+    const tags = parseTags(source);
+    const overview = parseOverview(source) ?? `Skill loaded from ${sourcePath}`;
+    const constraints = parseConstraints(source);
+    const inputSchema = parseInputSchema(source);
+    const examples = parseExamples(source);
+    const descriptor = {
+        skill_id: skillId,
+        mode,
+        input_schema: inputSchema
+    };
+    const manifest = {
+        skill_id: skillId,
+        name: heading,
+        overview,
+        usage_examples: examples,
+        constraints,
+        tags,
+        input_schema: inputSchema
+    };
+    return {
+        descriptor,
+        manifest,
+        source_path: sourcePath
+    };
+}
+function parseOverview(source) {
+    const lines = source
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    for (const line of lines) {
+        if (line.startsWith("#") || line.startsWith("- ") || line.startsWith("```")) {
+            continue;
+        }
+        return line;
+    }
+    return undefined;
+}
+function parseTags(source) {
+    const raw = matchGroup(source, /tags?\s*:\s*(.+)$/im);
+    if (!raw) {
+        return [];
+    }
+    return raw
+        .split(",")
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+}
+function parseConstraints(source) {
+    const lines = source.split(/\r?\n/);
+    const constraints = [];
+    let inConstraintSection = false;
+    for (const lineRaw of lines) {
+        const line = lineRaw.trim();
+        if (/^#+\s*(constraints?|rules?)\b/i.test(line)) {
+            inConstraintSection = true;
+            continue;
+        }
+        if (inConstraintSection && line.startsWith("#")) {
+            inConstraintSection = false;
+        }
+        if (inConstraintSection && line.startsWith("- ")) {
+            constraints.push(line.slice(2).trim());
+        }
+    }
+    return constraints;
+}
+function parseExamples(source) {
+    const lines = source.split(/\r?\n/);
+    const examples = [];
+    for (const lineRaw of lines) {
+        const line = lineRaw.trim();
+        if (!line.startsWith("- `")) {
+            continue;
+        }
+        const title = line.replace(/^- `/, "").replace(/`.*$/, "").trim() || "example";
+        examples.push({
+            title,
+            input: {}
+        });
+    }
+    return examples;
+}
+function parseInputSchema(source) {
+    const fence = matchGroup(source, /```json\s*([\s\S]*?)```/im);
+    if (!fence) {
+        return { type: "object", additionalProperties: true };
+    }
+    try {
+        const parsed = JSON.parse(fence);
+        if (isObject(parsed)) {
+            if (isObject(parsed.input_schema)) {
+                return parsed.input_schema;
+            }
+            return parsed;
+        }
+    }
+    catch {
+        return { type: "object", additionalProperties: true };
+    }
+    return { type: "object", additionalProperties: true };
+}
+function slugify(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 64);
+}
+function matchGroup(source, regex) {
+    const matched = source.match(regex);
+    if (!matched || typeof matched[1] !== "string") {
+        return undefined;
+    }
+    return matched[1].trim();
+}
+function isObject(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    return true;
+}
+function validateSkills(skills) {
+    (0, errors_1.ensure)(Array.isArray(skills), "AGENTS-E-SKILL-NOT-LOADED", "skills must be an array.");
+}

package/dist/src/tools.d.ts

@@ -0,0 +1,21 @@
+import { JsonObject, McpCapabilitySummary, Tool } from "./types";
+export interface FunctionToolDefinition {
+    name: string;
+    description: string;
+    parameters?: JsonObject;
+    execute(args: JsonObject): Promise<unknown> | unknown;
+}
+export interface HostedMcpServer {
+    id?: string;
+    url: string;
+    listTools?: () => Promise<McpCapabilitySummary[]>;
+    callTool(toolName: string, args: JsonObject): Promise<unknown> | unknown;
+}
+export interface HostedMcpToolOptions {
+    name?: string;
+    description?: string;
+    requireApproval?: boolean;
+    capabilities?: McpCapabilitySummary[];
+}
+export declare function tool(definition: FunctionToolDefinition): Tool;
+export declare function hostedMcpTool(server: HostedMcpServer, options?: HostedMcpToolOptions): Tool;