@compyle/unagent 1.0.0

package/dist/agents/define-agent.js

@@ -0,0 +1,866 @@
+import { createHash } from "crypto";
+import { extractCustomTools } from "../tools/define-tool.js";
+import { attachToolServiceOwner } from "../tools/tool-service-manager.js";
+import { normalizeExtraHeaders, resolveEnvHeaders, mergeHeaderRecords, serializeAnthropicHeaders, applyCodexExtraHeaders, } from "../client/extra-headers.js";
+export class Agent {
+    constructor(definition) {
+        if (!definition || typeof definition !== "object") {
+            throw new Error("Agent definition must be a valid object");
+        }
+        if (!definition.client || typeof definition.client !== "string") {
+            throw new Error("Agent client must be a non-empty string");
+        }
+        Object.assign(this, definition);
+        const state = getAgentState(this);
+        state.config = buildAgentClientConfig(definition);
+    }
+    get definition() {
+        return { ...this };
+    }
+    get config() {
+        const state = getAgentState(this);
+        if (!state.config) {
+            state.config = buildAgentClientConfig(this);
+        }
+        return { ...state.config };
+    }
+    async run(params) {
+        const client = await requireAgentClient(this);
+        return client.run(normalizeRunParams(params));
+    }
+    async runStream(params) {
+        const client = await requireAgentClient(this);
+        return client.runStream(normalizeRunParams(params));
+    }
+    async resume(params) {
+        const client = await requireAgentClient(this);
+        return client.resume(params);
+    }
+    abort() {
+        const state = getAgentState(this);
+        if (state.client) {
+            state.client.abort();
+            return;
+        }
+        if (state.clientPromise) {
+            state.clientPromise.then((client) => client.abort()).catch(() => { });
+        }
+    }
+    cleanup() {
+        const state = getAgentState(this);
+        const client = state.client;
+        if (client && typeof client.cleanup === "function") {
+            client.cleanup?.();
+        }
+        state.client = undefined;
+        state.clientPromise = undefined;
+    }
+    async getSessionDir() {
+        const client = await requireAgentClient(this);
+        if (typeof client.getSessionDir === "function") {
+            return client.getSessionDir();
+        }
+        throw new Error(`Client type '${this.client}' does not support getSessionDir`);
+    }
+}
+const agentState = new WeakMap();
+export function defineAgent(definition) {
+    const agentDefinition = buildAgentDefinition(definition);
+    return new Agent(agentDefinition);
+}
+export function resolveAgentDefinition(agent) {
+    if (isAgentInstance(agent)) {
+        return agent.definition;
+    }
+    return agent;
+}
+export function buildAgentClientConfig(agent) {
+    const definition = resolveAgentDefinition(agent);
+    const config = {};
+    if (isRecord(definition.otherConfig) && Object.keys(definition.otherConfig).length > 0) {
+        Object.assign(config, definition.otherConfig);
+    }
+    const systemPrompt = resolveString(definition.systemPrompt) ?? resolveString(definition.prompt);
+    const otherConfigPrompt = resolveString(isRecord(definition.otherConfig) ? definition.otherConfig.developer_instructions : undefined);
+    const existingPrompt = resolveString(config.systemPrompt);
+    if (systemPrompt) {
+        config.systemPrompt = systemPrompt;
+    }
+    else if (!existingPrompt && otherConfigPrompt) {
+        config.systemPrompt = otherConfigPrompt;
+    }
+    if (resolveString(definition.model)) {
+        config.model = definition.model;
+    }
+    if (resolveString(definition.apiKey)) {
+        config.apiKey = definition.apiKey;
+    }
+    if (resolveString(definition.baseURL)) {
+        config.baseURL = definition.baseURL;
+    }
+    if (definition.env && Object.keys(definition.env).length > 0) {
+        config.env = { ...definition.env };
+    }
+    const homeDir = resolveString(definition.homeDir);
+    if (homeDir && (definition.client === "codex" || definition.client === "claude")) {
+        const envRecord = isRecord(config.env)
+            ? { ...config.env }
+            : {};
+        if (definition.client === "codex") {
+            envRecord.CODEX_HOME = homeDir;
+        }
+        else if (definition.client === "claude") {
+            envRecord.CLAUDE_CONFIG_DIR = homeDir;
+        }
+        config.env = envRecord;
+    }
+    const extraHeaders = normalizeExtraHeaders(definition.extraHeaders);
+    if (extraHeaders) {
+        if (definition.client === "claude") {
+            const envRecord = isRecord(config.env)
+                ? config.env
+                : {};
+            const resolvedEnvHeaders = resolveEnvHeaders(extraHeaders.envHeaders, envRecord);
+            const mergedHeaders = mergeHeaderRecords(extraHeaders.headers, resolvedEnvHeaders);
+            const customHeaderValue = serializeAnthropicHeaders(mergedHeaders);
+            if (customHeaderValue) {
+                envRecord.ANTHROPIC_CUSTOM_HEADERS = customHeaderValue;
+                config.env = envRecord;
+            }
+        }
+        else if (definition.client === "codex") {
+            const existingConfig = isRecord(config.config)
+                ? config.config
+                : {};
+            const updatedConfig = applyCodexExtraHeaders(existingConfig, extraHeaders);
+            if (Object.keys(updatedConfig).length > 0) {
+                config.config = updatedConfig;
+            }
+        }
+    }
+    const customTools = Array.isArray(definition.customTools) ? definition.customTools : [];
+    if (customTools.length > 0) {
+        config.tools = customTools;
+    }
+    const toolFilters = resolveToolFilters(definition);
+    const hasExplicitAllowList = hasExplicitAllowedTools(definition);
+    const fallbackTools = normalizeStringArray(definition.tools) ?? [];
+    const allowedTools = hasExplicitAllowList ? toolFilters.allowedTools : fallbackTools;
+    if (allowedTools.length > 0) {
+        config.allowedTools = allowedTools;
+    }
+    if (toolFilters.disallowedTools.length > 0) {
+        config.disallowedTools = toolFilters.disallowedTools;
+    }
+    const mcpServers = definition.client === "codex"
+        ? extractCodexMcpServerRecord(definition.mcpServers, toolFilters)
+        : extractMcpServerRecord(definition.mcpServers);
+    if (mcpServers && Object.keys(mcpServers).length > 0) {
+        config.mcpServers = mcpServers;
+    }
+    if (definition.permissionMode) {
+        config.permissionMode = definition.permissionMode;
+    }
+    if (definition.hooks && Object.keys(definition.hooks).length > 0) {
+        config.hooks = definition.hooks;
+    }
+    if (Array.isArray(definition.settingSources) && definition.settingSources.length > 0) {
+        config.settingSources = definition.settingSources;
+    }
+    if (Array.isArray(definition.addDirs) && definition.addDirs.length > 0) {
+        config.addDirs = definition.addDirs;
+    }
+    if (resolveString(definition.cwd)) {
+        config.cwd = definition.cwd;
+    }
+    if (resolveString(definition.skillDir)) {
+        config.skillDir = definition.skillDir;
+    }
+    const homeDirHashIgnore = normalizeHashIgnoreList(definition.homeDirHashIgnore ??
+        definition.home_dir_hash_ignore);
+    if (homeDirHashIgnore.length > 0) {
+        config.homeDirHashIgnore = homeDirHashIgnore;
+    }
+    if (isRecord(agent)) {
+        attachToolServiceOwner(config, agent);
+    }
+    const codexHomeKey = createCodexHomeKey(definition);
+    if (codexHomeKey) {
+        const envRecord = isRecord(config.env) ? config.env : undefined;
+        const envCodexHome = resolveString(envRecord?.CODEX_HOME);
+        const existingCodexHomeKey = resolveString(config.codexHomeKey);
+        if (!envCodexHome && !existingCodexHomeKey) {
+            config.codexHomeKey = codexHomeKey;
+        }
+    }
+    return config;
+}
+function buildAgentDefinition(definition) {
+    const description = definition.description;
+    const systemPrompt = resolveSystemPrompt(definition);
+    const client = definition.client;
+    if (!client || typeof client !== "string") {
+        throw new Error("Agent client must be a non-empty string");
+    }
+    const validClients = ["claude", "codex", "other"];
+    if (!validClients.includes(client)) {
+        throw new Error(`Invalid client value: "${client}". Must be one of: ${validClients.join(", ")}`);
+    }
+    if (description !== undefined && (typeof description !== "string" || !description)) {
+        throw new Error("Agent description must be a non-empty string");
+    }
+    if (systemPrompt !== undefined && (typeof systemPrompt !== "string" || !systemPrompt)) {
+        throw new Error("Agent systemPrompt must be a non-empty string");
+    }
+    if (definition.apiKey !== undefined && typeof definition.apiKey !== "string") {
+        throw new Error("Agent apiKey must be a string");
+    }
+    if (definition.baseURL !== undefined && typeof definition.baseURL !== "string") {
+        throw new Error("Agent baseURL must be a string");
+    }
+    if (definition.skillDir !== undefined && typeof definition.skillDir !== "string") {
+        throw new Error("Agent skillDir must be a string");
+    }
+    if (definition.skillDir !== undefined && typeof definition.skillDir === "string" && !definition.skillDir) {
+        throw new Error("Agent skillDir must be a non-empty string");
+    }
+    if (definition.homeDir !== undefined && typeof definition.homeDir !== "string") {
+        throw new Error("Agent homeDir must be a string");
+    }
+    if (definition.homeDir !== undefined && typeof definition.homeDir === "string" && !definition.homeDir) {
+        throw new Error("Agent homeDir must be a non-empty string");
+    }
+    const extraHeaders = normalizeExtraHeaders(definition.extraHeaders);
+    if (definition.extraHeaders !== undefined && !extraHeaders) {
+        throw new Error("Agent extraHeaders must be a record of string headers or { headers, envHeaders }");
+    }
+    if (definition.homeDirHashIgnore !== undefined &&
+        !Array.isArray(definition.homeDirHashIgnore) &&
+        typeof definition.homeDirHashIgnore !== "string") {
+        throw new Error("Agent homeDirHashIgnore must be a string or list of strings");
+    }
+    if (definition.home_dir_hash_ignore !== undefined &&
+        !Array.isArray(definition.home_dir_hash_ignore) &&
+        typeof definition.home_dir_hash_ignore !== "string") {
+        throw new Error("Agent home_dir_hash_ignore must be a string or list of strings");
+    }
+    const toolFilters = resolveToolFilters(definition);
+    const allowedTools = toolFilters.allowedTools;
+    const disallowedTools = toolFilters.disallowedTools;
+    const customTools = extractCustomTools(definition.tools);
+    const toolNames = mergeUniqueStrings([
+        ...allowedTools,
+        ...customTools.map((tool) => tool.name),
+    ]);
+    const normalizedMcpServers = normalizeAgentMcpServers(definition.mcpServers);
+    const addDirs = normalizeStringList(definition.addDirs);
+    const homeDirHashIgnore = mergeUniqueStrings([
+        ...normalizeHashIgnoreList(definition.homeDirHashIgnore),
+        ...normalizeHashIgnoreList(definition.home_dir_hash_ignore),
+    ]);
+    const otherConfig = buildOtherConfig({
+        client,
+        model: definition.model,
+        systemPrompt,
+        mcpServers: definition.mcpServers,
+        addDirs,
+        allowedTools,
+        disallowedTools,
+        skillDir: definition.skillDir,
+        customConfig: definition.otherConfig,
+    });
+    const agent = {
+        client,
+    };
+    if (description !== undefined) {
+        agent.description = description;
+    }
+    if (systemPrompt !== undefined) {
+        agent.prompt = systemPrompt;
+        agent.systemPrompt = systemPrompt;
+    }
+    if (toolNames.length > 0) {
+        agent.tools = toolNames;
+    }
+    if (allowedTools.length > 0) {
+        agent.allowedTools = allowedTools;
+    }
+    if (disallowedTools.length > 0) {
+        agent.disallowedTools = disallowedTools;
+    }
+    if (definition.model) {
+        agent.model = definition.model;
+    }
+    if (definition.apiKey) {
+        agent.apiKey = definition.apiKey;
+    }
+    if (definition.baseURL) {
+        agent.baseURL = definition.baseURL;
+    }
+    if (normalizedMcpServers && normalizedMcpServers.length > 0) {
+        agent.mcpServers = normalizedMcpServers;
+    }
+    const permissionMode = definition.permissionMode;
+    if (permissionMode) {
+        agent.permissionMode = permissionMode;
+    }
+    if (definition.hooks) {
+        agent.hooks = definition.hooks;
+    }
+    const settingSources = normalizeStringList(definition.settingSources);
+    if (settingSources.length > 0) {
+        agent.settingSources = settingSources;
+    }
+    if (definition.env && Object.keys(definition.env).length > 0) {
+        agent.env = { ...definition.env };
+    }
+    if (addDirs.length > 0) {
+        agent.addDirs = addDirs;
+    }
+    if (definition.cwd) {
+        agent.cwd = definition.cwd;
+    }
+    if (definition.homeDir) {
+        agent.homeDir = definition.homeDir;
+    }
+    if (definition.skillDir) {
+        agent.skillDir = definition.skillDir;
+    }
+    if (homeDirHashIgnore.length > 0) {
+        agent.homeDirHashIgnore = homeDirHashIgnore;
+    }
+    if (extraHeaders) {
+        agent.extraHeaders = extraHeaders;
+    }
+    if (customTools.length > 0) {
+        agent.customTools = customTools;
+    }
+    if (otherConfig && Object.keys(otherConfig).length > 0) {
+        agent.otherConfig = otherConfig;
+    }
+    return agent;
+}
+function resolveSystemPrompt(definition) {
+    return definition.systemPrompt;
+}
+function createCodexHomeKey(definition) {
+    if (definition.client !== "codex") {
+        return undefined;
+    }
+    const hashSource = buildCodexHomeHashSource(definition);
+    const homeDirHashIgnore = normalizeHashIgnoreList(definition.homeDirHashIgnore ??
+        definition.home_dir_hash_ignore);
+    const filteredHashSource = applyHashIgnoreToRecord(hashSource, homeDirHashIgnore);
+    const serialized = logCodexHomeHashSource(filteredHashSource);
+    return createHash("sha256").update(serialized).digest("hex");
+}
+function buildCodexHomeHashSource(definition) {
+    const mcpServers = stripCustomToolsMcpServers(definition.mcpServers);
+    const otherConfig = stripCustomToolsMcpFromOtherConfig(definition.otherConfig);
+    return {
+        client: definition.client,
+        description: definition.description,
+        systemPrompt: resolveString(definition.systemPrompt) ?? resolveString(definition.prompt),
+        tools: definition.tools,
+        allowedTools: definition.allowedTools,
+        disallowedTools: definition.disallowedTools,
+        model: definition.model,
+        baseURL: definition.baseURL,
+        mcpServers,
+        permissionMode: definition.permissionMode,
+        settingSources: definition.settingSources,
+        addDirs: definition.addDirs,
+        cwd: definition.cwd,
+        homeDir: definition.homeDir,
+        skillDir: definition.skillDir,
+        extraHeaders: definition.extraHeaders,
+        otherConfig,
+    };
+}
+const HASH_EXCLUDED_KEYS = new Set([
+    "resume",
+    "resumesessionid",
+    "resume_session_id",
+    "sessionid",
+    "session_id",
+    "threadid",
+    "thread_id",
+]);
+const CUSTOM_TOOLS_MCP_NAME = "custom-tools";
+function shouldExcludeHashKey(key) {
+    return HASH_EXCLUDED_KEYS.has(key.toLowerCase());
+}
+function isCustomToolsMcpName(name) {
+    return name.toLowerCase() === CUSTOM_TOOLS_MCP_NAME;
+}
+function stripCustomToolsMcpServers(input) {
+    if (!input) {
+        return undefined;
+    }
+    let removed = false;
+    const filtered = [];
+    for (const entry of input) {
+        if (typeof entry === "string") {
+            if (isCustomToolsMcpName(entry)) {
+                removed = true;
+            }
+            else {
+                filtered.push(entry);
+            }
+            continue;
+        }
+        if (!isRecord(entry)) {
+            filtered.push(entry);
+            continue;
+        }
+        let recordRemoved = false;
+        const nextRecord = {};
+        for (const [name, config] of Object.entries(entry)) {
+            if (isCustomToolsMcpName(name)) {
+                recordRemoved = true;
+                continue;
+            }
+            nextRecord[name] = config;
+        }
+        if (Object.keys(nextRecord).length > 0) {
+            filtered.push(nextRecord);
+        }
+        if (recordRemoved) {
+            removed = true;
+        }
+    }
+    if (!removed) {
+        return input;
+    }
+    return filtered.length > 0 ? filtered : undefined;
+}
+function stripCustomToolsMcpFromRecord(input) {
+    let removed = false;
+    const nextRecord = {};
+    for (const [name, config] of Object.entries(input)) {
+        if (isCustomToolsMcpName(name)) {
+            removed = true;
+            continue;
+        }
+        nextRecord[name] = config;
+    }
+    if (!removed) {
+        return input;
+    }
+    return Object.keys(nextRecord).length > 0 ? nextRecord : undefined;
+}
+function stripCustomToolsMcpFromOtherConfig(input) {
+    if (!input || Object.keys(input).length === 0) {
+        return input;
+    }
+    let updated = false;
+    const output = { ...input };
+    const updateKey = (key) => {
+        if (!(key in output)) {
+            return;
+        }
+        const value = output[key];
+        if (Array.isArray(value)) {
+            const filtered = stripCustomToolsMcpServers(value);
+            if (filtered !== value) {
+                updated = true;
+            }
+            if (!filtered || filtered.length === 0) {
+                delete output[key];
+            }
+            else {
+                output[key] = filtered;
+            }
+            return;
+        }
+        if (isRecord(value)) {
+            const filtered = stripCustomToolsMcpFromRecord(value);
+            if (filtered !== value) {
+                updated = true;
+            }
+            if (!filtered || Object.keys(filtered).length === 0) {
+                delete output[key];
+            }
+            else {
+                output[key] = filtered;
+            }
+        }
+    };
+    updateKey("mcpServers");
+    updateKey("mcp_servers");
+    return updated ? output : input;
+}
+function logCodexHomeHashSource(hashSource) {
+    const serialized = JSON.stringify(normalizeHashValue(hashSource));
+    return serialized;
+}
+function normalizeHashValue(value, seen = new WeakSet()) {
+    if (value === null) {
+        return null;
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "bigint") {
+        return value.toString();
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => {
+            const normalized = normalizeHashValue(item, seen);
+            return normalized === undefined ? null : normalized;
+        });
+    }
+    if (typeof value === "object") {
+        if (seen.has(value)) {
+            return "[Circular]";
+        }
+        seen.add(value);
+        const record = {};
+        for (const key of Object.keys(value).sort()) {
+            if (shouldExcludeHashKey(key)) {
+                continue;
+            }
+            const lowerKey = key.toLowerCase();
+            let nextValue = value[key];
+            if (lowerKey === "mcp_servers" || lowerKey === "mcpservers") {
+                if (Array.isArray(nextValue)) {
+                    nextValue = stripCustomToolsMcpServers(nextValue);
+                }
+                else if (isRecord(nextValue)) {
+                    nextValue = stripCustomToolsMcpFromRecord(nextValue);
+                }
+            }
+            const normalized = normalizeHashValue(nextValue, seen);
+            if (normalized !== undefined) {
+                record[key] = normalized;
+            }
+        }
+        seen.delete(value);
+        return record;
+    }
+    return undefined;
+}
+function normalizeAgentMcpServers(input) {
+    if (!input) {
+        return undefined;
+    }
+    if (Array.isArray(input)) {
+        return input;
+    }
+    return [input];
+}
+function normalizeStringList(value) {
+    if (!value) {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value.filter((item) => typeof item === "string" && item.length > 0);
+    }
+    if (typeof value === "string") {
+        return value.length > 0 ? [value] : [];
+    }
+    return [];
+}
+function normalizeHashIgnoreList(value) {
+    return normalizeStringList(value)
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+}
+function normalizeHashIgnoreKey(value) {
+    return value.replace(/_/g, "").toLowerCase();
+}
+function applyHashIgnoreToRecord(record, ignoreList) {
+    if (ignoreList.length === 0) {
+        return record;
+    }
+    const ignoreSet = new Set(ignoreList.map((item) => normalizeHashIgnoreKey(item)));
+    const filtered = {};
+    for (const [key, value] of Object.entries(record)) {
+        if (ignoreSet.has(normalizeHashIgnoreKey(key))) {
+            continue;
+        }
+        filtered[key] = value;
+    }
+    return filtered;
+}
+function mergeUniqueStrings(values) {
+    return Array.from(new Set(values));
+}
+function resolveToolFilters(input) {
+    const allowedTools = mergeUniqueStrings([
+        ...normalizeStringList(input.allowedTools),
+        ...normalizeStringList(input.allowed_tools),
+    ]);
+    const disallowedTools = mergeUniqueStrings([
+        ...normalizeStringList(input.disallowedTools),
+        ...normalizeStringList(input.disallowed_tools),
+    ]);
+    return { allowedTools, disallowedTools };
+}
+function hasExplicitAllowedTools(input) {
+    if (Array.isArray(input.allowedTools) || Array.isArray(input.allowed_tools)) {
+        return true;
+    }
+    if (typeof input.allowedTools === "string") {
+        return input.allowedTools.length > 0;
+    }
+    if (typeof input.allowed_tools === "string") {
+        return input.allowed_tools.length > 0;
+    }
+    return false;
+}
+function applyCodexToolFilters(mcpServers, toolFilters) {
+    if (!toolFilters) {
+        return mcpServers;
+    }
+    const enabledTools = toolFilters.allowedTools ?? [];
+    const disabledTools = toolFilters.disallowedTools ?? [];
+    if (enabledTools.length === 0 && disabledTools.length === 0) {
+        return mcpServers;
+    }
+    const updated = {};
+    for (const [name, config] of Object.entries(mcpServers)) {
+        const nextConfig = { ...config };
+        if (enabledTools.length > 0) {
+            const existingEnabledTools = normalizeStringArray(nextConfig.enabled_tools);
+            if (!existingEnabledTools || existingEnabledTools.length === 0) {
+                nextConfig.enabled_tools = [...enabledTools];
+            }
+        }
+        if (disabledTools.length > 0) {
+            const existingDisabledTools = normalizeStringArray(nextConfig.disabled_tools);
+            if (!existingDisabledTools || existingDisabledTools.length === 0) {
+                nextConfig.disabled_tools = [...disabledTools];
+            }
+        }
+        updated[name] = nextConfig;
+    }
+    return updated;
+}
+function buildOtherConfig(input) {
+    const config = {};
+    if (input.customConfig && Object.keys(input.customConfig).length > 0) {
+        Object.assign(config, input.customConfig);
+    }
+    if (!input.customConfig || Object.keys(input.customConfig).length === 0) {
+        if (input.model) {
+            config.model = input.model;
+        }
+        if (input.systemPrompt) {
+            config.developer_instructions = input.systemPrompt;
+        }
+        const mcpServers = input.client === "codex"
+            ? extractCodexMcpServerRecord(input.mcpServers, {
+                allowedTools: input.allowedTools ?? [],
+                disallowedTools: input.disallowedTools ?? [],
+            })
+            : extractMcpServerRecord(input.mcpServers);
+        if (mcpServers && Object.keys(mcpServers).length > 0) {
+            config.mcp_servers = mcpServers;
+        }
+        if (input.addDirs && input.addDirs.length > 0) {
+            config.sandbox_workspace_write = {
+                writable_roots: [...input.addDirs],
+            };
+        }
+        if (input.skillDir && input.client === "codex") {
+            config.skills = {
+                config: [{ path: input.skillDir, enabled: true }],
+            };
+        }
+    }
+    if (Object.keys(config).length === 0) {
+        return undefined;
+    }
+    return config;
+}
+function extractMcpServerRecord(input) {
+    if (!input) {
+        return undefined;
+    }
+    if (!Array.isArray(input)) {
+        return input;
+    }
+    const merged = {};
+    for (const entry of input) {
+        if (typeof entry === "string") {
+            continue;
+        }
+        Object.assign(merged, entry);
+    }
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
+function extractCodexMcpServerRecord(input, toolFilters) {
+    const record = extractMcpServerRecord(input);
+    if (!record) {
+        return undefined;
+    }
+    const converted = {};
+    for (const [name, config] of Object.entries(record)) {
+        converted[name] = toCodexMcpServerConfig(name, config);
+    }
+    if (Object.keys(converted).length === 0) {
+        return undefined;
+    }
+    return applyCodexToolFilters(converted, toolFilters);
+}
+function toCodexMcpServerConfig(name, config) {
+    if (!isRecord(config)) {
+        throw new Error(`MCP server "${name}" must be an object`);
+    }
+    const source = config;
+    const type = typeof source.type === "string" ? source.type : undefined;
+    if (type === "sdk" || "instance" in source) {
+        throw new Error(`MCP server "${name}" uses SDK transport which Codex does not support`);
+    }
+    const codexConfig = {};
+    if (typeof source.command === "string" && source.command.length > 0) {
+        codexConfig.command = source.command;
+    }
+    const args = normalizeStringArray(source.args);
+    if (args && args.length > 0) {
+        codexConfig.args = args;
+    }
+    const env = normalizeStringRecord(source.env);
+    if (env) {
+        codexConfig.env = env;
+    }
+    if (typeof source.url === "string" && source.url.length > 0) {
+        codexConfig.url = source.url;
+    }
+    const httpHeaders = normalizeStringRecord(source.http_headers)
+        ?? normalizeStringRecord(source.headers);
+    if (httpHeaders) {
+        codexConfig.http_headers = httpHeaders;
+    }
+    const envHttpHeaders = normalizeStringRecord(source.env_http_headers);
+    if (envHttpHeaders) {
+        codexConfig.env_http_headers = envHttpHeaders;
+    }
+    if (typeof source.bearer_token_env_var === "string" && source.bearer_token_env_var.length > 0) {
+        codexConfig.bearer_token_env_var = source.bearer_token_env_var;
+    }
+    const envVars = normalizeStringArray(source.env_vars);
+    if (envVars && envVars.length > 0) {
+        codexConfig.env_vars = envVars;
+    }
+    if (typeof source.cwd === "string" && source.cwd.length > 0) {
+        codexConfig.cwd = source.cwd;
+    }
+    if (typeof source.persistent === "boolean") {
+        codexConfig.persistent = source.persistent;
+    }
+    if (typeof source.enabled === "boolean") {
+        codexConfig.enabled = source.enabled;
+    }
+    if (typeof source.startup_timeout_sec === "number") {
+        codexConfig.startup_timeout_sec = source.startup_timeout_sec;
+    }
+    if (typeof source.startup_timeout_ms === "number") {
+        codexConfig.startup_timeout_ms = source.startup_timeout_ms;
+    }
+    if (typeof source.tool_timeout_sec === "number") {
+        codexConfig.tool_timeout_sec = source.tool_timeout_sec;
+    }
+    const enabledTools = normalizeStringArray(source.enabled_tools);
+    if (enabledTools && enabledTools.length > 0) {
+        codexConfig.enabled_tools = enabledTools;
+    }
+    const disabledTools = normalizeStringArray(source.disabled_tools);
+    if (disabledTools && disabledTools.length > 0) {
+        codexConfig.disabled_tools = disabledTools;
+    }
+    if (!codexConfig.url && !codexConfig.command) {
+        throw new Error(`MCP server "${name}" must define a url or command for Codex`);
+    }
+    return codexConfig;
+}
+function getAgentState(agent) {
+    const existing = agentState.get(agent);
+    if (existing) {
+        return existing;
+    }
+    const state = {};
+    agentState.set(agent, state);
+    return state;
+}
+async function requireAgentClient(agent) {
+    const state = getAgentState(agent);
+    if (state.client) {
+        return state.client;
+    }
+    if (state.clientPromise) {
+        return state.clientPromise;
+    }
+    const config = state.config ?? buildAgentClientConfig(agent);
+    state.config = config;
+    const clientPromise = createAgentClient(agent.client, config);
+    state.clientPromise = clientPromise;
+    try {
+        const client = await clientPromise;
+        state.client = client;
+        return client;
+    }
+    finally {
+        if (state.clientPromise === clientPromise) {
+            state.clientPromise = undefined;
+        }
+    }
+}
+async function createAgentClient(client, config) {
+    if (client === "claude") {
+        const { ClaudeClient } = await import("../client/claude.js");
+        return new ClaudeClient(config);
+    }
+    if (client === "codex") {
+        const { CodexClient } = await import("../client/codex/index.js");
+        return new CodexClient(config);
+    }
+    throw new Error('Agent client must be "claude" or "codex" to run');
+}
+function normalizeRunParams(params) {
+    if (typeof params === "string") {
+        return { query: params };
+    }
+    return params;
+}
+function isAgentInstance(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.run === "function" &&
+        typeof candidate.runStream === "function" &&
+        typeof candidate.resume === "function" &&
+        typeof candidate.client === "string" &&
+        "definition" in candidate);
+}
+function resolveString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeStringArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const filtered = value.filter((item) => typeof item === "string" && item.length > 0);
+    return filtered.length > 0 ? filtered : undefined;
+}
+function normalizeStringRecord(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const entries = Object.entries(value)
+        .filter(([, entryValue]) => typeof entryValue === "string" && entryValue.length > 0)
+        .map(([key, entryValue]) => [key, entryValue]);
+    if (entries.length === 0) {
+        return undefined;
+    }
+    return Object.fromEntries(entries);
+}
+//# sourceMappingURL=define-agent.js.map