@compyle/unagent 1.0.0

package/dist/client/claude.js

@@ -0,0 +1,846 @@
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { BaseClient, } from "./base-client.js";
+import { ClientType, } from "../events/index.js";
+import { createAssistantMessage, createToolCallResultMessage, createUserMessage, normalizeMessage, } from "../messages/index.js";
+import { toContentArray, getTextValue, getImageUrl, stringifyContent, buildToolResultFromBlock, buildToolUseFromRecord, ToolCallTracker, } from "./transformers/content-utils.js";
+import { convertSnakeCaseToCamelCase } from "./config-utils.js";
+import { CLAUDE_FIELD_MAPPINGS } from "./field-mappings.js";
+import { extractCustomTools, isRegisteredTool } from "../tools/define-tool.js";
+import { getAgentToolServiceCommand, resolveToolServiceOwner } from "../tools/tool-service-manager.js";
+export class ClaudeClient extends BaseClient {
+    agentConfig;
+    toolCallTracker = new ToolCallTracker();
+    stderrBuffer = "";
+    stderrBufferLimit = 16000;
+    activeQuery;
+    constructor(config) {
+        super(ClientType.CLAUDE, config);
+        this.agentConfig = convertSnakeCaseToCamelCase(config, CLAUDE_FIELD_MAPPINGS);
+    }
+    async run(params) {
+        const events = [];
+        this.toolCallTracker.reset();
+        this.resetStderrBuffer();
+        let finalData = null;
+        let errorOccurred = false;
+        let sessionStarted = false;
+        const { controller, cleanup } = this.createAbortController(params.signal);
+        try {
+            const queryOptions = await this.buildQueryOptions({ abortController: controller });
+            const queryRunner = query({
+                prompt: params.query,
+                options: queryOptions,
+            });
+            this.activeQuery = queryRunner;
+            for await (const message of queryRunner) {
+                if (!sessionStarted && this.isInitMessage(message)) {
+                    const initSessionId = this.getInitSessionId(message);
+                    if (initSessionId) {
+                        await this.emitSessionStart(params, events, initSessionId);
+                        await this.emitUserItemEvents(params.query, events);
+                        sessionStarted = true;
+                    }
+                }
+                const convertedEvents = this.convertMessageToEvents(message);
+                events.push(...convertedEvents);
+                for (const event of convertedEvents) {
+                    await this.emit(event);
+                }
+                if (message.type === "text" && message.content) {
+                    finalData = message;
+                }
+                if (message.type === "assistant" && message.message) {
+                    finalData = message.message;
+                }
+                if (message.type === "message" && message.role === "assistant") {
+                    finalData = message;
+                }
+            }
+            if (this.isAbortRequested()) {
+                await this.emitSessionEnd(events, "aborted");
+                return {
+                    success: false,
+                    error: new Error("Aborted"),
+                    events,
+                };
+            }
+            await this.emitSessionEnd(events);
+            return {
+                success: !errorOccurred,
+                data: finalData,
+                events,
+            };
+        }
+        catch (error) {
+            if (this.isAbortRequested()) {
+                await this.emitSessionEnd(events, "aborted");
+                return {
+                    success: false,
+                    error: error,
+                    events,
+                };
+            }
+            await this.emitErrorEvent("run", error, events, this.getStderrContext());
+            await this.emitSessionEnd(events, "error");
+            return {
+                success: false,
+                error: error,
+                events,
+            };
+        }
+        finally {
+            this.activeQuery = undefined;
+            cleanup();
+        }
+    }
+    async runStream(params) {
+        this.toolCallTracker.reset();
+        this.resetStderrBuffer();
+        const { controller, cleanup } = this.createAbortController(params.signal);
+        try {
+            const queryOptions = await this.buildQueryOptions({ abortController: controller });
+            const eventStream = this.createEventStream(params, queryOptions);
+            return {
+                events: this.wrapEventStream(eventStream, () => {
+                    this.activeQuery = undefined;
+                    cleanup();
+                }),
+            };
+        }
+        catch (error) {
+            const aborted = this.isAbortRequested();
+            cleanup();
+            if (aborted) {
+                const sessionEndEvent = await this.emitSessionEnd(undefined, "aborted");
+                return {
+                    events: (async function* () {
+                        yield sessionEndEvent;
+                    })(),
+                };
+            }
+            const errorEvent = await this.emitErrorEvent("runStream", error, undefined, this.getStderrContext());
+            const sessionEndEvent = await this.emitSessionEnd(undefined, "error");
+            return {
+                events: (async function* () {
+                    yield errorEvent;
+                    yield sessionEndEvent;
+                })(),
+            };
+        }
+    }
+    async resume(params) {
+        this.toolCallTracker.reset();
+        this.resetStderrBuffer();
+        const { controller, cleanup } = this.createAbortController();
+        try {
+            const queryOptions = await this.buildQueryOptions({ abortController: controller });
+            const eventStream = this.createEventStream({ query: params.query || "[resuming session]", sessionId: params.sessionId }, queryOptions, params.sessionId);
+            return {
+                events: this.wrapEventStream(eventStream, () => {
+                    this.activeQuery = undefined;
+                    cleanup();
+                }),
+            };
+        }
+        catch (error) {
+            const aborted = this.isAbortRequested();
+            cleanup();
+            if (aborted) {
+                const sessionEndEvent = await this.emitSessionEnd(undefined, "aborted");
+                return {
+                    events: (async function* () {
+                        yield sessionEndEvent;
+                    })(),
+                };
+            }
+            const errorEvent = await this.emitErrorEvent("resume", error, undefined, {
+                ...this.getStderrContext(),
+                sessionId: params.sessionId,
+            });
+            const sessionEndEvent = await this.emitSessionEnd(undefined, "error");
+            return {
+                events: (async function* () {
+                    yield errorEvent;
+                    yield sessionEndEvent;
+                })(),
+            };
+        }
+    }
+    async buildQueryOptions(overrides) {
+        const options = {};
+        let toolRegistryServer = null;
+        const toolServerName = "custom-tools";
+        const permissionMode = resolveString(this.agentConfig.permissionMode);
+        if (permissionMode) {
+            options.permissionMode = permissionMode === "auto" ? "default" : permissionMode;
+        }
+        const systemPrompt = resolveString(this.agentConfig.systemPrompt);
+        if (systemPrompt !== undefined) {
+            options.systemPrompt = systemPrompt;
+        }
+        if (this.agentConfig.model) {
+            options.model = this.agentConfig.model;
+        }
+        if (this.agentConfig.agents) {
+            const normalizedAgents = {};
+            for (const [name, agent] of Object.entries(this.agentConfig.agents)) {
+                const { customTools, toolNames } = splitAgentTools(agent.tools);
+                const extraCustomTools = Array.isArray(agent.customTools) ? agent.customTools : [];
+                const agentCustomTools = [...customTools, ...extraCustomTools];
+                const allowedTools = normalizeToolNameList(agent.allowedTools);
+                const disallowedTools = normalizeToolNameList(agent.disallowedTools);
+                const agentToolNames = mergeToolNames([
+                    ...toolNames,
+                    ...allowedTools,
+                    ...agentCustomTools.map((tool) => tool.name),
+                ]);
+                const prompt = agent.prompt || agent.systemPrompt;
+                const agentOwner = getToolServiceOwner(agent);
+                const toolServerConfig = agentOwner && agentCustomTools.length > 0
+                    ? await buildToolServerConfig(agentOwner, agentCustomTools, toolServerName)
+                    : null;
+                const agentMcpServers = mergeAgentMcpServers(normalizeAgentMcpServers(agent.mcpServers), toolServerConfig);
+                normalizedAgents[name] = {
+                    description: agent.description ?? "",
+                    prompt: prompt || "",
+                    ...(agentToolNames.length > 0 ? { tools: agentToolNames } : {}),
+                    ...(disallowedTools.length > 0 ? { disallowedTools } : {}),
+                    ...(agent.model ? { model: agent.model } : {}),
+                    ...(agentMcpServers ? { mcpServers: agentMcpServers } : {}),
+                };
+            }
+            options.agents = normalizedAgents;
+        }
+        const customTools = extractCustomTools(this.agentConfig.tools);
+        if (customTools.length > 0) {
+            const toolServiceOwner = getToolServiceOwner(this.agentConfig);
+            if (toolServiceOwner) {
+                toolRegistryServer = await buildToolServerConfig(toolServiceOwner, customTools, toolServerName);
+            }
+        }
+        const allowedTools = normalizeToolNameList(this.agentConfig.allowedTools);
+        if (allowedTools.length > 0) {
+            options.allowedTools = allowedTools;
+        }
+        const disallowedTools = normalizeToolNameList(this.agentConfig.disallowedTools);
+        if (disallowedTools.length > 0) {
+            options.disallowedTools = disallowedTools;
+        }
+        const mcpServers = this.agentConfig.mcpServers;
+        if (mcpServers) {
+            options.mcpServers = {
+                ...(toolRegistryServer || {}),
+                ...mcpServers,
+            };
+        }
+        else if (toolRegistryServer) {
+            options.mcpServers = toolRegistryServer;
+        }
+        if (this.agentConfig.hooks) {
+            options.hooks = this.agentConfig.hooks;
+        }
+        if (this.agentConfig.resume) {
+            options.resume = this.agentConfig.resume;
+        }
+        const envOverrides = {};
+        let hasEnvOverrides = false;
+        if (this.agentConfig.apiKey) {
+            envOverrides.ANTHROPIC_API_KEY = this.agentConfig.apiKey;
+            hasEnvOverrides = true;
+        }
+        if (this.agentConfig.baseURL) {
+            envOverrides.ANTHROPIC_BASE_URL = this.agentConfig.baseURL;
+            hasEnvOverrides = true;
+        }
+        if (this.agentConfig.authToken) {
+            envOverrides.ANTHROPIC_AUTH_TOKEN = this.agentConfig.authToken;
+            hasEnvOverrides = true;
+        }
+        if (this.agentConfig.env && Object.keys(this.agentConfig.env).length > 0) {
+            Object.assign(envOverrides, this.agentConfig.env);
+            hasEnvOverrides = true;
+        }
+        if (hasEnvOverrides) {
+            options.env = {
+                ...process.env,
+                ...envOverrides,
+            };
+        }
+        options.stderr = (chunk) => {
+            this.captureStderr(chunk);
+        };
+        const settingSources = normalizeToolNameList(this.agentConfig.settingSources);
+        if (settingSources.length > 0) {
+            options.settingSources = [...settingSources];
+        }
+        else if (this.agentConfig.useProjectConfig) {
+            options.settingSources = ["project"];
+        }
+        const skillDir = resolveString(this.agentConfig.skillDir);
+        if (skillDir) {
+            ensureClaudeSkillPlugin(skillDir);
+            options.plugins = [{ type: "local", path: skillDir }];
+        }
+        const addDirs = normalizeToolNameList(this.agentConfig.addDirs);
+        if (addDirs.length > 0) {
+            options.additionalDirectories = [...addDirs];
+        }
+        const cwd = this.agentConfig.cwd ?? this.agentConfig.workingDirectory;
+        if (cwd) {
+            options.cwd = cwd;
+        }
+        if (overrides?.abortController) {
+            options.abortController = overrides.abortController;
+        }
+        return options;
+    }
+    abort() {
+        super.abort();
+        if (this.activeQuery) {
+            this.activeQuery.close();
+        }
+    }
+    getSessionDir() {
+        const envClaudConfigDir = this.agentConfig.env?.CLAUDE_CONFIG_DIR;
+        const baseDir = envClaudConfigDir || path.join(os.homedir(), ".claude");
+        return path.join(baseDir, "projects");
+    }
+    async *createEventStream(params, queryOptions, resumeSessionId) {
+        let endReason;
+        let sessionStarted = false;
+        try {
+            const finalOptions = resumeSessionId
+                ? { ...queryOptions, resume: resumeSessionId }
+                : queryOptions;
+            const queryRunner = query({
+                prompt: params.query,
+                options: finalOptions,
+            });
+            this.activeQuery = queryRunner;
+            for await (const message of queryRunner) {
+                if (!sessionStarted && this.isInitMessage(message)) {
+                    const initSessionId = this.getInitSessionId(message) ?? resumeSessionId;
+                    if (initSessionId) {
+                        const sessionStartEvent = await this.emitSessionStart(params, undefined, initSessionId);
+                        yield sessionStartEvent;
+                        const userEvents = await this.emitUserItemEvents(params.query);
+                        for (const event of userEvents) {
+                            yield event;
+                        }
+                        sessionStarted = true;
+                    }
+                }
+                const events = this.convertMessageToEvents(message);
+                for (const event of events) {
+                    await this.emit(event);
+                    yield event;
+                }
+            }
+        }
+        catch (error) {
+            if (this.isAbortRequested()) {
+                endReason = "aborted";
+            }
+            else {
+                const errorEvent = {
+                    type: "error",
+                    ...this.createBaseEvent(),
+                    error: error,
+                    context: { stage: "streamIteration", ...this.getStderrContext() },
+                };
+                await this.emit(errorEvent);
+                yield errorEvent;
+                endReason = "error";
+            }
+        }
+        if (!sessionStarted && resumeSessionId) {
+            const sessionStartEvent = await this.emitSessionStart(params, undefined, resumeSessionId);
+            yield sessionStartEvent;
+            const userEvents = await this.emitUserItemEvents(params.query);
+            for (const event of userEvents) {
+                yield event;
+            }
+        }
+        if (!endReason && this.isAbortRequested()) {
+            endReason = "aborted";
+        }
+        const sessionEndEvent = await this.emitSessionEnd(undefined, endReason);
+        yield sessionEndEvent;
+    }
+    isInitMessage(message) {
+        return Boolean(message &&
+            typeof message === "object" &&
+            message.type === "system" &&
+            message.subtype === "init");
+    }
+    getInitSessionId(message) {
+        const raw = message.session_id;
+        return typeof raw === "string" && raw.trim() ? raw : undefined;
+    }
+    convertMessageToEvents(message) {
+        const events = [];
+        const convertedMessage = this.convertToMessage(message);
+        if (convertedMessage) {
+            const normalized = convertedMessage;
+            const startMessage = { ...normalized, content: [] };
+            const itemStartEvent = {
+                type: "item.start",
+                ...this.createBaseEvent(),
+                message: startMessage,
+            };
+            const itemChunkEvent = {
+                type: "item.chunk",
+                ...this.createBaseEvent(),
+                message: normalized,
+            };
+            const itemEndEvent = {
+                type: "item.end",
+                ...this.createBaseEvent(),
+                message: normalized,
+            };
+            events.push(itemStartEvent, itemChunkEvent, itemEndEvent);
+        }
+        switch (message.type) {
+            case "system":
+                if (message.subtype === "init") {
+                    if (message.session_id) {
+                    }
+                }
+                break;
+            case "error":
+                const errorEvent = {
+                    type: "error",
+                    ...this.createBaseEvent(),
+                    error: new Error(message.error?.message || String(message.error)),
+                    context: {
+                        stage: "agentExecution",
+                        details: message.error,
+                    },
+                };
+                events.push(errorEvent);
+                break;
+            default:
+                break;
+        }
+        return events;
+    }
+    buildAssistantMessageFromContent(content, model) {
+        const blocks = toContentArray(content);
+        const textParts = [];
+        const toolCalls = [];
+        const thinkingParts = [];
+        let thinkingSignature;
+        for (const block of blocks) {
+            if (typeof block === "string") {
+                textParts.push(block);
+                continue;
+            }
+            if (!block || typeof block !== "object") {
+                continue;
+            }
+            const record = block;
+            const blockType = typeof record.type === "string" ? record.type : undefined;
+            if (blockType === "text") {
+                const text = getTextValue(record);
+                if (text !== null) {
+                    textParts.push(text);
+                }
+                continue;
+            }
+            if (blockType === "tool_use") {
+                const { id, name } = this.toolCallTracker.registerToolUse(record);
+                const toolUse = buildToolUseFromRecord(record, id);
+                toolUse.id = id;
+                toolUse.name = name;
+                toolCalls.push(toolUse);
+                continue;
+            }
+            if (blockType === "thinking") {
+                const text = getTextValue(record);
+                if (text !== null) {
+                    thinkingParts.push(text);
+                }
+                if (!thinkingSignature && typeof record.signature === "string") {
+                    thinkingSignature = record.signature;
+                }
+            }
+        }
+        if (textParts.length === 0 && toolCalls.length === 0 && thinkingParts.length === 0) {
+            return null;
+        }
+        return createAssistantMessage({
+            text: textParts.length > 0 ? textParts.join("\n") : undefined,
+            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+            thinking: thinkingParts.length > 0
+                ? { content: thinkingParts.join("\n"), signature: thinkingSignature }
+                : undefined,
+            model,
+        });
+    }
+    buildUserOrToolResultMessageFromContent(content) {
+        const blocks = toContentArray(content);
+        const toolResults = [];
+        const textParts = [];
+        const images = [];
+        for (const block of blocks) {
+            if (typeof block === "string") {
+                textParts.push(block);
+                continue;
+            }
+            if (!block || typeof block !== "object") {
+                continue;
+            }
+            const record = block;
+            const blockType = typeof record.type === "string" ? record.type : undefined;
+            if (blockType === "tool_result") {
+                const toolResult = buildToolResultFromBlock(record);
+                if (toolResult) {
+                    const { id: toolUseId } = this.toolCallTracker.resolveToolResult(record);
+                    toolResults.push({
+                        toolUseId,
+                        content: toolResult.content,
+                        isError: toolResult.isError,
+                    });
+                }
+                continue;
+            }
+            if (blockType === "text") {
+                const text = getTextValue(record);
+                if (text !== null) {
+                    textParts.push(text);
+                }
+                continue;
+            }
+            if (blockType === "image") {
+                const url = getImageUrl(record);
+                if (url) {
+                    images.push(url);
+                }
+            }
+        }
+        if (toolResults.length > 0) {
+            return createToolCallResultMessage(toolResults.map((result) => ({
+                tool_use_id: result.toolUseId,
+                content: result.content,
+                isError: result.isError,
+            })));
+        }
+        if (textParts.length === 0 && images.length === 0) {
+            return null;
+        }
+        if (images.length === 0) {
+            return createUserMessage(textParts.join("\n"));
+        }
+        return createUserMessage({ text: textParts.join("\n"), images });
+    }
+    resetStderrBuffer() {
+        this.stderrBuffer = "";
+    }
+    captureStderr(chunk) {
+        if (!chunk) {
+            return;
+        }
+        this.stderrBuffer += chunk;
+        if (this.stderrBuffer.length > this.stderrBufferLimit) {
+            this.stderrBuffer = this.stderrBuffer.slice(-this.stderrBufferLimit);
+        }
+    }
+    getStderrContext() {
+        const stderr = this.stderrBuffer.trim();
+        if (!stderr) {
+            return {};
+        }
+        return { stderr };
+    }
+    getModel(messageModel) {
+        return messageModel
+            ?? this.agentConfig.model
+            ?? "claude-sonnet-4-5-20250929";
+    }
+    convertToMessage(message) {
+        let msg = null;
+        switch (message.type) {
+            case "system":
+            case "usage":
+            case "result":
+            case "error":
+                break;
+            case "assistant": {
+                const content = message.message?.content ?? message.content;
+                msg = this.buildAssistantMessageFromContent(content, this.getModel(message.model));
+                break;
+            }
+            case "user": {
+                const content = message.message?.content ?? message.content;
+                msg = this.buildUserOrToolResultMessageFromContent(content);
+                break;
+            }
+            case "message": {
+                const role = message.role ?? message.message?.role;
+                const content = message.content ?? message.message?.content;
+                if (role === "assistant") {
+                    msg = this.buildAssistantMessageFromContent(content, this.getModel(message.model));
+                }
+                else if (role === "user") {
+                    msg = this.buildUserOrToolResultMessageFromContent(content);
+                }
+                break;
+            }
+            case "text":
+                if (message.content) {
+                    msg = createAssistantMessage({ text: String(message.content), model: this.getModel(message.model) });
+                }
+                break;
+            case "thinking":
+                if (message.content) {
+                    msg = createAssistantMessage({
+                        thinking: {
+                            content: String(message.content),
+                            signature: message.signature,
+                        },
+                        model: this.getModel(message.model),
+                    });
+                }
+                break;
+            case "tool_use":
+                const toolUseRecord = message;
+                const { id: toolUseId, name: toolUseName } = this.toolCallTracker.registerToolUse(toolUseRecord);
+                const toolUse = buildToolUseFromRecord(toolUseRecord, toolUseId);
+                toolUse.id = toolUseId;
+                toolUse.name = toolUseName;
+                msg = createAssistantMessage({ toolCalls: [toolUse], model: this.getModel(message.model) });
+                break;
+            case "tool_result":
+                const toolResultRecord = message;
+                const { id: toolResultId } = this.toolCallTracker.resolveToolResult(toolResultRecord);
+                let resultContent = "";
+                if (typeof message.content === "string" && message.content.length > 0) {
+                    resultContent = message.content;
+                }
+                else if (message.content !== undefined && message.content !== null) {
+                    resultContent = stringifyContent(message.content);
+                }
+                if (!resultContent && message.result !== undefined && message.result !== null) {
+                    resultContent = stringifyContent(message.result);
+                }
+                msg = createToolCallResultMessage([
+                    {
+                        tool_use_id: toolResultId,
+                        content: resultContent,
+                        isError: message.is_error || false,
+                    },
+                ]);
+                break;
+            default:
+                if (message.content !== undefined && message.content !== null) {
+                    msg = createAssistantMessage({
+                        text: stringifyContent(message.content),
+                        model: this.getModel(message.model),
+                    });
+                }
+                else {
+                    msg = createAssistantMessage({
+                        text: stringifyContent(message),
+                        model: this.getModel(message.model),
+                    });
+                }
+                break;
+        }
+        const parentToolUseId = this.getParentToolUseId(message);
+        if (msg && parentToolUseId) {
+            msg = { ...msg, parent_tool_use_id: parentToolUseId };
+        }
+        return msg ? normalizeMessage(this.applyParentToolUseId(msg)) : null;
+    }
+    getParentToolUseId(message) {
+        const topLevel = typeof message.parent_tool_use_id === "string"
+            ? message.parent_tool_use_id
+            : typeof message.parentToolUseId === "string"
+                ? message.parentToolUseId
+                : undefined;
+        if (topLevel) {
+            return topLevel;
+        }
+        const nested = message.message;
+        if (!nested || typeof nested !== "object") {
+            return undefined;
+        }
+        const nestedRecord = nested;
+        const nestedDirect = typeof nestedRecord.parent_tool_use_id === "string"
+            ? nestedRecord.parent_tool_use_id
+            : typeof nestedRecord.parentToolUseId === "string"
+                ? nestedRecord.parentToolUseId
+                : undefined;
+        if (nestedDirect) {
+            return nestedDirect;
+        }
+        const meta = nestedRecord.metadata;
+        if (meta && typeof meta === "object") {
+            const metaRecord = meta;
+            const metaValue = typeof metaRecord.parent_tool_use_id === "string"
+                ? metaRecord.parent_tool_use_id
+                : typeof metaRecord.parentToolUseId === "string"
+                    ? metaRecord.parentToolUseId
+                    : undefined;
+            if (metaValue) {
+                return metaValue;
+            }
+        }
+        const messageMeta = message.metadata;
+        if (messageMeta) {
+            const metaValue = typeof messageMeta.parent_tool_use_id === "string"
+                ? messageMeta.parent_tool_use_id
+                : typeof messageMeta.parentToolUseId === "string"
+                    ? messageMeta.parentToolUseId
+                    : undefined;
+            if (metaValue) {
+                return metaValue;
+            }
+        }
+        return undefined;
+    }
+    getAgentConfig() {
+        return { ...this.agentConfig };
+    }
+    updateAgentConfig(config) {
+        this.agentConfig = { ...this.agentConfig, ...config };
+    }
+    setAllowedTools(tools) {
+        this.agentConfig.allowedTools = tools;
+    }
+    setPermissionMode(mode) {
+        this.agentConfig.permissionMode = mode;
+    }
+    addMcpServer(name, config) {
+        if (!this.agentConfig.mcpServers) {
+            this.agentConfig.mcpServers = {};
+        }
+        this.agentConfig.mcpServers[name] = config;
+    }
+    addAgent(name, config) {
+        if (!this.agentConfig.agents) {
+            this.agentConfig.agents = {};
+        }
+        this.agentConfig.agents[name] = config;
+    }
+}
+function splitAgentTools(tools) {
+    const customTools = [];
+    const toolNames = [];
+    const addTool = (tool) => {
+        if (isRegisteredTool(tool)) {
+            customTools.push(tool);
+            toolNames.push(tool.name);
+            return;
+        }
+        if (typeof tool === "string" && tool.length > 0) {
+            toolNames.push(tool);
+            return;
+        }
+        throw new Error("Agent tools must be RegisteredTool instances or tool name strings");
+    };
+    if (tools === undefined || tools === null) {
+        return { customTools, toolNames };
+    }
+    if (Array.isArray(tools)) {
+        for (const tool of tools) {
+            addTool(tool);
+        }
+        return { customTools, toolNames };
+    }
+    addTool(tools);
+    return { customTools, toolNames };
+}
+function normalizeToolNameList(value) {
+    if (!value) {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value.filter((item) => typeof item === "string" && item.length > 0);
+    }
+    if (typeof value === "string" && value.length > 0) {
+        return [value];
+    }
+    return [];
+}
+function mergeToolNames(toolNames) {
+    return Array.from(new Set(toolNames));
+}
+function normalizeAgentMcpServers(value) {
+    if (!value) {
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        return value;
+    }
+    return [value];
+}
+function mergeAgentMcpServers(existing, toolServerConfig) {
+    if (!toolServerConfig) {
+        return existing;
+    }
+    if (existing && existing.length > 0) {
+        return [toolServerConfig, ...existing];
+    }
+    return [toolServerConfig];
+}
+async function buildToolServerConfig(owner, tools, serverName) {
+    if (tools.length === 0) {
+        return null;
+    }
+    const command = await getAgentToolServiceCommand(owner, tools, {
+        name: serverName,
+        version: "1.0.0",
+    });
+    return {
+        [serverName]: {
+            type: "stdio",
+            command: command.command,
+            args: command.args,
+            ...(command.env ? { env: command.env } : {}),
+        },
+    };
+}
+function getToolServiceOwner(value) {
+    const owner = resolveToolServiceOwner(value);
+    if (owner) {
+        return owner;
+    }
+    return isRecord(value) ? value : null;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function ensureClaudeSkillPlugin(skillDir) {
+    const pluginContent = {
+        name: "load-custom-skill-plugin",
+        description: "plugin to load custom skills",
+        version: "1.0.0",
+        skills: "./",
+    };
+    fs.mkdirSync(path.join(skillDir, ".claude-plugin"), { recursive: true });
+    const pluginPath = path.join(skillDir, ".claude-plugin", "plugin.json");
+    const serialized = `${JSON.stringify(pluginContent, null, 2)}\n`;
+    let shouldWrite = true;
+    if (fs.existsSync(pluginPath)) {
+        try {
+            const existing = fs.readFileSync(pluginPath, "utf-8");
+            if (existing === serialized) {
+                shouldWrite = false;
+            }
+        }
+        catch {
+            shouldWrite = true;
+        }
+    }
+    if (shouldWrite) {
+        fs.writeFileSync(pluginPath, serialized, "utf-8");
+    }
+}
+//# sourceMappingURL=claude.js.map