@agents-ensemble/core 0.7.0 → 0.9.0

package/dist/conductor/pi-conductor-agent.js

@@ -1,46 +1,58 @@
 import { randomUUID } from 'node:crypto';
-import { Agent, } from '@earendil-works/pi-agent-core';
-import { getEnvApiKey, getModel, getModels, getProviders, } from '@earendil-works/pi-ai/compat';
-import { toPiAgentTools } from './conductor-tool-pi-adapter.js';
-import { PiConductorSession } from './pi-conductor-session.js';
+import { basename, join } from 'node:path';
+import { getModel, getModels, getProviders, } from '@earendil-works/pi-ai/compat';
+import { createAgentSession, createCodemodeExtension, createMcpExtension, createToolSearchExtension, DefaultResourceLoader, SessionManager, SettingsManager, } from '@earendil-works/pi-coding-agent';
+import { createPiConductorAuthContext, resolvePiConductorApiKey, } from './conductor-pi-auth.js';
+import { toPiCodingAgentTools } from './conductor-tool-pi-adapter.js';
 import { expandPiResourcePrompt, formatPiSkillsForPrompt, loadPiResources, } from './pi-resource-loader.js';
-import { createPiMcpBridge, } from './pi-mcp-bridge.js';
+/** Project-local Pi transcript storage used by the conductor backend. */
+export const PI_SESSION_ROOT = '.ensemble/pi/sessions';
+const PI_MCP_STARTUP_OBSERVATION_MS = 2_000;
 /** Resolve the Pi model/auth selection from the standard resource roots. */
 export async function resolvePiModelConfig(options) {
     const resources = await loadPiResources(options);
-    return resolvePiModelConfigFromResources(options, resources);
+    const authContext = await createPiConductorAuthContext(options, resources);
+    return resolvePiModelConfigFromResources(options, resources, authContext);
 }
-function resolvePiModelConfigFromResources(options, resources) {
+async function resolvePiModelConfigFromResources(options, resources, authContext) {
     const env = options.env ?? process.env;
     const settings = resources.settings;
     const selection = resolvePiModelSelection(options.modelId, settings, resources.models);
     const providerConfig = resources.models.providers[selection.provider];
+    const projectProviderConfig = resources.modelsLayers.at(-1)?.providers[selection.provider];
+    const projectDefinesModel = projectProviderConfig?.models?.some((candidate) => candidate.id === selection.modelId);
+    const registryModel = projectDefinesModel
+        ? undefined
+        : authContext.modelRegistry.find(selection.provider, selection.modelId);
+    const apiKey = await resolvePiConductorApiKey({
+        modelRuntime: authContext.modelRuntime,
+        resources,
+        provider: selection.provider,
+        explicitApiKey: options.apiKey,
+        env,
+    });
     const builtInModel = getModel(selection.provider, selection.modelId);
-    const model = resolvePiModel(selection.provider, selection.modelId, providerConfig, builtInModel);
+    const model = resolvePiModel(selection.provider, selection.modelId, providerConfig, registryModel ?? builtInModel, registryModel);
     if (!model) {
         throw new Error(`Pi conductor model "${selection.provider}/${selection.modelId}" was not found in pi-ai or models.json. ` +
             'Set defaultProvider/defaultModel in Pi settings.json or pass a built-in provider/model id.');
     }
-    const apiKey = options.apiKey ??
-        resolvePiAuthKey(resources.authLayers, selection.provider, env) ??
-        resolvePiSettingsApiKey(settings, selection.provider, env) ??
-        resolvePiModelsApiKey(providerConfig, env) ??
-        getEnvApiKey(selection.provider, toProviderEnv(env));
     return {
         provider: selection.provider,
         modelId: selection.modelId,
         model: applyPiProviderRequestConfig(model, providerConfig, apiKey),
+        ...(registryModel ? { usesModelRegistry: true } : {}),
         ...(apiKey !== undefined ? { apiKey } : {}),
     };
 }
 /** Pi implementation of the backend-neutral conductor interface. */
 export class PiConductorAgent {
-    agent;
     session;
-    mcpBridge;
     resources;
+    systemPromptRef;
     agentId;
     modelId;
+    mcpStartupState;
     onStreamText;
     unsubscribe;
     activeSend;
@@ -49,46 +61,21 @@ export class PiConductorAgent {
     hasUsage = false;
     rawCostCents = 0;
     chargedCents = 0;
-    constructor(agent, session, mcpBridge, resources, agentId, modelId, onStreamText) {
-        this.agent = agent;
+    constructor(session, resources, systemPromptRef, agentId, modelId, mcpStartupState, onStreamText) {
         this.session = session;
-        this.mcpBridge = mcpBridge;
         this.resources = resources;
+        this.systemPromptRef = systemPromptRef;
         this.agentId = agentId;
         this.modelId = modelId;
+        this.mcpStartupState = mcpStartupState;
         this.onStreamText = onStreamText;
-        this.unsubscribe = this.agent.subscribe((event) => this.handleEvent(event));
+        this.unsubscribe = this.session.subscribe((event) => this.handleEvent(event));
     }
     static async create(options) {
-        const agentId = randomUUID();
-        const resources = await loadPiResources(options);
-        const resolved = resolvePiModelConfigFromResources(options, resources);
-        const session = await PiConductorSession.create(options.cwd, agentId);
-        const mcpBridge = await createPiMcpBridge(options.mcpServers, {
-            cwd: options.cwd,
-        });
-        try {
-            return new PiConductorAgent(createPiAgent(agentId, options, resolved, session.messages, mcpBridge, resources), session, mcpBridge, resources, agentId, resolved.modelId, options.onStreamText);
-        }
-        catch (error) {
-            await mcpBridge?.close();
-            throw error;
-        }
+        return createPiConductorSession(randomUUID(), options, 'startup');
     }
     static async resume(agentId, options) {
-        const resources = await loadPiResources(options);
-        const resolved = resolvePiModelConfigFromResources(options, resources);
-        const session = await PiConductorSession.resume(options.cwd, agentId);
-        const mcpBridge = await createPiMcpBridge(options.mcpServers, {
-            cwd: options.cwd,
-        });
-        try {
-            return new PiConductorAgent(createPiAgent(agentId, options, resolved, session.messages, mcpBridge, resources), session, mcpBridge, resources, agentId, resolved.modelId, options.onStreamText);
-        }
-        catch (error) {
-            await mcpBridge?.close();
-            throw error;
-        }
+        return createPiConductorSession(agentId, options, 'resume');
     }
     async send(prompt, callbacks) {
         const runId = randomUUID();
@@ -99,6 +86,17 @@ export class PiConductorAgent {
                 error: { message: 'Pi conductor agent is closed.' },
             };
         }
+        if (this.mcpStartupState.error) {
+            return {
+                runId,
+                status: 'error',
+                error: {
+                    message: this.mcpStartupState.error,
+                    code: 'MCP_CONNECTION_FAILED',
+                },
+                modelId: this.modelId,
+            };
+        }
         if (this.activeSend) {
             return {
                 runId,
@@ -109,7 +107,10 @@ export class PiConductorAgent {
         const state = { runId, callbacks };
         this.activeSend = state;
         try {
-            await this.agent.prompt(expandPiResourcePrompt(prompt, this.resources));
+            await this.session.prompt(expandPiResourcePrompt(prompt, this.resources), {
+                expandPromptTemplates: false,
+                source: 'rpc',
+            });
         }
         catch (error) {
             return {
@@ -122,7 +123,7 @@ export class PiConductorAgent {
         finally {
             this.activeSend = undefined;
         }
-        const finalMessage = state.finalMessage ?? lastAssistantMessage(this.agent.state.messages);
+        const finalMessage = state.finalMessage ?? lastAssistantMessage(this.session.state.messages);
         if (!finalMessage) {
             return {
                 runId,
@@ -143,8 +144,9 @@ export class PiConductorAgent {
             modelId: finalMessage.model || this.modelId,
         };
     }
-    /** Pi's core agent has no reload operation; settings are loaded at create. */
-    async reload() { }
+    async reload() {
+        await this.session.reload();
+    }
     async getUsage() {
         return this.hasUsage
             ? {
@@ -157,7 +159,7 @@ export class PiConductorAgent {
     }
     /** Resume recompiles and reinstalls the native system prompt on each run. */
     async setSystemPrompt(systemPrompt) {
-        this.agent.state.systemPrompt = withPiSkills(systemPrompt, this.resources);
+        this.systemPromptRef.value = withPiSkills(systemPrompt, this.resources);
     }
     async close() {
         if (this.closePromise) {
@@ -166,22 +168,20 @@ export class PiConductorAgent {
         this.closed = true;
         this.closePromise = (async () => {
             try {
-                this.agent.abort();
-                await this.agent.waitForIdle();
-                await this.session.appendNewMessages(this.agent.state.messages);
+                await this.session.abort();
             }
             finally {
                 try {
                     this.unsubscribe();
                 }
                 finally {
-                    await this.mcpBridge?.close();
+                    this.session.dispose();
                 }
             }
         })();
         return this.closePromise;
     }
-    async handleEvent(event) {
+    handleEvent(event) {
         const activeSend = this.activeSend;
         if (event.type === 'tool_execution_start') {
             activeSend?.callbacks?.onToolCallStarted?.({
@@ -200,13 +200,6 @@ export class PiConductorAgent {
         if (event.type === 'agent_end' && activeSend) {
             activeSend.finalMessage = lastAssistantMessage(event.messages);
         }
-        if (event.type === 'agent_end') {
-            // Pi's failure/abort event can contain only the failure assistant while
-            // agent.state.messages already contains the user prompt and failure.
-            // Persist the full in-memory suffix so every run is written once in
-            // transcript order; close() uses the same serialized operation.
-            await this.session.appendNewMessages(this.agent.state.messages);
-        }
     }
     recordUsage(message) {
         this.hasUsage = true;
@@ -221,42 +214,274 @@ export function createPiConductorAgentFactory() {
         resume: (agentId, options) => PiConductorAgent.resume(agentId, options),
     };
 }
-function createPiAgent(agentId, options, resolved, messages, mcpBridge, resources) {
-    const tools = uniquePiTools(options.customTools ? toPiAgentTools(options.customTools) : [], mcpBridge?.tools ?? [], resources.extensionTools);
-    return new Agent({
-        initialState: {
-            systemPrompt: withPiSkills(options.systemPrompt, resources),
+async function createPiConductorSession(agentId, options, reason) {
+    const piMcpResolution = { cwd: options.cwd };
+    // Validate the harness-resolved map before creating the SDK session so an
+    // unsupported transport fails with an actionable Pi-specific error.
+    if (options.mcpServers)
+        loadPiMcpConfig(options.mcpServers, piMcpResolution);
+    const resources = await loadPiResources(options);
+    const authContext = await createPiConductorAuthContext(options, resources);
+    const resolved = await resolvePiModelConfigFromResources(options, resources, authContext);
+    if (options.apiKey !== undefined) {
+        await authContext.modelRuntime.setRuntimeApiKey(resolved.provider, options.apiKey);
+    }
+    const sessionDir = join(options.cwd, PI_SESSION_ROOT);
+    let sessionManager;
+    let previousSessionFile;
+    if (reason === 'resume') {
+        previousSessionFile = SessionManager.findById(options.cwd, agentId, sessionDir);
+        if (!previousSessionFile) {
+            throw new Error(`Pi session not found for resume (sessionId=${agentId}, cwd=${options.cwd}, ` +
+                `sessionsRoot=${PI_SESSION_ROOT})`);
+        }
+        sessionManager = SessionManager.open(previousSessionFile, sessionDir, options.cwd);
+    }
+    else {
+        sessionManager = SessionManager.create(options.cwd, sessionDir, { id: agentId });
+    }
+    const systemPromptRef = {
+        value: withPiSkills(options.systemPrompt, resources),
+    };
+    const settingsManager = SettingsManager.create(options.cwd, authContext.agentDir);
+    const resourceLoader = new DefaultResourceLoader({
+        cwd: options.cwd,
+        agentDir: authContext.agentDir,
+        settingsManager,
+        noExtensions: true,
+        noSkills: true,
+        noPromptTemplates: true,
+        noThemes: true,
+        noContextFiles: true,
+        systemPrompt: systemPromptRef.value,
+        extensionFactories: [
+            createMcpExtension({
+                loadConfig: () => loadPiMcpConfig(options.mcpServers, piMcpResolution),
+            }),
+            createCodemodeExtension({ mode: 'on' }),
+            createToolSearchExtension(),
+            createPiSystemPromptExtension(systemPromptRef),
+        ],
+    });
+    await resourceLoader.reload();
+    let session;
+    try {
+        const mcpStartupState = {};
+        const result = await createAgentSession({
+            cwd: options.cwd,
+            agentDir: authContext.agentDir,
+            modelRuntime: authContext.modelRuntime,
             model: resolved.model,
-            // Do not add Pi's built-in coding tools. Harness tools are the complete
-            // loadout; repository work is delegated to worker ACP sessions.
-            tools,
-            messages: [...messages],
+            sessionManager,
+            settingsManager,
+            resourceLoader,
+            // Keep repository operations in worker ACP sessions. The conductor gets
+            // only harness tools plus the official MCP/codemode extensions.
+            noTools: 'builtin',
+            customTools: uniquePiTools(options.customTools ? toPiCodingAgentTools(options.customTools) : [], resources.extensionTools.map(toPiCodingAgentTool)),
+            sessionStartEvent: {
+                type: 'session_start',
+                reason,
+                ...(previousSessionFile ? { previousSessionFile } : {}),
+            },
+        });
+        session = result.session;
+        await session.bindExtensions({
+            mode: 'rpc',
+            uiContext: createPiHeadlessExtensionUi(mcpStartupState),
+            onError: (error) => {
+                if (error.extensionPath.includes('mcp')) {
+                    mcpStartupState.error =
+                        `Pi MCP extension failed during ${error.event}: ${error.error}`;
+                }
+            },
+        });
+        await observePiMcpStartup(session, options.mcpServers, mcpStartupState);
+        if (mcpStartupState.error) {
+            throw new Error(mcpStartupState.error);
+        }
+        return new PiConductorAgent(session, resources, systemPromptRef, agentId, resolved.modelId, mcpStartupState, options.onStreamText);
+    }
+    catch (error) {
+        session?.dispose();
+        throw error;
+    }
+}
+function createPiHeadlessExtensionUi(state) {
+    return {
+        select: async () => undefined,
+        confirm: async () => false,
+        input: async () => undefined,
+        notify: (message, type) => {
+            if (message.startsWith('MCP failed to load:') ||
+                (type === 'warning' && message.startsWith('MCP servers need attention:'))) {
+                state.error = `Pi MCP startup failed: ${message}`;
+            }
         },
-        sessionId: agentId,
-        getApiKey: (provider) => provider === resolved.provider
-            ? (resolved.apiKey ?? getEnvApiKey(provider))
-            : getEnvApiKey(provider),
-    });
+        onTerminalInput: () => () => { },
+        setStatus: () => { },
+        setWorkingMessage: () => { },
+        setWorkingVisible: () => { },
+        setWorkingIndicator: () => { },
+        setHiddenThinkingLabel: () => { },
+        setWidget: () => { },
+        setFooter: () => { },
+        setHeader: () => { },
+        setTitle: () => { },
+        pasteToEditor: () => { },
+        setEditorText: () => { },
+        getEditorText: () => '',
+        editor: async () => undefined,
+        custom: async () => undefined,
+        getToolsExpanded: () => false,
+        setToolsExpanded: () => { },
+        get theme() {
+            return undefined;
+        },
+        getAllThemes: () => [],
+        getTheme: () => undefined,
+        setTheme: () => ({ success: false, error: 'Headless conductor has no theme.' }),
+    };
+}
+async function observePiMcpStartup(session, servers, state) {
+    const names = Object.keys(servers ?? {});
+    if (names.length === 0 || typeof session.getAllTools !== 'function')
+        return;
+    const deadline = Date.now() + PI_MCP_STARTUP_OBSERVATION_MS;
+    while (Date.now() < deadline && !state.error) {
+        const tools = session.getAllTools();
+        if (names.every((name) => {
+            const namespace = name.replace(/[^A-Za-z0-9_]/g, '_');
+            return tools.some((tool) => tool.name.startsWith(`mcp__${namespace}__`));
+        })) {
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+}
+function toPiCodingAgentTool(tool) {
+    return {
+        name: tool.name,
+        label: tool.label,
+        description: tool.description,
+        parameters: tool.parameters,
+        execute: (toolCallId, params, signal, onUpdate) => tool.execute(toolCallId, params, signal, onUpdate),
+    };
 }
 function uniquePiTools(...groups) {
     const tools = new Map();
     for (const group of groups) {
         for (const tool of group) {
-            if (!tools.has(tool.name)) {
+            if (!tools.has(tool.name))
                 tools.set(tool.name, tool);
-            }
         }
     }
     return [...tools.values()];
 }
+function createPiSystemPromptExtension(systemPromptRef) {
+    return (pi) => {
+        pi.on('before_agent_start', (event) => {
+            // Change only Pi's custom preamble. MCP/codemode sections assembled by
+            // the official extensions remain intact on every request and resume.
+            event.systemPromptOptions.customPrompt = systemPromptRef.value;
+        });
+    };
+}
+export function loadPiMcpConfig(servers, options = {}) {
+    const resolution = {
+        cwd: options.cwd ?? process.cwd(),
+        env: options.env ?? process.env,
+    };
+    return {
+        servers: Object.entries(servers ?? {}).map(([name, config]) => ({
+            name,
+            config: toPiMcpServerConfig(name, config, resolution),
+            source: '<agents-ensemble-resolved-mcp.json>',
+            scope: 'project',
+        })),
+        autoEnableCodemode: true,
+        errors: [],
+    };
+}
+function toPiMcpServerConfig(name, config, resolution) {
+    if (config.type === 'sse') {
+        throw new Error(`MCP server "${name}" uses SSE, which Pi 1.0 does not support. ` +
+            'Use stdio or streamable HTTP instead.');
+    }
+    if (config.command) {
+        return {
+            type: 'stdio',
+            command: expandPiMcpString(config.command, name, 'command', resolution),
+            ...(config.args
+                ? {
+                    args: config.args.map((value, index) => expandPiMcpString(value, name, `args[${index}]`, resolution)),
+                }
+                : {}),
+            ...(config.env
+                ? { env: expandPiMcpRecord(config.env, name, 'env', resolution) }
+                : {}),
+            ...(config.cwd
+                ? { cwd: expandPiMcpString(config.cwd, name, 'cwd', resolution) }
+                : {}),
+        };
+    }
+    if (config.url) {
+        return {
+            type: 'http',
+            url: expandPiMcpString(config.url, name, 'url', resolution),
+            ...(config.headers
+                ? { headers: expandPiMcpRecord(config.headers, name, 'headers', resolution) }
+                : {}),
+            ...(config.auth
+                ? {
+                    oauth: {
+                        clientId: expandPiMcpString(config.auth.CLIENT_ID, name, 'auth.CLIENT_ID', resolution),
+                        ...(config.auth.CLIENT_SECRET !== undefined
+                            ? {
+                                clientSecret: expandPiMcpString(config.auth.CLIENT_SECRET, name, 'auth.CLIENT_SECRET', resolution),
+                            }
+                            : {}),
+                        ...(config.auth.scopes?.length
+                            ? {
+                                scope: config.auth.scopes
+                                    .map((value, index) => expandPiMcpString(value, name, `auth.scopes[${index}]`, resolution))
+                                    .join(' '),
+                            }
+                            : {}),
+                    },
+                }
+                : {}),
+        };
+    }
+    throw new Error(`MCP server "${name}" has no command or URL. ` +
+        'Use a valid resolved stdio or streamable HTTP configuration.');
+}
+function expandPiMcpRecord(values, server, field, resolution) {
+    return Object.fromEntries(Object.entries(values).map(([key, value]) => [
+        key,
+        expandPiMcpString(value, server, `${field}.${key}`, resolution),
+    ]));
+}
+function expandPiMcpString(value, server, field, resolution) {
+    return value.replace(/\$\{env:([A-Za-z_][A-Za-z0-9_]*)\}|\$\{workspaceFolder(Basename)?\}/g, (placeholder, variable, basenameSuffix) => {
+        if (variable) {
+            const resolved = resolution.env[variable];
+            if (resolved === undefined) {
+                throw new Error(`MCP server "${server}" references missing environment variable "${variable}" in ${field}.`);
+            }
+            return resolved;
+        }
+        return basenameSuffix ? basename(resolution.cwd) : resolution.cwd;
+    });
+}
 function withPiSkills(systemPrompt, resources) {
     return `${systemPrompt}${formatPiSkillsForPrompt(resources.skills)}`;
 }
-function resolvePiModel(provider, modelId, providerConfig, builtInModel) {
+function resolvePiModel(provider, modelId, providerConfig, builtInModel, registryModel) {
     const definition = providerConfig?.models?.find((candidate) => candidate.id === modelId);
-    let model = definition && providerConfig
+    let model = registryModel ?? (definition && providerConfig
         ? createPiModel(provider, providerConfig, definition)
-        : builtInModel;
+        : builtInModel);
     if (!model)
         return undefined;
     const override = providerConfig?.modelOverrides?.[modelId];
@@ -341,7 +566,16 @@ function numberValue(value, fallback) {
     return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
 }
 function mergePiHeaders(...headers) {
-    return Object.assign({}, ...headers.filter((value) => Boolean(value)));
+    const merged = {};
+    for (const headerSet of headers) {
+        if (!headerSet)
+            continue;
+        for (const [name, value] of Object.entries(headerSet)) {
+            if (value !== null)
+                merged[name] = value;
+        }
+    }
+    return merged;
 }
 function mergePiObjects(...values) {
     const merged = {};
@@ -383,50 +617,6 @@ function resolvePiModelSelection(requestedModelId, settings, models) {
     }
     return { provider, modelId };
 }
-function resolvePiAuthKey(authLayers, provider, env) {
-    for (let index = authLayers.length - 1; index >= 0; index -= 1) {
-        const value = resolvePiAuthEntry(authLayers[index]?.[provider], env);
-        if (value !== undefined)
-            return value;
-    }
-    return undefined;
-}
-function resolvePiAuthEntry(entry, env) {
-    if (typeof entry === 'string')
-        return expandEnvReference(entry, env);
-    if (!isRecord(entry))
-        return undefined;
-    for (const key of ['key', 'apiKey', 'token', 'accessToken', 'access']) {
-        const value = entry[key];
-        if (typeof value === 'string') {
-            return expandEnvReference(value, env);
-        }
-    }
-    return undefined;
-}
-function resolvePiModelsApiKey(providerConfig, env) {
-    return providerConfig?.apiKey
-        ? expandEnvReference(providerConfig.apiKey, env)
-        : undefined;
-}
-function resolvePiSettingsApiKey(settings, provider, env) {
-    if (typeof settings.apiKey === 'string') {
-        return expandEnvReference(settings.apiKey, env);
-    }
-    if (!isRecord(settings.apiKeys))
-        return undefined;
-    const value = settings.apiKeys[provider];
-    return typeof value === 'string' ? expandEnvReference(value, env) : undefined;
-}
-function expandEnvReference(value, env) {
-    if (value.startsWith('!')) {
-        // Pi supports command-backed credentials. Do not execute arbitrary commands
-        // from a harness config; #356/#358 can define a deliberate credential hook.
-        return undefined;
-    }
-    const variable = /^\$\{([^}]+)\}$/.exec(value) ?? /^\$([A-Za-z_][A-Za-z0-9_]*)$/.exec(value);
-    return variable ? env[variable[1]] : value;
-}
 function normalizeConfiguredString(value) {
     if (typeof value !== 'string')
         return undefined;
@@ -481,7 +671,4 @@ function isRecord(value) {
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function toProviderEnv(env) {
-    return Object.fromEntries(Object.entries(env).filter((entry) => typeof entry[1] === 'string'));
-}
 //# sourceMappingURL=pi-conductor-agent.js.map