open-multi-agent-kit 0.78.0

package/dist/runtime/slash-commands.d.ts

@@ -0,0 +1,46 @@
+import type { CommandHandler } from "./command-bus.js";
+export interface SlashCommandResult {
+    readonly kind: "status" | "mutation" | "error";
+    readonly command: string;
+    readonly payload: unknown;
+    readonly renderMode: "theme" | "nlp" | "json";
+    readonly sideEffects: readonly RuntimeSideEffect[];
+}
+export type RuntimeSideEffect = {
+    readonly type: "provider_changed";
+    readonly provider: string;
+    readonly model: string;
+} | {
+    readonly type: "thinking_changed";
+    readonly thinking: string;
+    readonly modelVariant: string;
+} | {
+    readonly type: "session_updated";
+    readonly sessionId: string;
+} | {
+    readonly type: "memory_written";
+    readonly memoryId: string;
+} | {
+    readonly type: "theme_changed";
+    readonly theme: string;
+};
+export interface SlashCommandInput {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly rawText: string;
+    readonly state: {
+        readonly provider?: string;
+        readonly model?: string;
+        readonly sessionId?: string;
+        readonly theme?: string;
+        readonly thinking?: string;
+        readonly activeProviderTab?: string;
+    };
+}
+export interface SlashCommandHandler {
+    execute(input: SlashCommandInput): Promise<SlashCommandResult>;
+}
+export declare function createSlashCommandHandler(state?: SlashCommandInput["state"]): CommandHandler;
+export declare function registerSlashCommands(bus: {
+    registerHandler(command: string, handler: CommandHandler): void;
+}, state?: SlashCommandInput["state"]): void;

package/dist/runtime/slash-commands.js

@@ -0,0 +1,321 @@
+import { KNOWN_PROVIDER_IDS, normalizeProviderId, parseProviderModelArg, readProviderRegistry } from "../providers/model-registry.js";
+import { groupProviderModelsByProvider, renderProviderModelTable } from "../providers/model-table.js";
+import { formatThinkingModelVariant, nextThinkingLevel, normalizeThinkingLevel, normalizeThinkingVariant, thinkingLevelsFor } from "../providers/thinking-levels.js";
+function parseSlashInput(rawText) {
+    const trimmed = rawText.trimStart();
+    const match = trimmed.match(/^\/([a-zA-Z0-9_-]+)\s*(.*)/s);
+    if (!match)
+        return { command: "", args: [] };
+    const command = match[1]?.toLowerCase() ?? "";
+    const argStr = match[2]?.trim() ?? "";
+    const args = argStr ? argStr.split(/\s+/) : [];
+    return { command, args };
+}
+function resultToCommandBusResult(result) {
+    const output = JSON.stringify(result.payload, null, 2);
+    const events = [
+        {
+            type: "result",
+            timestamp: new Date().toISOString(),
+            data: {
+                kind: "result",
+                content: renderSlashResultContent(result, output),
+                format: result.renderMode,
+            },
+        },
+    ];
+    return {
+        handled: true,
+        events,
+        output,
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(payload, key, fallback = "unknown") {
+    const value = payload[key];
+    return typeof value === "string" && value.trim() ? value : fallback;
+}
+function stringListValue(payload, key) {
+    const value = payload[key];
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function renderSlashResultContent(result, fallback) {
+    if (result.renderMode === "json" || !isRecord(result.payload))
+        return fallback;
+    const payload = result.payload;
+    const providers = payload.providers;
+    if (typeof providers === "string" && providers.trim())
+        return providers;
+    if (result.kind === "error") {
+        const usage = stringValue(payload, "usage", "Use /help for available commands.");
+        const requested = stringValue(payload, "requestedThinking", "");
+        const supported = stringListValue(payload, "supportedThinkingLevels");
+        return [
+            "\n  Command error",
+            requested ? `  Requested thinking: ${requested}` : undefined,
+            supported.length > 0 ? `  Supported: ${supported.join(" → ")}` : undefined,
+            `  Usage: ${usage}`,
+            "",
+        ].filter((line) => typeof line === "string").join("\n");
+    }
+    switch (result.command) {
+        case "model.set": {
+            const provider = stringValue(payload, "provider");
+            const model = stringValue(payload, "model", "default");
+            const lines = [`\n  Model override for this session: ${provider}/${model}`];
+            const thinking = stringValue(payload, "thinking", "");
+            const modelVariant = stringValue(payload, "modelVariant", "");
+            if (thinking)
+                lines.push(`  Thinking: ${thinking}${modelVariant ? `  (${modelVariant})` : ""}`);
+            lines.push("  Persistent default unchanged; use `omk model use` to persist.\n");
+            return lines.join("\n");
+        }
+        case "think.set": {
+            const thinking = stringValue(payload, "thinking");
+            const modelVariant = stringValue(payload, "modelVariant", "auto");
+            const cycle = stringListValue(payload, "cycle");
+            return [
+                `\n  Thinking variant: ${thinking}`,
+                `  Active: ${modelVariant}`,
+                cycle.length > 0 ? `  Cycle: ${cycle.join(" → ")}` : undefined,
+                "",
+            ].filter((line) => typeof line === "string").join("\n");
+        }
+        case "status.show":
+            return `\n  Status: ${stringValue(payload, "provider")}/${stringValue(payload, "model")}  theme=${stringValue(payload, "theme")}`;
+        case "theme.show": {
+            const current = stringValue(payload, "current", stringValue(payload, "theme", "omk"));
+            const available = stringListValue(payload, "available");
+            return `\n  Theme: ${current}${available.length > 0 ? `\n  Available: ${available.join(", ")}` : ""}`;
+        }
+        case "theme.set":
+            return `\n  Theme updated: ${stringValue(payload, "theme", "omk")}`;
+        case "help": {
+            const commands = stringListValue(payload, "commands");
+            return [`\n  OMK Slash Commands`, ...commands.map((command) => `  - ${command}`), ""].join("\n");
+        }
+        default:
+            return fallback;
+    }
+}
+class ModelCommandHandler {
+    async execute(input) {
+        const raw = input.args.join(" ").trim();
+        if (!raw) {
+            const registry = await readProviderRegistry();
+            return {
+                kind: "status",
+                command: "model.show",
+                payload: {
+                    schema: "omk.runtime.model-groups.v1",
+                    currentProvider: input.state.provider ?? "unknown",
+                    currentModel: input.state.model ?? "unknown",
+                    currentThinking: input.state.thinking,
+                    usage: "/model <provider>/<model>[:level] or /think variant <name>",
+                    providerGroups: groupProviderModelsByProvider(registry),
+                    providers: renderProviderModelTable(registry, {
+                        currentProvider: input.state.provider,
+                        currentModel: input.state.model,
+                        currentThinking: input.state.thinking,
+                        activeProviderTab: input.state.activeProviderTab,
+                    }),
+                },
+                renderMode: "theme",
+                sideEffects: [],
+            };
+        }
+        const parsed = parseProviderModelArg(raw);
+        const normalizedProvider = normalizeProviderId(raw);
+        const providerOnly = !raw.includes(":")
+            && !raw.includes("/")
+            && normalizedProvider !== "auto"
+            && KNOWN_PROVIDER_IDS.includes(normalizedProvider);
+        const provider = providerOnly ? normalizedProvider : parsed.provider ?? input.state.provider ?? "auto";
+        const model = providerOnly ? await defaultModelForProvider(provider) : parsed.model ?? raw;
+        const sideEffects = [
+            { type: "provider_changed", provider, model },
+        ];
+        const payload = { provider, model };
+        if (parsed.thinkingLevel) {
+            const level = normalizeThinkingLevel(parsed.thinkingLevel);
+            const supportedLevels = thinkingLevelsFor(provider, model);
+            if (!level || !supportedLevels.includes(level)) {
+                return {
+                    kind: "error",
+                    command: "model.set",
+                    payload: {
+                        provider,
+                        model,
+                        requestedThinking: parsed.thinkingLevel,
+                        supportedThinkingLevels: supportedLevels,
+                        usage: `/model ${provider}/${model}:${supportedLevels.join("|")}`,
+                    },
+                    renderMode: "theme",
+                    sideEffects: [],
+                };
+            }
+            const modelVariant = formatThinkingModelVariant(model, level);
+            payload.thinking = level;
+            payload.modelVariant = modelVariant;
+            payload.supportedThinkingLevels = supportedLevels;
+            sideEffects.push({ type: "thinking_changed", thinking: level, modelVariant });
+        }
+        return {
+            kind: "mutation",
+            command: "model.set",
+            payload,
+            renderMode: "theme",
+            sideEffects,
+        };
+    }
+}
+async function defaultModelForProvider(provider) {
+    const registry = await readProviderRegistry();
+    return registry.find((entry) => entry.id === provider)?.defaultModel ?? "default";
+}
+class ThinkCommandHandler {
+    async execute(input) {
+        const requested = input.args[0]?.toLowerCase();
+        const levels = thinkingLevelsFor(input.state.provider, input.state.model);
+        const wantsCustomVariant = requested === "variant" || requested === "varint" || requested === "v";
+        if (wantsCustomVariant) {
+            const variant = normalizeThinkingVariant(input.args[1]);
+            if (!variant) {
+                return {
+                    kind: "error",
+                    command: "think.set",
+                    payload: { usage: "/think variant <name>", aliases: ["/think varint <name>"] },
+                    renderMode: "theme",
+                    sideEffects: [],
+                };
+            }
+            const modelVariant = formatThinkingModelVariant(input.state.model, variant);
+            return {
+                kind: "mutation",
+                command: "think.set",
+                payload: { thinking: variant, modelVariant, custom: true, cycle: levels },
+                renderMode: "theme",
+                sideEffects: [{ type: "thinking_changed", thinking: variant, modelVariant }],
+            };
+        }
+        const level = !requested || requested === "next" || requested === "tab"
+            ? nextThinkingLevel(input.state.thinking, input.state.provider, input.state.model)
+            : normalizeThinkingLevel(requested);
+        if (!level || !levels.includes(level)) {
+            return {
+                kind: "error",
+                command: "think.set",
+                payload: { usage: `/think next | ${levels.join(" | ")} | variant <name>`, supported: levels },
+                renderMode: "theme",
+                sideEffects: [],
+            };
+        }
+        const modelVariant = formatThinkingModelVariant(input.state.model, level);
+        return {
+            kind: "mutation",
+            command: "think.set",
+            payload: { thinking: level, modelVariant, cycle: levels },
+            renderMode: "theme",
+            sideEffects: [{ type: "thinking_changed", thinking: level, modelVariant }],
+        };
+    }
+}
+class StatusCommandHandler {
+    async execute(input) {
+        return {
+            kind: "status",
+            command: "status.show",
+            payload: {
+                provider: input.state.provider ?? "unknown",
+                model: input.state.model ?? "unknown",
+                sessionId: input.state.sessionId ?? "none",
+                theme: input.state.theme ?? "default",
+            },
+            renderMode: "theme",
+            sideEffects: [],
+        };
+    }
+}
+class ThemeCommandHandler {
+    async execute(input) {
+        if (!input.args[0]) {
+            return {
+                kind: "status",
+                command: "theme.show",
+                payload: {
+                    current: input.state.theme ?? "omk",
+                    usage: "/theme <name>",
+                    available: ["omk", "night-city", "omk-control", "green-rain", "rust-forge", "neon-circuit", "minimal", "mono", "dark", "light"],
+                },
+                renderMode: "theme",
+                sideEffects: [],
+            };
+        }
+        return {
+            kind: "mutation",
+            command: "theme.set",
+            payload: { theme: input.args[0] },
+            renderMode: "theme",
+            sideEffects: [{ type: "theme_changed", theme: input.args[0] }],
+        };
+    }
+}
+class HelpCommandHandler {
+    async execute() {
+        return {
+            kind: "status",
+            command: "help",
+            payload: {
+                commands: [
+                    "/model [provider/model] - Show or set provider/model by provider group",
+                    "/think [next|medium|high|xhigh|max|variant <name>] - Cycle or set thinking variant",
+                    "/status - Show current runtime status",
+                    "/theme [name] - Show or set theme",
+                    "/help - Show this help",
+                ],
+            },
+            renderMode: "theme",
+            sideEffects: [],
+        };
+    }
+}
+const defaultHandlers = {
+    model: new ModelCommandHandler(),
+    think: new ThinkCommandHandler(),
+    thinking: new ThinkCommandHandler(),
+    status: new StatusCommandHandler(),
+    theme: new ThemeCommandHandler(),
+    help: new HelpCommandHandler(),
+};
+export function createSlashCommandHandler(state = {}) {
+    return async (envelope) => {
+        const { command, args } = parseSlashInput(envelope.rawText);
+        const handler = defaultHandlers[command];
+        if (!handler) {
+            return {
+                handled: false,
+                events: [],
+                output: `Unknown command: /${command}. Use /help for available commands.`,
+            };
+        }
+        const input = {
+            command,
+            args,
+            rawText: envelope.rawText,
+            state,
+        };
+        const result = await handler.execute(input);
+        return resultToCommandBusResult(result);
+    };
+}
+export function registerSlashCommands(bus, state = {}) {
+    const handler = createSlashCommandHandler(state);
+    bus.registerHandler("model", handler);
+    bus.registerHandler("think", handler);
+    bus.registerHandler("thinking", handler);
+    bus.registerHandler("status", handler);
+    bus.registerHandler("theme", handler);
+    bus.registerHandler("help", handler);
+}

package/dist/runtime/stable-json.d.ts

@@ -0,0 +1,9 @@
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+export interface JsonObject {
+    readonly [key: string]: JsonValue | undefined;
+}
+export declare function compareCodepoints(left: string, right: string): number;
+export declare function stableJsonStringify(value: unknown): string;
+export declare function sha256Hex(value: string): string;
+export declare function stableValueHash(value: unknown): string;

package/dist/runtime/stable-json.js

@@ -0,0 +1,45 @@
+import { createHash } from "node:crypto";
+export function compareCodepoints(left, right) {
+    const leftPoints = Array.from(left);
+    const rightPoints = Array.from(right);
+    const length = Math.min(leftPoints.length, rightPoints.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftCode = leftPoints[index]?.codePointAt(0) ?? 0;
+        const rightCode = rightPoints[index]?.codePointAt(0) ?? 0;
+        if (leftCode !== rightCode)
+            return leftCode - rightCode;
+    }
+    return leftPoints.length - rightPoints.length;
+}
+export function stableJsonStringify(value) {
+    if (value === null)
+        return "null";
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (typeof value === "number")
+        return Number.isFinite(value) ? String(value) : "null";
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    if (typeof value === "undefined" || typeof value === "function" || typeof value === "symbol") {
+        return "null";
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableJsonStringify(entry)).join(",")}]`;
+    }
+    if (typeof value === "object") {
+        const objectValue = value;
+        const entries = Object.entries(objectValue)
+            .filter(([, entryValue]) => entryValue !== undefined)
+            .sort(([left], [right]) => compareCodepoints(left, right));
+        return `{${entries
+            .map(([key, entryValue]) => `${JSON.stringify(key)}:${stableJsonStringify(entryValue)}`)
+            .join(",")}}`;
+    }
+    return "null";
+}
+export function sha256Hex(value) {
+    return createHash("sha256").update(value, "utf8").digest("hex");
+}
+export function stableValueHash(value) {
+    return sha256Hex(stableJsonStringify(value));
+}

package/dist/runtime/tool-call-repair.d.ts

@@ -0,0 +1,35 @@
+export interface ToolCallContractRef {
+    readonly name: string;
+}
+export interface RawToolCall {
+    readonly id?: string;
+    readonly name: string;
+    readonly arguments: string;
+}
+export interface RepairedToolCall {
+    readonly id?: string;
+    readonly name: string;
+    readonly input: unknown;
+    readonly source: "declared" | "reasoning" | "visible";
+    readonly signature: string;
+}
+export interface ToolCallRepairInput {
+    readonly declaredCalls?: readonly RawToolCall[];
+    readonly reasoningContent?: string;
+    readonly visibleContent?: string;
+    readonly allowedToolNames: ReadonlySet<string>;
+    readonly toolContracts?: readonly ToolCallContractRef[];
+    readonly stormState?: ToolCallStormState;
+}
+export interface ToolCallStormState {
+    readonly seenSignatures: ReadonlySet<string>;
+}
+export interface ToolCallRepairResult {
+    readonly calls: readonly RepairedToolCall[];
+    readonly suppressed: readonly string[];
+    readonly ignored: readonly string[];
+    readonly stormState: ToolCallStormState;
+}
+export declare function repairToolCalls(input: ToolCallRepairInput): ToolCallRepairResult;
+export declare function repairTruncatedJson(input: string): string;
+export declare function reNestFlatArgs(args: Record<string, unknown>): Record<string, unknown>;

package/dist/runtime/tool-call-repair.js

@@ -0,0 +1,181 @@
+import { stableValueHash } from "./stable-json.js";
+export function repairToolCalls(input) {
+    const knownTools = new Set(input.toolContracts?.map((contract) => contract.name) ?? []);
+    const allowed = new Set([...input.allowedToolNames].filter((name) => knownTools.size === 0 || knownTools.has(name)));
+    const candidates = [
+        ...(input.declaredCalls ?? []).flatMap((call) => normalizeRawCall(call, "declared", allowed)),
+        ...scavengeToolCalls(input.reasoningContent ?? "", "reasoning", allowed),
+        ...scavengeToolCalls(input.visibleContent ?? "", "visible", allowed),
+    ];
+    const seen = new Set(input.stormState?.seenSignatures ?? []);
+    const accepted = [];
+    const suppressed = [];
+    const ignored = [];
+    for (const call of candidates) {
+        if (!allowed.has(call.name)) {
+            ignored.push(call.name);
+            continue;
+        }
+        if (seen.has(call.signature)) {
+            suppressed.push(call.signature);
+            continue;
+        }
+        seen.add(call.signature);
+        accepted.push(call);
+    }
+    return {
+        calls: accepted,
+        suppressed,
+        ignored,
+        stormState: { seenSignatures: seen },
+    };
+}
+export function repairTruncatedJson(input) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return "{}";
+    let output = trimmed;
+    let inString = false;
+    let escaped = false;
+    const stack = [];
+    for (const char of output) {
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (char === "\"") {
+            inString = !inString;
+            continue;
+        }
+        if (inString)
+            continue;
+        if (char === "{")
+            stack.push("}");
+        if (char === "[")
+            stack.push("]");
+        if ((char === "}" || char === "]") && stack.at(-1) === char)
+            stack.pop();
+    }
+    if (inString)
+        output += "\"";
+    while (stack.length > 0)
+        output += stack.pop();
+    return output;
+}
+export function reNestFlatArgs(args) {
+    const nested = {};
+    for (const [key, value] of Object.entries(args)) {
+        const parts = key.split(".").filter(Boolean);
+        if (parts.length <= 1) {
+            nested[key] = value;
+            continue;
+        }
+        let cursor = nested;
+        for (const part of parts.slice(0, -1)) {
+            const existing = cursor[part];
+            if (!isPlainObject(existing)) {
+                cursor[part] = {};
+            }
+            cursor = cursor[part];
+        }
+        cursor[parts.at(-1) ?? key] = value;
+    }
+    return nested;
+}
+function scavengeToolCalls(content, source, allowedToolNames) {
+    const calls = [];
+    const jsonBlocks = extractJsonObjects(content);
+    for (const block of jsonBlocks) {
+        const parsed = parseMaybeToolCall(block);
+        if (!parsed || !allowedToolNames.has(parsed.name))
+            continue;
+        calls.push(...normalizeRawCall(parsed, source, allowedToolNames));
+    }
+    return calls;
+}
+function extractJsonObjects(content) {
+    const blocks = [];
+    let start = -1;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let index = 0; index < content.length; index += 1) {
+        const char = content[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (char === "\"") {
+            inString = !inString;
+            continue;
+        }
+        if (inString)
+            continue;
+        if (char === "{") {
+            if (depth === 0)
+                start = index;
+            depth += 1;
+            continue;
+        }
+        if (char === "}" && depth > 0) {
+            depth -= 1;
+            if (depth === 0 && start >= 0) {
+                blocks.push(content.slice(start, index + 1));
+                start = -1;
+            }
+        }
+    }
+    if (depth > 0 && start >= 0) {
+        blocks.push(repairTruncatedJson(content.slice(start)));
+    }
+    return blocks;
+}
+function parseMaybeToolCall(value) {
+    try {
+        const parsed = JSON.parse(repairTruncatedJson(value));
+        if (!isPlainObject(parsed))
+            return null;
+        const name = typeof parsed.name === "string" ? parsed.name : typeof parsed.tool === "string" ? parsed.tool : null;
+        if (!name)
+            return null;
+        const rawArgs = parsed.arguments ?? parsed.args ?? parsed.input ?? {};
+        return {
+            name,
+            arguments: typeof rawArgs === "string" ? rawArgs : JSON.stringify(rawArgs),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeRawCall(call, source, allowedToolNames) {
+    if (!allowedToolNames.has(call.name))
+        return [];
+    let input;
+    try {
+        input = JSON.parse(repairTruncatedJson(call.arguments));
+    }
+    catch {
+        input = call.arguments;
+    }
+    const normalizedInput = isPlainObject(input) ? reNestFlatArgs(input) : input;
+    const signature = stableValueHash({ name: call.name, input: normalizedInput });
+    return [{
+            id: call.id,
+            name: call.name,
+            input: normalizedInput,
+            source,
+            signature,
+        }];
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/runtime/tool-dispatch-contracts.d.ts

@@ -0,0 +1,8 @@
+import type { OmkToolCall, OmkToolDefinition } from "./tool-registry-contract.js";
+export interface ToolDispatchResult<R = unknown> {
+    readonly call: OmkToolCall;
+    readonly status: "fulfilled" | "rejected";
+    readonly value?: R;
+    readonly reason?: unknown;
+}
+export declare function dispatchToolCallsByContract<A, R>(calls: readonly OmkToolCall<A>[], registry: ReadonlyMap<string, OmkToolDefinition<A, R>>, dispatchOne: (call: OmkToolCall<A>) => Promise<R>): Promise<ToolDispatchResult<R>[]>;

package/dist/runtime/tool-dispatch-contracts.js

@@ -0,0 +1,32 @@
+import { createToolExecutionBatches } from "./tool-registry-contract.js";
+export async function dispatchToolCallsByContract(calls, registry, dispatchOne) {
+    const batches = createToolExecutionBatches(calls, registry);
+    const appended = [];
+    for (const batch of batches) {
+        if (batch.kind === "parallel") {
+            const settled = await Promise.allSettled(batch.calls.map((call) => dispatchOne(call)));
+            settled.forEach((result, index) => {
+                const call = batch.calls[index];
+                if (!call)
+                    return;
+                appended.push(toDispatchResult(call, result));
+            });
+            continue;
+        }
+        for (const call of batch.calls) {
+            try {
+                appended.push({ call, status: "fulfilled", value: await dispatchOne(call) });
+            }
+            catch (reason) {
+                appended.push({ call, status: "rejected", reason });
+            }
+        }
+    }
+    return appended;
+}
+function toDispatchResult(call, result) {
+    if (result.status === "fulfilled") {
+        return { call, status: "fulfilled", value: result.value };
+    }
+    return { call, status: "rejected", reason: result.reason };
+}