@goondan/runtime 0.0.3-alpha5 → 0.0.3-alpha8

package/dist/runner/runtime-runner.js

@@ -9,10 +9,13 @@ import { generateText, jsonSchema, stepCountIs, tool, } from 'ai';
 import { createAnthropic } from '@ai-sdk/anthropic';
 import { createGoogleGenerativeAI } from '@ai-sdk/google';
 import { createOpenAI } from '@ai-sdk/openai';
-import { BundleLoader, ConversationStateImpl, ExtensionApiImpl, ExtensionStateManagerImpl, PipelineRegistryImpl, buildToolName, createMinimalToolContext, isJsonObject, loadExtensions, normalizeObjectRef, FileWorkspaceStorage, ToolExecutor, ToolRegistryImpl, WorkspacePaths, } from '../index.js';
+import { BundleLoader, ConversationStateImpl, ExtensionApiImpl, ExtensionStateManagerImpl, PipelineRegistryImpl, RUNTIME_EVENT_TYPES, RuntimeEventBusImpl, buildToolName, createMinimalToolContext, isJsonObject, loadExtensions, normalizeObjectRef, FileWorkspaceStorage, ToolExecutor, ToolRegistryImpl, WorkspacePaths, } from '../index.js';
 import { formatRuntimeInboundUserText, parseAgentToolEventPayload, parseConnectorEventPayload, selectMatchingIngressRule, resolveInboundInstanceKey, resolveRuntimeWorkdir, } from './runtime-routing.js';
 import { buildStepLimitResponse } from './turn-policy.js';
 import { toConversationTurns, toPersistentMessages, } from './conversation-state.js';
+const DEFAULT_MIDDLEWARE_AGENT_REQUEST_TIMEOUT_MS = 15_000;
+const EXTENSION_AGENT_CALL_SOURCE = 'extension-middleware';
+const AGENT_CALL_STACK_METADATA_KEY = '__goondanAgentCallStack';
 const ORCHESTRATOR_PROCESS_NAME = 'orchestrator';
 const REPLACEMENT_STARTUP_TIMEOUT_MS = 5000;
 const CONNECTOR_CHILD_STARTUP_TIMEOUT_MS = 5000;
@@ -1243,6 +1246,163 @@ function buildRuntimeAgentCatalog(runnerPlan, selfAgent) {
         callableAgents,
     };
 }
+function createAgentCallNode(agentName, instanceKey) {
+    return `${agentName}@${instanceKey}`;
+}
+function readAgentCallStack(metadata) {
+    if (!metadata) {
+        return [];
+    }
+    const value = metadata[AGENT_CALL_STACK_METADATA_KEY];
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const stack = [];
+    for (const item of value) {
+        if (typeof item !== 'string' || item.length === 0) {
+            continue;
+        }
+        stack.push(item);
+    }
+    return stack;
+}
+function appendAgentCallStack(stack, node) {
+    if (stack.includes(node)) {
+        return [...stack];
+    }
+    return [...stack, node];
+}
+function withAgentCallStack(metadata, stack) {
+    const next = {};
+    if (metadata) {
+        for (const [key, value] of Object.entries(metadata)) {
+            next[key] = value;
+        }
+    }
+    next[AGENT_CALL_STACK_METADATA_KEY] = stack;
+    return next;
+}
+function toMiddlewareAgentResponseText(response) {
+    if (typeof response === 'string') {
+        return response;
+    }
+    if (response === undefined || response === null) {
+        return '';
+    }
+    return safeJsonStringify(response);
+}
+function createMiddlewareAgentMetadata(input) {
+    const next = {};
+    if (input.metadata) {
+        for (const [key, value] of Object.entries(input.metadata)) {
+            next[key] = value;
+        }
+    }
+    const callerNode = createAgentCallNode(input.callerAgentName, input.callerInstanceKey);
+    const inheritedStack = readAgentCallStack(input.inheritedMetadata);
+    const callStack = appendAgentCallStack(inheritedStack, callerNode);
+    next.callerAgent = input.callerAgentName;
+    next.callerInstanceKey = input.callerInstanceKey;
+    next.callerTurnId = input.callerTurnId;
+    next.callSource = EXTENSION_AGENT_CALL_SOURCE;
+    next[AGENT_CALL_STACK_METADATA_KEY] = callStack;
+    return next;
+}
+function createMiddlewareAgentEvent(input) {
+    const event = {
+        id: createId('agent_event'),
+        type: input.eventType,
+        createdAt: new Date(),
+        traceId: input.traceId,
+        source: {
+            kind: 'agent',
+            name: input.callerAgentName,
+        },
+        input: input.eventInput,
+        instanceKey: input.targetInstanceKey,
+        metadata: input.metadata,
+    };
+    if (input.correlationId) {
+        return {
+            ...event,
+            replyTo: {
+                target: input.callerAgentName,
+                correlationId: input.correlationId,
+            },
+        };
+    }
+    return event;
+}
+function normalizeMiddlewareTarget(target) {
+    const resolved = target.trim();
+    if (resolved.length === 0) {
+        throw new Error('ctx.agents 호출에는 target이 필요합니다.');
+    }
+    return resolved;
+}
+function normalizeMiddlewareInstanceKey(instanceKey, fallback) {
+    if (!instanceKey) {
+        return fallback;
+    }
+    const resolved = instanceKey.trim();
+    return resolved.length > 0 ? resolved : fallback;
+}
+function normalizeMiddlewareTimeoutMs(timeoutMs) {
+    if (typeof timeoutMs === 'number' &&
+        Number.isFinite(timeoutMs) &&
+        Number.isInteger(timeoutMs) &&
+        timeoutMs > 0) {
+        return timeoutMs;
+    }
+    return DEFAULT_MIDDLEWARE_AGENT_REQUEST_TIMEOUT_MS;
+}
+function createMiddlewareAgentsApi(input) {
+    const resolveMetadata = (metadata) => createMiddlewareAgentMetadata({
+        callerAgentName: input.callerAgentName,
+        callerInstanceKey: input.callerInstanceKey,
+        callerTurnId: input.callerTurnId,
+        inheritedMetadata: input.inboundMetadata,
+        metadata,
+    });
+    return {
+        request: async (params) => {
+            const target = normalizeMiddlewareTarget(params.target);
+            const targetInstanceKey = normalizeMiddlewareInstanceKey(params.instanceKey, input.callerInstanceKey);
+            const timeoutMs = normalizeMiddlewareTimeoutMs(params.timeoutMs);
+            const correlationId = createId('corr');
+            const event = createMiddlewareAgentEvent({
+                callerAgentName: input.callerAgentName,
+                traceId: input.traceId,
+                eventType: 'agent.request',
+                eventInput: params.input,
+                targetInstanceKey,
+                metadata: resolveMetadata(params.metadata),
+                correlationId,
+            });
+            const result = await input.runtime.request(target, event, { timeoutMs });
+            return {
+                target: result.target,
+                response: toMiddlewareAgentResponseText(result.response),
+            };
+        },
+        send: async (params) => {
+            const target = normalizeMiddlewareTarget(params.target);
+            const targetInstanceKey = normalizeMiddlewareInstanceKey(params.instanceKey, input.callerInstanceKey);
+            const event = createMiddlewareAgentEvent({
+                callerAgentName: input.callerAgentName,
+                traceId: input.traceId,
+                eventType: 'agent.send',
+                eventInput: params.input,
+                targetInstanceKey,
+                metadata: resolveMetadata(params.metadata),
+            });
+            const result = await input.runtime.send(target, event);
+            return {
+                accepted: result.accepted,
+            };
+        },
+    };
+}
 function mergeToolCatalog(baseCatalog, extensionCatalog) {
     const merged = [];
     for (const item of baseCatalog) {
@@ -1919,6 +2079,15 @@ function createAgentToolRuntime(input) {
             if (!parsed) {
                 throw new Error('agents__request 입력 이벤트 형식이 올바르지 않습니다.');
             }
+            if (target === input.callerAgentName && parsed.instanceKey === input.callerInstanceKey) {
+                throw new Error('agents__request는 동일 agent+instance를 대상으로 호출할 수 없습니다.');
+            }
+            const callerNode = createAgentCallNode(input.callerAgentName, input.callerInstanceKey);
+            const targetNode = createAgentCallNode(target, parsed.instanceKey);
+            const currentCallStack = appendAgentCallStack(readAgentCallStack(parsed.metadata), callerNode);
+            if (currentCallStack.includes(targetNode)) {
+                throw new Error(`agents__request 순환 호출이 감지되었습니다: ${[...currentCallStack, targetNode].join(' -> ')}`);
+            }
             const inboundEvent = {
                 sourceKind: 'agent',
                 sourceName: parsed.sourceName,
@@ -1929,11 +2098,8 @@ function createAgentToolRuntime(input) {
                     from_agent: input.callerAgentName,
                     from_instance: input.callerInstanceKey,
                 },
-                metadata: parsed.metadata,
+                metadata: withAgentCallStack(parsed.metadata, currentCallStack),
             };
-            if (target === input.callerAgentName && inboundEvent.instanceKey === input.callerInstanceKey) {
-                throw new Error('agents__request는 동일 agent+instance를 대상으로 호출할 수 없습니다.');
-            }
             const timeoutMs = options?.timeoutMs;
             const turnResult = await withOptionalTimeout(executeInboundTurn({
                 runtime: input.runtime,
@@ -1955,6 +2121,8 @@ function createAgentToolRuntime(input) {
             if (!parsed) {
                 throw new Error('agents__send 입력 이벤트 형식이 올바르지 않습니다.');
             }
+            const callerNode = createAgentCallNode(input.callerAgentName, input.callerInstanceKey);
+            const currentCallStack = appendAgentCallStack(readAgentCallStack(parsed.metadata), callerNode);
             const inboundEvent = {
                 sourceKind: 'agent',
                 sourceName: parsed.sourceName,
@@ -1965,7 +2133,7 @@ function createAgentToolRuntime(input) {
                     from_agent: input.callerAgentName,
                     from_instance: input.callerInstanceKey,
                 },
-                metadata: parsed.metadata,
+                metadata: withAgentCallStack(parsed.metadata, currentCallStack),
             };
             void executeInboundTurn({
                 runtime: input.runtime,
@@ -2047,7 +2215,7 @@ async function getOrCreateAgentExtensionEnvironment(input) {
     await extensionStateManager.loadAll();
     const extensionToolRegistry = new ToolRegistryImpl();
     const environment = {
-        pipelineRegistry: new PipelineRegistryImpl(),
+        pipelineRegistry: new PipelineRegistryImpl(input.runtime.runtimeEventBus),
         extensionToolRegistry,
         extensionToolExecutor: new ToolExecutor(extensionToolRegistry),
         extensionStateManager,
@@ -2082,6 +2250,14 @@ async function runAgentTurn(input) {
         callerInstanceKey: input.instanceKey,
         logger: input.logger,
     });
+    const middlewareAgentsApi = createMiddlewareAgentsApi({
+        runtime: agentRuntime,
+        callerAgentName: input.plan.name,
+        callerInstanceKey: input.instanceKey,
+        callerTurnId: input.turnId,
+        traceId: input.traceId,
+        inboundMetadata: input.inputEvent.metadata,
+    });
     const extensionEnvironment = await getOrCreateAgentExtensionEnvironment({
         runtime: input.runtime,
         plan: input.plan,
@@ -2102,6 +2278,7 @@ async function runAgentTurn(input) {
             traceId: input.traceId,
             inputEvent: input.inputEvent,
             conversationState,
+            agents: middlewareAgentsApi,
             emitMessageEvent(event) {
                 conversationState.emitMessageEvent(event);
             },
@@ -2148,6 +2325,7 @@ async function runAgentTurn(input) {
                     turn: turnSnapshot,
                     stepIndex: step,
                     conversationState,
+                    agents: middlewareAgentsApi,
                     emitMessageEvent(event) {
                         conversationState.emitMessageEvent(event);
                     },
@@ -2319,6 +2497,19 @@ async function runAgentTurn(input) {
 function logConnectorEvent(plan, event) {
     console.info(`[goondan-runtime][${plan.connectionName}/${plan.connectorName}] emitted event name=${event.name} instanceKey=${event.instanceKey}`);
 }
+function readRuntimeEventInstanceKey(event) {
+    if (!('instanceKey' in event)) {
+        return undefined;
+    }
+    if (typeof event.instanceKey !== 'string') {
+        return undefined;
+    }
+    const trimmedInstanceKey = event.instanceKey.trim();
+    if (trimmedInstanceKey.length === 0) {
+        return undefined;
+    }
+    return trimmedInstanceKey;
+}
 function buildRuntimeEngine(args, plan) {
     const workspacePaths = new WorkspacePaths({
         stateRoot: args.stateRoot,
@@ -2334,6 +2525,68 @@ function buildRuntimeEngine(args, plan) {
         spawnedAgentsByOwner: new Map(),
         instanceWorkdirs: new Map(),
         extensionEnvironments: new Map(),
+        runtimeEventBus: new RuntimeEventBusImpl(),
+        runtimeEventTurnQueueKeys: new Map(),
+    };
+}
+function resolveRuntimeEventQueueKey(runtime, event) {
+    if (event.type === 'turn.started') {
+        const explicitInstanceKey = readRuntimeEventInstanceKey(event);
+        if (explicitInstanceKey !== undefined) {
+            runtime.runtimeEventTurnQueueKeys.set(event.turnId, explicitInstanceKey);
+            return explicitInstanceKey;
+        }
+        return runtime.runtimeEventTurnQueueKeys.get(event.turnId);
+    }
+    const trackedInstanceKey = runtime.runtimeEventTurnQueueKeys.get(event.turnId);
+    if (trackedInstanceKey !== undefined) {
+        return trackedInstanceKey;
+    }
+    const explicitInstanceKey = readRuntimeEventInstanceKey(event);
+    if (explicitInstanceKey !== undefined) {
+        return explicitInstanceKey;
+    }
+    if (event.type === 'turn.completed' || event.type === 'turn.failed') {
+        return undefined;
+    }
+    return undefined;
+}
+function shouldReleaseRuntimeEventTurnKey(event) {
+    return event.type === 'turn.completed' || event.type === 'turn.failed';
+}
+export function attachRuntimeEventPersistence(runtime) {
+    const listener = async (event) => {
+        const instanceKey = resolveRuntimeEventQueueKey(runtime, event);
+        if (instanceKey === undefined) {
+            console.warn(`[goondan-runtime] runtime event dropped type=${event.type} turnId=${event.turnId}: unresolved instance`);
+            if (shouldReleaseRuntimeEventTurnKey(event)) {
+                runtime.runtimeEventTurnQueueKeys.delete(event.turnId);
+            }
+            return;
+        }
+        try {
+            await runtime.storage.appendRuntimeEvent(instanceKey, event);
+        }
+        catch (error) {
+            console.warn(`[goondan-runtime] runtime event persistence failed type=${event.type} instanceKey=${instanceKey}: ${unknownToErrorMessage(error)}`);
+        }
+        finally {
+            if (shouldReleaseRuntimeEventTurnKey(event)) {
+                runtime.runtimeEventTurnQueueKeys.delete(event.turnId);
+            }
+        }
+    };
+    const unsubscribers = [];
+    for (const eventType of RUNTIME_EVENT_TYPES) {
+        const unsubscribe = runtime.runtimeEventBus.on(eventType, listener);
+        unsubscribers.push(unsubscribe);
+    }
+    return () => {
+        for (const unsubscribe of unsubscribers) {
+            unsubscribe();
+        }
+        runtime.runtimeEventBus.clear();
+        runtime.runtimeEventTurnQueueKeys.clear();
     };
 }
 async function requestRuntimeRestart(runtime, reason) {
@@ -2735,60 +2988,82 @@ async function main() {
     const args = parseRunnerArguments(process.argv.slice(2));
     const plan = await preflight(args);
     const runtime = buildRuntimeEngine(args, plan);
-    await preloadAgentExtensions(runtime, plan, args.instanceKey);
-    const stopWatching = args.watch ? startWatchMode(runtime, plan) : () => {
-        // no-op
-    };
-    const runningConnectors = await startConnectors(plan, runtime);
-    console.info(`[goondan-runtime] started instanceKey=${args.instanceKey} pid=${process.pid} swarm=${plan.selectedSwarm.name} connectors=${runningConnectors.length}`);
-    console.info(`[goondan-runtime] active connectors: ${summarizeConnectorPlans(plan.connectors)}`);
-    console.info(`[goondan-runtime] active agents: ${summarizeAgentPlans(plan.agents)}`);
-    const readyMessage = {
-        type: 'ready',
-        instanceKey: args.instanceKey,
-        pid: process.pid,
-    };
-    sendMessage(readyMessage);
+    const detachRuntimeEventPersistence = attachRuntimeEventPersistence(runtime);
     try {
-        await runLifecycle(runningConnectors);
+        await preloadAgentExtensions(runtime, plan, args.instanceKey);
+        const stopWatching = args.watch ? startWatchMode(runtime, plan) : () => {
+            // no-op
+        };
+        let runningConnectors = [];
+        try {
+            runningConnectors = await startConnectors(plan, runtime);
+            console.info(`[goondan-runtime] started instanceKey=${args.instanceKey} pid=${process.pid} swarm=${plan.selectedSwarm.name} connectors=${runningConnectors.length}`);
+            console.info(`[goondan-runtime] active connectors: ${summarizeConnectorPlans(plan.connectors)}`);
+            console.info(`[goondan-runtime] active agents: ${summarizeAgentPlans(plan.agents)}`);
+            const readyMessage = {
+                type: 'ready',
+                instanceKey: args.instanceKey,
+                pid: process.pid,
+            };
+            sendMessage(readyMessage);
+            await runLifecycle(runningConnectors);
+        }
+        finally {
+            stopWatching();
+            await stopConnectors(runningConnectors);
+        }
+        if (runtime.restartRequestedReason !== undefined) {
+            const runnerModulePath = process.argv[1];
+            if (typeof runnerModulePath !== 'string' || runnerModulePath.trim().length === 0) {
+                throw new Error('runtime-runner 모듈 경로를 확인할 수 없습니다.');
+            }
+            const reason = runtime.restartRequestedReason;
+            const replacementPlan = await buildRunnerPlan(runtime.runnerArgs);
+            const replacementInstanceKey = replacementPlan.selectedSwarm.instanceKey;
+            const replacementSwarmName = replacementPlan.selectedSwarm.name;
+            const replacementRunnerArgsWithInstanceKey = upsertRunnerOption(process.argv.slice(2), '--instance-key', replacementInstanceKey);
+            const replacementRunnerArgs = upsertRunnerOption(replacementRunnerArgsWithInstanceKey, '--swarm', replacementSwarmName);
+            const replacementPid = await spawnReplacementRunner({
+                runnerModulePath,
+                runnerArgs: replacementRunnerArgs,
+                stateRoot: runtime.runnerArgs.stateRoot,
+                instanceKey: replacementInstanceKey,
+                bundlePath: runtime.runnerArgs.bundlePath,
+                watch: runtime.runnerArgs.watch,
+                swarmName: replacementSwarmName,
+                env: process.env,
+            });
+            console.info(`[goondan-runtime] replacement orchestrator started pid=${replacementPid} reason=${reason}`);
+        }
     }
     finally {
-        stopWatching();
-        await stopConnectors(runningConnectors);
-    }
-    if (runtime.restartRequestedReason !== undefined) {
-        const runnerModulePath = process.argv[1];
-        if (typeof runnerModulePath !== 'string' || runnerModulePath.trim().length === 0) {
-            throw new Error('runtime-runner 모듈 경로를 확인할 수 없습니다.');
-        }
-        const reason = runtime.restartRequestedReason;
-        const replacementPlan = await buildRunnerPlan(runtime.runnerArgs);
-        const replacementInstanceKey = replacementPlan.selectedSwarm.instanceKey;
-        const replacementSwarmName = replacementPlan.selectedSwarm.name;
-        const replacementRunnerArgsWithInstanceKey = upsertRunnerOption(process.argv.slice(2), '--instance-key', replacementInstanceKey);
-        const replacementRunnerArgs = upsertRunnerOption(replacementRunnerArgsWithInstanceKey, '--swarm', replacementSwarmName);
-        const replacementPid = await spawnReplacementRunner({
-            runnerModulePath,
-            runnerArgs: replacementRunnerArgs,
-            stateRoot: runtime.runnerArgs.stateRoot,
-            instanceKey: replacementInstanceKey,
-            bundlePath: runtime.runnerArgs.bundlePath,
-            watch: runtime.runnerArgs.watch,
-            swarmName: replacementSwarmName,
-            env: process.env,
-        });
-        console.info(`[goondan-runtime] replacement orchestrator started pid=${replacementPid} reason=${reason}`);
+        detachRuntimeEventPersistence();
     }
     process.exit(0);
 }
-void main().catch((error) => {
-    const message = unknownToErrorMessage(error);
-    const startErrorMessage = {
-        type: 'start_error',
-        message,
-    };
-    sendMessage(startErrorMessage);
-    console.error(`[goondan-runtime] startup failure: ${message}`);
-    process.exit(1);
-});
+function isRuntimeRunnerEntryPoint() {
+    const entryArg = process.argv[1];
+    if (typeof entryArg !== 'string' || entryArg.trim().length === 0) {
+        return false;
+    }
+    try {
+        const entryUrl = pathToFileURL(path.resolve(entryArg)).href;
+        return entryUrl === import.meta.url;
+    }
+    catch {
+        return false;
+    }
+}
+if (isRuntimeRunnerEntryPoint()) {
+    void main().catch((error) => {
+        const message = unknownToErrorMessage(error);
+        const startErrorMessage = {
+            type: 'start_error',
+            message,
+        };
+        sendMessage(startErrorMessage);
+        console.error(`[goondan-runtime] startup failure: ${message}`);
+        process.exit(1);
+    });
+}
 //# sourceMappingURL=runtime-runner.js.map