open-multi-agent-kit 0.78.0

package/dist/cli/runtime/event-bus.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Phase 1 — CliEventBus
+ * Normalizes core onProgress/onTrace events into a unified stream.
+ * Deterministic; no LLM calls here.
+ */
+import type { NormalizedRunEvent } from "./types.js";
+export interface CliEventBus {
+    emit(event: NormalizedRunEvent): void;
+    subscribe(listener: (event: NormalizedRunEvent) => void): () => void;
+    snapshot(): readonly NormalizedRunEvent[];
+}
+export declare function createCliEventBus(): CliEventBus;

package/dist/cli/runtime/event-bus.js

@@ -0,0 +1,31 @@
+/**
+ * Phase 1 — CliEventBus
+ * Normalizes core onProgress/onTrace events into a unified stream.
+ * Deterministic; no LLM calls here.
+ */
+export function createCliEventBus() {
+    const events = [];
+    const listeners = new Set();
+    return {
+        emit(event) {
+            events.push(event);
+            for (const listener of listeners) {
+                try {
+                    listener(event);
+                }
+                catch {
+                    // isolated delivery; one failing listener must not break others
+                }
+            }
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        snapshot() {
+            return events.slice();
+        },
+    };
+}

package/dist/cli/runtime/generic-provider-adapter.d.ts

@@ -0,0 +1,24 @@
+/**
+ * GenericProviderAdapter — wraps the existing provider system into ProviderAdapter interface.
+ *
+ * This is the bridge between the old provider system and the new ProviderAdapter abstraction.
+ * Each provider (kimi, deepseek, openai, etc.) can be wrapped with this adapter.
+ */
+import type { ProviderAdapter, ProviderRequest, ProviderChunk } from "./types.js";
+export interface GenericProviderAdapterOptions {
+    readonly name: string;
+    readonly supportsStreaming?: boolean;
+    readonly supportsToolCalling?: boolean;
+    readonly supportsMcp?: boolean;
+    readonly sendFn: (request: ProviderRequest) => AsyncIterable<ProviderChunk>;
+    readonly abortFn?: () => void;
+}
+/**
+ * Create a ProviderAdapter from a send function.
+ * This is the simplest way to wrap an existing provider.
+ */
+export declare function createGenericProviderAdapter(options: GenericProviderAdapterOptions): ProviderAdapter;
+/**
+ * Create a mock provider adapter for testing.
+ */
+export declare function createMockProviderAdapter(name?: string, responses?: string[]): ProviderAdapter;

package/dist/cli/runtime/generic-provider-adapter.js

@@ -0,0 +1,38 @@
+/**
+ * GenericProviderAdapter — wraps the existing provider system into ProviderAdapter interface.
+ *
+ * This is the bridge between the old provider system and the new ProviderAdapter abstraction.
+ * Each provider (kimi, deepseek, openai, etc.) can be wrapped with this adapter.
+ */
+/**
+ * Create a ProviderAdapter from a send function.
+ * This is the simplest way to wrap an existing provider.
+ */
+export function createGenericProviderAdapter(options) {
+    return {
+        name: options.name,
+        supportsStreaming: options.supportsStreaming ?? true,
+        supportsToolCalling: options.supportsToolCalling ?? false,
+        supportsMcp: options.supportsMcp ?? false,
+        send: options.sendFn,
+        abort: options.abortFn,
+    };
+}
+/**
+ * Create a mock provider adapter for testing.
+ */
+export function createMockProviderAdapter(name = "mock", responses = ["OK"]) {
+    let responseIndex = 0;
+    return {
+        name,
+        supportsStreaming: true,
+        supportsToolCalling: false,
+        supportsMcp: false,
+        async *send(_request) {
+            const response = responses[responseIndex % responses.length];
+            responseIndex++;
+            yield { type: "text", content: response };
+            yield { type: "done" };
+        },
+    };
+}

package/dist/cli/runtime/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Phase 1 — CLI Runtime barrel export
+ * Import from here, not from individual files.
+ */
+export * from "./types.js";
+export * from "./cli-writer.js";
+export * from "./event-bus.js";
+export * from "./cli-runtime.js";
+export * from "./run-controller.js";
+export * from "./task-controller.js";
+export * from "./plan-controller.js";
+export { classifyIntent, quickClassify } from "./intent-classifier.js";
+export { selectCapabilities, createSubAgentCapabilityPlan } from "./capability-selector.js";
+export { buildRuntimeSidecar, createSubAgentSidecar } from "./runtime-sidecar.js";
+export { type SlashCommandHandler, type SlashCommandResult, registerSlashCommand, isSlashCommand, parseSlashCommand, dispatchSlashCommand, listSlashCommands, } from "./command-bus.js";
+export { registerProviderAdapter, getProviderAdapter, listProviderAdapters, hasProviderAdapter, selectProviderAdapter, } from "./provider-adapter-registry.js";
+export { createGenericProviderAdapter, createMockProviderAdapter, } from "./generic-provider-adapter.js";

package/dist/cli/runtime/index.js

@@ -0,0 +1,18 @@
+/**
+ * Phase 1 — CLI Runtime barrel export
+ * Import from here, not from individual files.
+ */
+export * from "./types.js";
+export * from "./cli-writer.js";
+export * from "./event-bus.js";
+export * from "./cli-runtime.js";
+export * from "./run-controller.js";
+export * from "./task-controller.js";
+export * from "./plan-controller.js";
+// Phase 1.5 — RuntimeSidecar + CapabilityPlan pipeline
+export { classifyIntent, quickClassify } from "./intent-classifier.js";
+export { selectCapabilities, createSubAgentCapabilityPlan } from "./capability-selector.js";
+export { buildRuntimeSidecar, createSubAgentSidecar } from "./runtime-sidecar.js";
+export { registerSlashCommand, isSlashCommand, parseSlashCommand, dispatchSlashCommand, listSlashCommands, } from "./command-bus.js";
+export { registerProviderAdapter, getProviderAdapter, listProviderAdapters, hasProviderAdapter, selectProviderAdapter, } from "./provider-adapter-registry.js";
+export { createGenericProviderAdapter, createMockProviderAdapter, } from "./generic-provider-adapter.js";

package/dist/cli/runtime/intent-classifier.d.ts

@@ -0,0 +1,16 @@
+/**
+ * IntentClassifier — rule-based intent classification (no LLM required).
+ *
+ * Architecture Doc §4: User Input → IntentClassifier → CapabilitySelector
+ * Classifies user input into IntentKind for downstream capability selection.
+ */
+import type { ClassifiedIntent, IntentKind } from "./types.js";
+/**
+ * Classify user input into an IntentKind.
+ * Pure rule-based — no LLM call, deterministic, fast.
+ */
+export declare function classifyIntent(input: string, role?: string): ClassifiedIntent;
+/**
+ * Quick intent check — returns just the kind.
+ */
+export declare function quickClassify(input: string, role?: string): IntentKind;

package/dist/cli/runtime/intent-classifier.js

@@ -0,0 +1,113 @@
+/**
+ * IntentClassifier — rule-based intent classification (no LLM required).
+ *
+ * Architecture Doc §4: User Input → IntentClassifier → CapabilitySelector
+ * Classifies user input into IntentKind for downstream capability selection.
+ */
+const INTENT_RULES = [
+    {
+        kind: "debugging",
+        patterns: [/debug|fix|error|failure|bug|trace|investigate|crash|stack\s*trace|exception/i],
+        roleHints: ["debugger"],
+        priority: 10,
+    },
+    {
+        kind: "review",
+        patterns: [/review|audit|check|validate|verify|pr\s*review|code\s*review|security\s*review/i],
+        roleHints: ["reviewer", "security"],
+        priority: 10,
+    },
+    {
+        kind: "test-generation",
+        patterns: [/test|spec|coverage|assertion|unit\s*test|e2e|integration\s*test|tdd/i],
+        roleHints: ["tester", "qa"],
+        priority: 8,
+    },
+    {
+        kind: "refactor",
+        patterns: [/refactor|optimize|clean|improve|simplify|restructure|modernize/i],
+        roleHints: ["refactor"],
+        priority: 8,
+    },
+    {
+        kind: "research",
+        patterns: [/research|investigate|explore|search|discover|analyze|compare|benchmark/i],
+        roleHints: ["researcher", "explorer"],
+        priority: 7,
+    },
+    {
+        kind: "planning",
+        patterns: [/plan|design|architect|strategy|roadmap|spec|specify|rfc|proposal/i],
+        roleHints: ["planner", "architect"],
+        priority: 7,
+    },
+    {
+        kind: "documentation",
+        patterns: [/doc|readme|changelog|comment|javadoc|jsdoc|wiki|guide|tutorial/i],
+        roleHints: ["documenter"],
+        priority: 6,
+    },
+    {
+        kind: "shell-operation",
+        patterns: [/shell|command|run|exec|script|bash|terminal|cli/i],
+        roleHints: ["shell"],
+        priority: 5,
+    },
+    {
+        kind: "chat",
+        patterns: [/chat|talk|ask|question|explain|how|what|why|help/i],
+        roleHints: [],
+        priority: 3,
+    },
+    {
+        kind: "coding",
+        patterns: [/implement|build|create|develop|add|feature|module|component|function|class/i],
+        roleHints: ["coder"],
+        priority: 5,
+    },
+];
+/**
+ * Classify user input into an IntentKind.
+ * Pure rule-based — no LLM call, deterministic, fast.
+ */
+export function classifyIntent(input, role) {
+    const matchedRules = [];
+    let bestKind = "unknown";
+    let bestScore = 0;
+    let bestPriority = 0;
+    for (const rule of INTENT_RULES) {
+        let score = 0;
+        // Pattern match
+        for (const pattern of rule.patterns) {
+            if (pattern.test(input)) {
+                score += 5;
+                matchedRules.push(`pattern:${rule.kind}`);
+            }
+        }
+        // Role hint match
+        if (role && rule.roleHints.includes(role)) {
+            score += 3;
+            matchedRules.push(`role:${rule.kind}`);
+        }
+        // Combined score with priority tiebreaker
+        if (score > bestScore || (score === bestScore && rule.priority > bestPriority)) {
+            bestScore = score;
+            bestPriority = rule.priority;
+            bestKind = rule.kind;
+        }
+    }
+    // Confidence: 0-1 based on match strength
+    const confidence = bestScore > 0 ? Math.min(bestScore / 8, 1.0) : 0.1;
+    return {
+        kind: bestKind,
+        confidence,
+        matchedRules,
+        rawInput: input,
+    };
+}
+/**
+ * Quick intent check — returns just the kind.
+ */
+export function quickClassify(input, role) {
+    return classifyIntent(input, role).kind;
+}

package/dist/cli/runtime/plan-controller.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Phase 1 — Plan Controller
+ * Handles the 'plan' command. Adapter shell around the core planning engine.
+ * Collects events via EventBus and returns a normalized CliExecutionResult.
+ */
+import type { CommandEnvelope, CliExecutionResult } from "./types.js";
+export declare function handlePlanCommand(envelope: CommandEnvelope): Promise<CliExecutionResult>;

package/dist/cli/runtime/plan-controller.js

@@ -0,0 +1,29 @@
+/**
+ * Phase 1 — Plan Controller
+ * Handles the 'plan' command. Adapter shell around the core planning engine.
+ * Collects events via EventBus and returns a normalized CliExecutionResult.
+ */
+import { createCliEventBus } from "./event-bus.js";
+export async function handlePlanCommand(envelope) {
+    const bus = createCliEventBus();
+    // TODO: wire to core planning engine once available
+    bus.emit({
+        type: "task-started",
+        taskId: envelope.runtime.runId ?? "plan-stub",
+        taskTitle: envelope.input.goal ?? "plan",
+        timestamp: new Date().toISOString(),
+    });
+    bus.emit({
+        type: "task-completed",
+        taskId: envelope.runtime.runId ?? "plan-stub",
+        taskTitle: envelope.input.goal ?? "plan",
+        timestamp: new Date().toISOString(),
+    });
+    return {
+        command: "plan",
+        success: true,
+        exitCode: 0,
+        result: { placeholder: true, goal: envelope.input.goal },
+        events: bus.snapshot(),
+    };
+}

package/dist/cli/runtime/provider-adapter-registry.d.ts

@@ -0,0 +1,32 @@
+/**
+ * ProviderAdapterRegistry — provider-neutral adapter registry.
+ *
+ * Replaces Kimi-specific hardcoding with a pluggable adapter pattern.
+ * Each provider (kimi, deepseek, openai, codex, opencode, etc.) registers an adapter.
+ */
+import type { ProviderAdapter } from "./types.js";
+/**
+ * Register a provider adapter.
+ */
+export declare function registerProviderAdapter(adapter: ProviderAdapter): void;
+/**
+ * Get a provider adapter by name.
+ */
+export declare function getProviderAdapter(name: string): ProviderAdapter | undefined;
+/**
+ * List all registered provider adapters.
+ */
+export declare function listProviderAdapters(): readonly ProviderAdapter[];
+/**
+ * Check if a provider adapter is registered.
+ */
+export declare function hasProviderAdapter(name: string): boolean;
+/**
+ * Get the best available provider adapter based on requirements.
+ */
+export declare function selectProviderAdapter(options: {
+    readonly preferProvider?: string;
+    readonly requireToolCalling?: boolean;
+    readonly requireMcp?: boolean;
+    readonly requireStreaming?: boolean;
+}): ProviderAdapter | undefined;

package/dist/cli/runtime/provider-adapter-registry.js

@@ -0,0 +1,60 @@
+/**
+ * ProviderAdapterRegistry — provider-neutral adapter registry.
+ *
+ * Replaces Kimi-specific hardcoding with a pluggable adapter pattern.
+ * Each provider (kimi, deepseek, openai, codex, opencode, etc.) registers an adapter.
+ */
+const adapters = new Map();
+/**
+ * Register a provider adapter.
+ */
+export function registerProviderAdapter(adapter) {
+    adapters.set(adapter.name, adapter);
+}
+/**
+ * Get a provider adapter by name.
+ */
+export function getProviderAdapter(name) {
+    return adapters.get(name);
+}
+/**
+ * List all registered provider adapters.
+ */
+export function listProviderAdapters() {
+    return [...adapters.values()];
+}
+/**
+ * Check if a provider adapter is registered.
+ */
+export function hasProviderAdapter(name) {
+    return adapters.has(name);
+}
+/**
+ * Get the best available provider adapter based on requirements.
+ */
+export function selectProviderAdapter(options) {
+    // Preferred provider first
+    if (options.preferProvider) {
+        const preferred = adapters.get(options.preferProvider);
+        if (preferred && meetsRequirements(preferred, options)) {
+            return preferred;
+        }
+    }
+    // Find first adapter that meets requirements
+    for (const adapter of adapters.values()) {
+        if (meetsRequirements(adapter, options)) {
+            return adapter;
+        }
+    }
+    // Fallback: any adapter
+    return adapters.values().next().value;
+}
+function meetsRequirements(adapter, options) {
+    if (options.requireToolCalling && !adapter.supportsToolCalling)
+        return false;
+    if (options.requireMcp && !adapter.supportsMcp)
+        return false;
+    if (options.requireStreaming && !adapter.supportsStreaming)
+        return false;
+    return true;
+}

package/dist/cli/runtime/provider-event-normalizer.d.ts

@@ -0,0 +1,19 @@
+import type { TaskResult } from "../../contracts/orchestration.js";
+import type { NormalizedRunEvent } from "./types.js";
+export interface NormalizeProviderTaskResultInput {
+    readonly taskId: string;
+    readonly taskTitle?: string;
+    readonly role?: string;
+    readonly result: TaskResult;
+    readonly timestamp?: string;
+    readonly durationMs?: number;
+}
+export interface NormalizeProviderTelemetryEventInput {
+    readonly type: string;
+    readonly nodeId?: string;
+    readonly provider?: string;
+    readonly data?: unknown;
+    readonly timestamp?: string;
+}
+export declare function normalizeProviderTaskResult(input: NormalizeProviderTaskResultInput): readonly NormalizedRunEvent[];
+export declare function normalizeProviderTelemetryEvent(input: NormalizeProviderTelemetryEventInput): NormalizedRunEvent | undefined;

package/dist/cli/runtime/provider-event-normalizer.js

@@ -0,0 +1,150 @@
+export function normalizeProviderTaskResult(input) {
+    const metadata = asRecord(input.result.metadata);
+    if (!metadata)
+        return [];
+    const provider = stringField(metadata, "provider");
+    if (!provider)
+        return [];
+    const timestamp = input.timestamp ?? new Date().toISOString();
+    const common = {
+        provider,
+        taskId: input.taskId,
+        taskTitle: input.taskTitle,
+        role: input.role,
+        requestedProvider: stringField(metadata, "requestedProvider"),
+        authority: stringField(metadata, "providerAuthority"),
+        durationMs: input.durationMs,
+        attempts: numberField(metadata, "providerAttemptCount"),
+        timestamp,
+    };
+    const events = [
+        input.result.success
+            ? { type: "provider-request-completed", ...common }
+            : {
+                type: "provider-request-failed",
+                ...common,
+                error: summarizeProviderError(input.result),
+            },
+    ];
+    const fallback = asRecord(metadata.providerFallback);
+    if (fallback) {
+        const from = stringField(fallback, "from");
+        const to = stringField(fallback, "to");
+        const reason = stringField(fallback, "reason");
+        if (from && to && reason) {
+            events.push({
+                type: "provider-fallback",
+                taskId: input.taskId,
+                from,
+                to,
+                reason,
+                attempts: numberField(fallback, "attempts"),
+                failureKind: stringField(fallback, "failureKind"),
+                timestamp,
+            });
+        }
+    }
+    const assist = asRecord(metadata.providerAssist);
+    if (assist) {
+        const assistProvider = stringField(assist, "provider");
+        const participation = stringField(assist, "participation");
+        const success = booleanField(assist, "success");
+        if (assistProvider && participation === "advisory" && success !== undefined) {
+            events.push({
+                type: "provider-assist",
+                taskId: input.taskId,
+                provider: assistProvider,
+                participation: "advisory",
+                success,
+                model: stringField(assist, "model"),
+                modelTier: stringField(assist, "modelTier"),
+                summary: stringField(assist, "summary"),
+                failureReason: stringField(assist, "failureReason"),
+                timestamp,
+            });
+        }
+    }
+    const skip = asRecord(metadata.providerSkip);
+    if (skip) {
+        const skipProvider = stringField(skip, "provider");
+        const reason = stringField(skip, "reason");
+        if (skipProvider && reason) {
+            events.push({
+                type: "provider-skip",
+                taskId: input.taskId,
+                provider: skipProvider,
+                reason,
+                attempts: numberField(skip, "attempts"),
+                failureKind: stringField(skip, "failureKind"),
+                timestamp,
+            });
+        }
+    }
+    return events;
+}
+export function normalizeProviderTelemetryEvent(input) {
+    const taskId = input.nodeId;
+    const provider = input.provider;
+    if (!taskId || !provider)
+        return undefined;
+    const timestamp = input.timestamp ?? new Date().toISOString();
+    const data = asRecord(input.data);
+    const role = data ? stringField(data, "role") : undefined;
+    const durationMs = data ? numberField(data, "durationMs") : undefined;
+    if (input.type === "provider.request.started") {
+        return {
+            type: "provider-request-started",
+            provider,
+            taskId,
+            role,
+            timestamp,
+        };
+    }
+    if (input.type === "provider.request.completed") {
+        return {
+            type: "provider-request-completed",
+            provider,
+            taskId,
+            role,
+            durationMs,
+            timestamp,
+        };
+    }
+    if (input.type === "provider.request.failed") {
+        return {
+            type: "provider-request-failed",
+            provider,
+            taskId,
+            role,
+            durationMs,
+            error: data ? stringField(data, "error") ?? "provider request failed" : "provider request failed",
+            timestamp,
+        };
+    }
+    return undefined;
+}
+function summarizeProviderError(result) {
+    const message = [result.stderr, result.stdout]
+        .map((value) => value.trim())
+        .find((value) => value.length > 0);
+    if (!message)
+        return "provider request failed";
+    return message.split(/\r?\n/)[0]?.slice(0, 500) || "provider request failed";
+}
+function asRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function numberField(record, key) {
+    const value = record[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function booleanField(record, key) {
+    const value = record[key];
+    return typeof value === "boolean" ? value : undefined;
+}

package/dist/cli/runtime/run-controller.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Phase 1 — Run Controller
+ * Handles the 'run' command. Adapter shell around the core orchestrator.
+ * Collects events via EventBus and returns a normalized CliExecutionResult.
+ */
+import type { CommandEnvelope, CliExecutionResult } from "./types.js";
+export declare function handleRunCommand(envelope: CommandEnvelope): Promise<CliExecutionResult>;

package/dist/cli/runtime/run-controller.js

@@ -0,0 +1,30 @@
+/**
+ * Phase 1 — Run Controller
+ * Handles the 'run' command. Adapter shell around the core orchestrator.
+ * Collects events via EventBus and returns a normalized CliExecutionResult.
+ */
+import { createCliEventBus } from "./event-bus.js";
+export async function handleRunCommand(envelope) {
+    const bus = createCliEventBus();
+    // TODO: wire to core orchestrator once available
+    // For now, emit a placeholder event and return a stub result.
+    bus.emit({
+        type: "task-started",
+        taskId: envelope.runtime.runId ?? "run-stub",
+        taskTitle: envelope.input.goal ?? "run",
+        timestamp: new Date().toISOString(),
+    });
+    bus.emit({
+        type: "task-completed",
+        taskId: envelope.runtime.runId ?? "run-stub",
+        taskTitle: envelope.input.goal ?? "run",
+        timestamp: new Date().toISOString(),
+    });
+    return {
+        command: "run",
+        success: true,
+        exitCode: 0,
+        result: { placeholder: true, goal: envelope.input.goal },
+        events: bus.snapshot(),
+    };
+}

package/dist/cli/runtime/runtime-sidecar.d.ts

@@ -0,0 +1,17 @@
+/**
+ * RuntimeSidecarBuilder — builds RuntimeSidecar from CapabilityPlan + envelope.
+ *
+ * Architecture Doc §4: CapabilitySelector → RuntimeSidecar Builder → NLP Prompt Compiler
+ * Builds the filtered, per-turn runtime context that replaces monolithic config injection.
+ */
+import type { CapabilityPlan, CommandEnvelope, RuntimeSidecar } from "./types.js";
+/**
+ * Build a RuntimeSidecar from a CapabilityPlan and CommandEnvelope.
+ * This is the main entry point for the sidecar pipeline.
+ */
+export declare function buildRuntimeSidecar(plan: CapabilityPlan, envelope: CommandEnvelope): RuntimeSidecar;
+/**
+ * Create a minimal sidecar for sub-agent workers.
+ * Used by ParallelOrchestrator when dispatching tasks.
+ */
+export declare function createSubAgentSidecar(plan: CapabilityPlan, taskGoal: string): RuntimeSidecar;