@adminforth/agent 1.0.0

package/dist/agent/middleware/sequenceDebug.js

@@ -0,0 +1,210 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { createMiddleware } from "langchain";
+import YAML from "yaml";
+function createPendingSequenceDebug(sequenceId) {
+    return {
+        sequenceId,
+        startedAt: new Date().toISOString(),
+        prompt: "",
+        reasoning: "",
+        text: "",
+        toolCalls: [],
+        pendingToolCalls: 0,
+        resultType: null,
+    };
+}
+function hasSequenceDebugContent(sequence) {
+    return Boolean(sequence &&
+        (sequence.prompt ||
+            sequence.reasoning ||
+            sequence.text ||
+            sequence.toolCalls.length > 0));
+}
+function finalizeSequenceDebug(sequence) {
+    var _a;
+    return {
+        sequenceId: sequence.sequenceId,
+        startedAt: sequence.startedAt,
+        prompt: sequence.prompt,
+        reasoning: sequence.reasoning,
+        text: sequence.text,
+        toolCalls: sequence.toolCalls.map((_a) => {
+            var { completed: _completed } = _a, toolCall = __rest(_a, ["completed"]);
+            return toolCall;
+        }),
+        endedAt: new Date().toISOString(),
+        resultType: (_a = sequence.resultType) !== null && _a !== void 0 ? _a : "final_text",
+    };
+}
+function stringifyPromptForDebug(params) {
+    const { systemMessage, messages, tools, modelSettings } = params;
+    return YAML.stringify(Object.assign({ systemMessage: systemMessage.toDict(), messages: messages.map((message) => message.toDict()), tools: tools.map((tool) => {
+            if (typeof tool === "object" &&
+                tool !== null &&
+                "name" in tool &&
+                typeof tool.name === "string") {
+                return tool.name;
+            }
+            if (typeof tool === "object" &&
+                tool !== null &&
+                "schema" in tool &&
+                typeof tool.schema === "object" &&
+                tool.schema !== null &&
+                "name" in tool.schema &&
+                typeof tool.schema.name === "string") {
+                return tool.schema.name;
+            }
+            return "";
+        }) }, (modelSettings && Object.keys(modelSettings).length > 0
+        ? { modelSettings }
+        : {})));
+}
+function getMessageBlocks(message) {
+    if (Array.isArray(message.contentBlocks)) {
+        return message.contentBlocks;
+    }
+    if (Array.isArray(message.content)) {
+        return message.content;
+    }
+    return [];
+}
+function hasToolCallSignal(message) {
+    var _a;
+    return Boolean((Array.isArray(message.tool_calls) && message.tool_calls.length > 0) ||
+        (Array.isArray(message.tool_call_chunks) && message.tool_call_chunks.length > 0) ||
+        (Array.isArray((_a = message.additional_kwargs) === null || _a === void 0 ? void 0 : _a.tool_calls) &&
+            message.additional_kwargs.tool_calls.length > 0));
+}
+function extractSequenceResponseDebug(message) {
+    const blocks = getMessageBlocks(message);
+    const reasoning = blocks
+        .filter((block) => (block === null || block === void 0 ? void 0 : block.type) === "reasoning")
+        .map((block) => { var _a; return String((_a = block.reasoning) !== null && _a !== void 0 ? _a : ""); })
+        .join("");
+    const textFromBlocks = blocks
+        .filter((block) => (block === null || block === void 0 ? void 0 : block.type) === "text")
+        .map((block) => { var _a; return String((_a = block.text) !== null && _a !== void 0 ? _a : ""); })
+        .join("");
+    return {
+        reasoning,
+        text: textFromBlocks || (typeof message.content === "string" ? message.content : ""),
+        resultType: hasToolCallSignal(message) ? "tool_calls" : "final_text",
+    };
+}
+export function createSequenceDebugCollector() {
+    let nextSequenceId = 1;
+    let currentSequenceDebug = null;
+    const history = [];
+    const ensureSequenceDebug = () => {
+        if (!currentSequenceDebug) {
+            currentSequenceDebug = createPendingSequenceDebug(nextSequenceId++);
+        }
+        return currentSequenceDebug;
+    };
+    const flush = () => {
+        if (!hasSequenceDebugContent(currentSequenceDebug)) {
+            currentSequenceDebug = null;
+            return;
+        }
+        const finalizedSequenceDebug = finalizeSequenceDebug(currentSequenceDebug);
+        history.push(finalizedSequenceDebug);
+        currentSequenceDebug = null;
+    };
+    return {
+        handleModelCallStart(prompt) {
+            if ((currentSequenceDebug === null || currentSequenceDebug === void 0 ? void 0 : currentSequenceDebug.resultType) &&
+                currentSequenceDebug.pendingToolCalls === 0) {
+                flush();
+            }
+            const sequenceDebug = ensureSequenceDebug();
+            sequenceDebug.prompt = prompt;
+        },
+        handleModelCallComplete(params) {
+            const sequenceDebug = ensureSequenceDebug();
+            sequenceDebug.reasoning = params.reasoning;
+            sequenceDebug.text = params.text;
+            sequenceDebug.resultType = params.resultType;
+            if (sequenceDebug.resultType === "final_text" &&
+                sequenceDebug.pendingToolCalls === 0) {
+                flush();
+            }
+        },
+        handleToolCallEvent(event) {
+            const sequenceDebug = ensureSequenceDebug();
+            if (event.phase === "start") {
+                sequenceDebug.toolCalls.push({
+                    toolCallId: event.toolCallId,
+                    toolName: event.toolName,
+                    input: event.input,
+                    output: null,
+                    error: null,
+                    completed: false,
+                });
+                sequenceDebug.pendingToolCalls += 1;
+                return;
+            }
+            const pendingToolCall = sequenceDebug.toolCalls.find((toolCall) => toolCall.toolCallId === event.toolCallId && !toolCall.completed);
+            if (pendingToolCall) {
+                pendingToolCall.output = event.output;
+                pendingToolCall.error = event.error;
+                pendingToolCall.completed = true;
+            }
+            else {
+                sequenceDebug.toolCalls.push({
+                    toolCallId: event.toolCallId,
+                    toolName: event.toolName,
+                    input: "",
+                    output: event.output,
+                    error: event.error,
+                    completed: true,
+                });
+            }
+            sequenceDebug.pendingToolCalls = Math.max(0, sequenceDebug.pendingToolCalls - 1);
+            if (sequenceDebug.resultType === "tool_calls" &&
+                sequenceDebug.pendingToolCalls === 0) {
+                flush();
+            }
+        },
+        flush,
+        getHistory() {
+            return history;
+        },
+    };
+}
+export function createSequenceDebugMiddleware(sink) {
+    return createMiddleware({
+        name: "SequenceDebugMiddleware",
+        wrapModelCall(request, handler) {
+            return __awaiter(this, void 0, void 0, function* () {
+                sink.handleModelCallStart(stringifyPromptForDebug({
+                    systemMessage: request.systemMessage,
+                    messages: request.messages,
+                    tools: request.tools,
+                    modelSettings: request.modelSettings,
+                }));
+                const response = yield handler(request);
+                sink.handleModelCallComplete(extractSequenceResponseDebug(response));
+                return response;
+            });
+        },
+    });
+}

package/dist/agent/simpleAgent.js

@@ -0,0 +1,173 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { createAgent, summarizationMiddleware } from "langchain";
+import { logger } from "adminforth";
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+import { MemorySaver } from "@langchain/langgraph";
+import { z } from "zod";
+import { ChatOpenAI } from "@langchain/openai";
+import { createAgentTools } from "./tools/index.js";
+import { createApiBasedToolsMiddleware } from "./middleware/apiBasedTools.js";
+import { createSequenceDebugMiddleware, } from "./middleware/sequenceDebug.js";
+const checkpointer = new MemorySaver();
+export const contextSchema = z.object({
+    adminUser: z.custom(),
+    userTimeZone: z.string(),
+    sessionId: z.string(),
+    turnId: z.string(),
+    emitToolCallEvent: z.custom(),
+});
+function getFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value)
+        ? value
+        : undefined;
+}
+function extractTokenUsage(output) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    const llmOutputTokenUsage = (_a = output.llmOutput) === null || _a === void 0 ? void 0 : _a.tokenUsage;
+    const promptTokens = getFiniteNumber(llmOutputTokenUsage === null || llmOutputTokenUsage === void 0 ? void 0 : llmOutputTokenUsage.promptTokens);
+    const completionTokens = getFiniteNumber(llmOutputTokenUsage === null || llmOutputTokenUsage === void 0 ? void 0 : llmOutputTokenUsage.completionTokens);
+    if (promptTokens !== undefined || completionTokens !== undefined) {
+        return {
+            InputTokens: promptTokens !== null && promptTokens !== void 0 ? promptTokens : 0,
+            outputTokens: completionTokens !== null && completionTokens !== void 0 ? completionTokens : 0,
+        };
+    }
+    let InputTokens = 0;
+    let outputTokens = 0;
+    for (const generationBatch of output.generations) {
+        for (const generation of generationBatch) {
+            if (!("message" in generation) || !generation.message) {
+                continue;
+            }
+            const message = generation.message;
+            InputTokens +=
+                (_f = (_c = getFiniteNumber((_b = message.usage_metadata) === null || _b === void 0 ? void 0 : _b.input_tokens)) !== null && _c !== void 0 ? _c : getFiniteNumber((_e = (_d = message.response_metadata) === null || _d === void 0 ? void 0 : _d.tokenUsage) === null || _e === void 0 ? void 0 : _e.promptTokens)) !== null && _f !== void 0 ? _f : 0;
+            outputTokens +=
+                (_l = (_h = getFiniteNumber((_g = message.usage_metadata) === null || _g === void 0 ? void 0 : _g.output_tokens)) !== null && _h !== void 0 ? _h : getFiniteNumber((_k = (_j = message.response_metadata) === null || _j === void 0 ? void 0 : _j.tokenUsage) === null || _k === void 0 ? void 0 : _k.completionTokens)) !== null && _l !== void 0 ? _l : 0;
+        }
+    }
+    return { InputTokens, outputTokens };
+}
+class AgentLlmMetricsLogger extends BaseCallbackHandler {
+    constructor() {
+        super(...arguments);
+        this.name = "AgentLlmMetricsLogger";
+        this.lc_prefer_streaming = true;
+        this.pendingRuns = new Map();
+    }
+    handleLLMStart(_llm, _prompts, runId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.pendingRuns.set(runId, { startedAt: Date.now() });
+        });
+    }
+    handleLLMNewToken(_token, _chunk, runId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pendingRun = this.pendingRuns.get(runId);
+            if (!pendingRun || pendingRun.firstTokenAt !== undefined) {
+                return;
+            }
+            pendingRun.firstTokenAt = Date.now();
+        });
+    }
+    handleLLMEnd(output, runId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pendingRun = this.pendingRuns.get(runId);
+            if (!pendingRun) {
+                return;
+            }
+            this.pendingRuns.delete(runId);
+            const finishedAt = Date.now();
+            const rtt = finishedAt - pendingRun.startedAt;
+            const ttft = pendingRun.firstTokenAt === undefined
+                ? rtt
+                : pendingRun.firstTokenAt - pendingRun.startedAt;
+            const { InputTokens, outputTokens } = extractTokenUsage(output);
+            logger.info({ InputTokens, outputTokens, ttft, rtt }, "LLM call finished");
+        });
+    }
+    handleLLMError(_error, runId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.pendingRuns.delete(runId);
+        });
+    }
+}
+function createAgentLlmMetricsLogger() {
+    return new AgentLlmMetricsLogger();
+}
+function normalizeReasoning(reasoning) {
+    if (reasoning === "none") {
+        return undefined;
+    }
+    return {
+        effort: reasoning,
+        summary: "auto",
+    };
+}
+export function createAgentChatModel(params) {
+    var _a, _b, _c, _d;
+    const adapter = params.adapter;
+    const options = (_a = adapter.options) !== null && _a !== void 0 ? _a : {};
+    if (!options.openAiApiKey) {
+        throw new Error("CompletionAdapter must expose options.openAiApiKey for ChatOpenAI");
+    }
+    const model = (_c = (_b = params.modelName) !== null && _b !== void 0 ? _b : options.model) !== null && _c !== void 0 ? _c : "gpt-5-nano";
+    const baseURL = (_d = options.baseURL) !== null && _d !== void 0 ? _d : options.baseUrl;
+    const reasoning = normalizeReasoning(params.reasoning);
+    return new ChatOpenAI(Object.assign(Object.assign(Object.assign({ apiKey: options.openAiApiKey, model, maxTokens: params.maxTokens, useResponsesApi: true, outputVersion: "v1" }, (reasoning ? { reasoning } : {})), (typeof options.timeoutMs === "number"
+        ? { timeout: options.timeoutMs }
+        : {})), (baseURL
+        ? {
+            configuration: {
+                baseURL,
+            },
+        }
+        : {})));
+}
+export function callAgent(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { name, model, summaryModel, messages, adminUser, apiBasedTools, customComponentsDir, sessionId, turnId, userTimeZone, emitToolCallEvent, sequenceDebugSink, } = params;
+        const tools = yield createAgentTools(customComponentsDir, apiBasedTools);
+        const apiBasedToolsMiddleware = createApiBasedToolsMiddleware(apiBasedTools);
+        const sequenceDebugMiddleware = createSequenceDebugMiddleware(sequenceDebugSink);
+        const middleware = [
+            apiBasedToolsMiddleware,
+            sequenceDebugMiddleware,
+            summarizationMiddleware({
+                model: summaryModel,
+                trigger: { tokens: 1024 * 8 },
+                keep: { messages: 10 },
+            }),
+        ];
+        const agent = createAgent({
+            name,
+            model,
+            checkpointer,
+            tools,
+            contextSchema,
+            middleware,
+        });
+        return yield agent.stream({ messages }, {
+            streamMode: "messages",
+            recursionLimit: 50,
+            callbacks: [createAgentLlmMetricsLogger()],
+            configurable: {
+                thread_id: sessionId,
+            },
+            context: {
+                adminUser,
+                userTimeZone,
+                sessionId,
+                turnId,
+                emitToolCallEvent,
+            },
+        });
+    });
+}

package/dist/agent/skills/registry.js

@@ -0,0 +1,108 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { readdir, readFile } from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+import { parse as parseYaml } from "yaml";
+const PLUGIN_SKILLS_DIRECTORY_PATH = fileURLToPath(new URL("../../custom/skills/", import.meta.url));
+const SKILL_MARKDOWN_FILENAME = "SKILL.md";
+const SKILL_FRONTMATTER_SEPARATOR = "\n---\n";
+function parseSkillManifest(directoryName, markdown) {
+    var _a, _b;
+    const [frontmatterBlock, instructions = ""] = markdown.split("\r\n").join("\n").split(SKILL_FRONTMATTER_SEPARATOR, 2);
+    const metadata = parseYaml(frontmatterBlock);
+    return {
+        directoryName,
+        name: (_a = metadata.name) !== null && _a !== void 0 ? _a : directoryName,
+        description: (_b = metadata.description) !== null && _b !== void 0 ? _b : "",
+        instructions: instructions.trim(),
+    };
+}
+function readSkillManifest(skillsDirectoryPath, directoryName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const markdown = yield readFile(path.join(skillsDirectoryPath, directoryName, SKILL_MARKDOWN_FILENAME), "utf8");
+        return parseSkillManifest(directoryName, markdown);
+    });
+}
+function listDirectorySkillManifests(skillsDirectoryPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const entries = yield readdir(skillsDirectoryPath, { withFileTypes: true });
+            return yield Promise.all(entries
+                .filter((entry) => entry.isDirectory())
+                .map((entry) => entry.name)
+                .sort()
+                .map((directoryName) => readSkillManifest(skillsDirectoryPath, directoryName)));
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return [];
+            }
+            throw error;
+        }
+    });
+}
+function mergeSkillManifests(skillGroups) {
+    return Array.from(new Map(skillGroups.flat().map((skill) => [
+        `${skill.name}:${skill.directoryName}`,
+        skill,
+    ])).values());
+}
+export function getProjectSkillsDirectoryPath(customComponentsDir) {
+    return path.resolve(customComponentsDir, "skills");
+}
+export function listBundledSkillManifests() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield listDirectorySkillManifests(PLUGIN_SKILLS_DIRECTORY_PATH);
+    });
+}
+export function listProjectSkillManifests(customComponentsDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield listDirectorySkillManifests(getProjectSkillsDirectoryPath(customComponentsDir));
+    });
+}
+export function listSkillManifests(customComponentsDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return mergeSkillManifests([
+            yield listProjectSkillManifests(customComponentsDir),
+            yield listBundledSkillManifests(),
+        ]);
+    });
+}
+export function loadSkillManifest(skillName, customComponentsDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const manifests = yield listSkillManifests(customComponentsDir);
+        return ((_a = manifests.find((manifest) => manifest.name === skillName || manifest.directoryName === skillName)) !== null && _a !== void 0 ? _a : null);
+    });
+}
+export function loadSkillMarkdown(skillName, customComponentsDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const manifest = yield loadSkillManifest(skillName, customComponentsDir);
+        if (!manifest) {
+            return null;
+        }
+        const directories = [
+            getProjectSkillsDirectoryPath(customComponentsDir),
+            PLUGIN_SKILLS_DIRECTORY_PATH,
+        ];
+        for (const skillsDirectoryPath of directories) {
+            try {
+                return yield readFile(path.join(skillsDirectoryPath, manifest.directoryName, SKILL_MARKDOWN_FILENAME), "utf8");
+            }
+            catch (error) {
+                if (error.code !== "ENOENT") {
+                    throw error;
+                }
+            }
+        }
+        return null;
+    });
+}

package/dist/agent/systemPrompt.js

@@ -0,0 +1,64 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { listBundledSkillManifests, listProjectSkillManifests, } from "./skills/registry.js";
+import { ALWAYS_AVAILABLE_API_TOOL_NAMES } from "./tools/index.js";
+export const DEFAULT_AGENT_SYSTEM_PROMPT = [
+    "You are helpful AI Assistant for Admin Panel.",
+    // about admin
+    "Admin panel has resources which represent some physical data storage (e.g. table/collection), each resource defines list of columns.",
+    "Each resource stores data records. Record represents a data item of resource.",
+    //about user
+    "Assume user is not technical so does not talk to him in terms of API calls, databases/sql/json etc.",
+    // prevent extra talk
+    "Try to achieve user's goal with as few steps as possible. Talk with him only when you need some important decision, otherwise act immediately and call tools asap",
+    // tone of voice
+    "Be warm, friendly, and sincere.",
+    "Keep responses short, clear, and practical.",
+    "Answer only what is needed.",
+    "Do not add extra explanations or suggestions unless the user asks.",
+    "Adapt to the user's tone and style of speaking, mirroring their vibe and wording.",
+    "if the user speaks casually, you should respond casually too",
+].join(" ");
+function formatResources(resources) {
+    return resources
+        .map((resource) => `- resourceId: ${resource.resourceId}\n  label: ${resource.label}`)
+        .join("\n");
+}
+function formatSkills(skills, label) {
+    return skills
+        .map((skill) => `- ${label}: ${skill.name}\n  description: ${skill.description}`)
+        .join("\n");
+}
+export function buildAgentSystemPrompt(adminforth) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [primarySkills, defaultSkills] = yield Promise.all([
+            listProjectSkillManifests(adminforth.config.customization.customComponentsDir),
+            listBundledSkillManifests(),
+        ]);
+        const alwaysAvailableTools = ALWAYS_AVAILABLE_API_TOOL_NAMES.join(", ");
+        const sections = [
+            DEFAULT_AGENT_SYSTEM_PROMPT,
+            `BASE_URL: ${adminforth.config.baseUrl}`,
+            `List of resources:\n${formatResources(adminforth.config.resources)}`,
+            `You have always-available base tools: ${alwaysAvailableTools}.`,
+            primarySkills.length > 0
+                ? `You have primary skills set:\n${formatSkills(primarySkills, "skill_name")}`
+                : "",
+            "You have next default skills which you can fallback to if primary skill set does not provide a good skill:\n" +
+                formatSkills(defaultSkills, "skill_name"),
+            "Before using any skill, call fetch_skill to load its full instructions.",
+            "You can use get_resource immediately to inspect resource structure and column names.",
+            "Only call fetch_tool_schema for tool names that are explicitly mentioned in a fetched skill and are not already available as base tools.",
+            "When fetch_tool_schema succeeds, that tool becomes available on the next step.",
+            "Try to call as many tools as possible in parallel in one step.",
+        ];
+        return sections.filter(Boolean).join("\n\n");
+    });
+}

package/dist/agent/toolCallEvents.js

@@ -0,0 +1 @@
+export {};

package/dist/agent/tools/apiTool.js

@@ -0,0 +1,93 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { tool } from "langchain";
+import { randomUUID } from "crypto";
+import YAML from "yaml";
+import { serializeUnknownError } from "../../apiBasedTools.js";
+const emptyToolSchema = {
+    type: "object",
+    properties: {},
+    additionalProperties: true,
+};
+function normalizeToolInputSchema(inputSchema) {
+    if (!inputSchema || typeof inputSchema !== "object" || Array.isArray(inputSchema)) {
+        return emptyToolSchema;
+    }
+    const schema = JSON.parse(JSON.stringify(inputSchema));
+    if (schema.type !== "object") {
+        return emptyToolSchema;
+    }
+    const notes = [];
+    if ("if" in schema || "then" in schema || "else" in schema || "allOf" in schema) {
+        delete schema.if;
+        delete schema.then;
+        delete schema.else;
+        delete schema.allOf;
+        notes.push("Runtime applies additional conditional validation rules.");
+    }
+    if ("oneOf" in schema || "anyOf" in schema || "not" in schema || "enum" in schema) {
+        delete schema.oneOf;
+        delete schema.anyOf;
+        delete schema.not;
+        delete schema.enum;
+        notes.push("Top-level composite validation rules are omitted for tool compatibility.");
+    }
+    if (notes.length > 0) {
+        schema.description = typeof schema.description === "string"
+            ? `${schema.description}\n\n${notes.join(" ")}`
+            : notes.join(" ");
+    }
+    return schema;
+}
+export function createApiTool(toolName, apiBasedTool) {
+    var _a;
+    return tool((input, runtime) => __awaiter(this, void 0, void 0, function* () {
+        const normalizedInput = (input !== null && input !== void 0 ? input : {});
+        const toolCallId = randomUUID();
+        const startedAt = Date.now();
+        runtime.context.emitToolCallEvent({
+            toolCallId,
+            toolName,
+            phase: "start",
+            input: YAML.stringify(normalizedInput),
+        });
+        try {
+            const output = yield apiBasedTool.call({
+                adminUser: runtime.context.adminUser,
+                inputs: normalizedInput,
+                userTimeZone: runtime.context.userTimeZone,
+            });
+            runtime.context.emitToolCallEvent({
+                toolCallId,
+                toolName,
+                phase: "end",
+                durationMs: Date.now() - startedAt,
+                output,
+                error: null,
+            });
+            return output;
+        }
+        catch (error) {
+            runtime.context.emitToolCallEvent({
+                toolCallId,
+                toolName,
+                phase: "end",
+                durationMs: Date.now() - startedAt,
+                output: null,
+                error: YAML.stringify(serializeUnknownError(error)),
+            });
+            throw error;
+        }
+    }), {
+        name: toolName,
+        description: (_a = apiBasedTool.description) !== null && _a !== void 0 ? _a : `${toolName} tool`,
+        schema: normalizeToolInputSchema(apiBasedTool.input_schema),
+    });
+}