open-multi-agent-kit 0.78.0

package/dist/adapters/kimi/wire-protocol-types.d.ts

@@ -0,0 +1,549 @@
+/**
+ * Kimi Wire Protocol Types — aligned with official spec v1.7
+ *
+ * Source: https://www.kimi.com/code/docs/en/kimi-code-cli/customization/wire-protocol.html
+ * Protocol: JSON-RPC 2.0 based, bidirectional via stdin/stdout
+ */
+export interface JSONRPCRequest<Method extends string, Params> {
+    jsonrpc: "2.0";
+    method: Method;
+    id: string;
+    params: Params;
+}
+export interface JSONRPCNotification<Method extends string, Params> {
+    jsonrpc: "2.0";
+    method: Method;
+    params: Params;
+}
+export interface JSONRPCSuccessResponse<Result> {
+    jsonrpc: "2.0";
+    id: string;
+    result: Result;
+}
+export interface JSONRPCErrorResponse {
+    jsonrpc: "2.0";
+    id: string;
+    error: JSONRPCError;
+}
+export type JSONRPCResponse<Result = unknown> = JSONRPCSuccessResponse<Result> | JSONRPCErrorResponse;
+export interface JSONRPCError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+/** @deprecated Use JSONRPCRequest instead */
+export interface JsonRpcRequest<TParams = unknown> {
+    jsonrpc: "2.0";
+    id: string;
+    method: string;
+    params?: TParams;
+}
+/** @deprecated Use JSONRPCSuccessResponse instead */
+export interface JsonRpcResponse<TResult = unknown> {
+    jsonrpc: "2.0";
+    id: string;
+    result?: TResult;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export declare const JSONRPC_PARSE_ERROR = -32700;
+export declare const JSONRPC_INVALID_REQUEST = -32600;
+export declare const JSONRPC_METHOD_NOT_FOUND = -32601;
+export declare const JSONRPC_INVALID_PARAMS = -32602;
+export declare const JSONRPC_INTERNAL_ERROR = -32603;
+export declare const WIRE_TURN_IN_PROGRESS = -32000;
+export declare const WIRE_LLM_NOT_SET = -32001;
+export declare const WIRE_LLM_NOT_SUPPORTED = -32002;
+export declare const WIRE_LLM_SERVICE_ERROR = -32003;
+export interface ClientInfo {
+    name: string;
+    version?: string;
+}
+export interface ServerInfo {
+    name: string;
+    version: string;
+}
+export interface ClientCapabilities {
+    /** Whether the client can handle QuestionRequest messages */
+    supports_question?: boolean;
+    /** Whether the client supports plan mode */
+    supports_plan_mode?: boolean;
+}
+export interface ServerCapabilities {
+    /** Whether the server supports sending QuestionRequest messages */
+    supports_question?: boolean;
+}
+export interface ExternalTool {
+    /** Tool name, must not conflict with built-in tools */
+    name: string;
+    /** Tool description */
+    description: string;
+    /** Parameter definition in JSON Schema format */
+    parameters: Record<string, unknown>;
+}
+export interface ExternalToolsResult {
+    /** Successfully registered tool names */
+    accepted: string[];
+    /** Failed tool registrations with reasons */
+    rejected: Array<{
+        name: string;
+        reason: string;
+    }>;
+}
+export interface SlashCommandInfo {
+    name: string;
+    description: string;
+    aliases: string[];
+}
+export interface WireHookSubscription {
+    /** Subscription ID, referenced in HookRequest */
+    id: string;
+    /** Event type to subscribe to, e.g. 'PreToolUse', 'Stop' */
+    event: string;
+    /** Regex filter, empty string matches all */
+    matcher?: string;
+    /** Timeout for client response in seconds, default 30 */
+    timeout?: number;
+}
+export interface HooksInfo {
+    /** List of all hook event types supported by the server */
+    supported_events: string[];
+    /** Currently configured hooks statistics */
+    configured: Record<string, number>;
+}
+export interface InitializeParams {
+    /** Protocol version */
+    protocol_version: string;
+    /** Client info, optional */
+    client?: ClientInfo;
+    /** External tool definitions, optional */
+    external_tools?: ExternalTool[];
+    /** Client capabilities, optional */
+    capabilities?: ClientCapabilities;
+    /** Hook subscriptions, optional */
+    hooks?: WireHookSubscription[];
+}
+export interface InitializeResult {
+    /** Protocol version */
+    protocol_version: string;
+    /** Server info */
+    server: ServerInfo;
+    /** Available slash commands */
+    slash_commands: SlashCommandInfo[];
+    /** External tool registration result */
+    external_tools?: ExternalToolsResult;
+    /** Server capabilities */
+    capabilities?: ServerCapabilities;
+    /** Hook system info, optional */
+    hooks?: HooksInfo;
+}
+export type PromptParams = {
+    /** User input, can be plain text or array of content parts */
+    user_input: string | ContentPart[];
+};
+export interface PromptResult {
+    /** Turn end status */
+    status: "finished" | "cancelled" | "max_steps_reached";
+    /** Number of steps executed when status is max_steps_reached */
+    steps?: number;
+}
+export interface SteerParams {
+    /** User input, can be plain text or array of content parts */
+    user_input: string | ContentPart[];
+}
+export interface SteerResult {
+    /** Fixed as "steered" */
+    status: "steered";
+}
+export interface SetPlanModeParams {
+    /** Whether to enable plan mode */
+    enabled: boolean;
+}
+export interface SetPlanModeResult {
+    /** Fixed as "ok" */
+    status: "ok";
+    /** Plan mode state after the call */
+    plan_mode: boolean;
+}
+export type CancelParams = Record<string, never>;
+export type CancelResult = Record<string, never>;
+export type ReplayParams = Record<string, never>;
+export interface ReplayResult {
+    /** Replay end status */
+    status: "finished" | "cancelled";
+    /** Number of replayed events */
+    events: number;
+    /** Number of replayed requests */
+    requests: number;
+}
+export type ContentPart = TextPart | ThinkPart | ImageURLPart | AudioURLPart | VideoURLPart;
+export interface TextPart {
+    type: "text";
+    /** Text content */
+    text: string;
+}
+export interface ThinkPart {
+    type: "think";
+    /** Thinking content */
+    think: string;
+    /** Encrypted thinking content or signature, may be absent */
+    encrypted?: string | null;
+}
+export interface ImageURLPart {
+    type: "image_url";
+    image_url: {
+        /** Image URL, can be data URI */
+        url: string;
+        /** Image ID for distinguishing different images */
+        id?: string | null;
+    };
+}
+export interface AudioURLPart {
+    type: "audio_url";
+    audio_url: {
+        /** Audio URL, can be data URI */
+        url: string;
+        /** Audio ID for distinguishing different audio */
+        id?: string | null;
+    };
+}
+export interface VideoURLPart {
+    type: "video_url";
+    video_url: {
+        /** Video URL, can be data URI */
+        url: string;
+        /** Video ID for distinguishing different video */
+        id?: string | null;
+    };
+}
+export interface TokenUsage {
+    /** Input tokens excluding input_cache_read and input_cache_creation */
+    input_other: number;
+    /** Total output tokens */
+    output: number;
+    /** Cached input tokens */
+    input_cache_read: number;
+    /** Input tokens used for cache creation */
+    input_cache_creation: number;
+}
+export interface TurnBegin {
+    /** User input, can be plain text or array of content parts */
+    user_input: string | ContentPart[];
+}
+export interface TurnEnd {
+}
+export interface StepBegin {
+    /** Step number, starting from 1 */
+    n: number;
+}
+export interface StepInterrupted {
+}
+export interface CompactionBegin {
+}
+export interface CompactionEnd {
+}
+export interface StatusUpdate {
+    /** Context usage ratio, float between 0-1 */
+    context_usage?: number | null;
+    /** Number of tokens currently in the context */
+    context_tokens?: number | null;
+    /** Maximum number of tokens the context can hold */
+    max_context_tokens?: number | null;
+    /** Token usage stats for current step */
+    token_usage?: TokenUsage | null;
+    /** Message ID for current step */
+    message_id?: string | null;
+    /** Whether plan mode is active, null means no change */
+    plan_mode?: boolean | null;
+}
+export interface ToolCallEvent {
+    /** Fixed as "function" */
+    type: "function";
+    /** Tool call ID */
+    id: string;
+    function: {
+        /** Tool name */
+        name: string;
+        /** JSON-format argument string, may be absent */
+        arguments?: string | null;
+    };
+    /** Extra info, may be absent */
+    extras?: object | null;
+}
+export interface ToolCallPart {
+    /** Argument fragment for streaming tool call arguments */
+    arguments_part?: string | null;
+}
+export interface ToolResultEvent {
+    /** Corresponding tool call ID */
+    tool_call_id: string;
+    return_value: ToolReturnValue;
+}
+export interface ToolReturnValue {
+    /** Whether this is an error */
+    is_error: boolean;
+    /** Output content returned to model */
+    output: string | ContentPart[];
+    /** Explanatory message for model */
+    message: string;
+    /** Display blocks shown to user */
+    display: DisplayBlock[];
+    /** Extra debug info, may be absent */
+    extras?: object | null;
+}
+export interface ApprovalResponseEvent {
+    /** Approval request ID */
+    request_id: string;
+    /** Approval result */
+    response: "approve" | "approve_for_session" | "reject";
+    /** Optional feedback text when rejecting */
+    feedback?: string;
+}
+export interface SubagentEvent {
+    /** Associated parent Agent tool call ID */
+    parent_tool_call_id?: string | null;
+    /** Subagent instance ID */
+    agent_id?: string | null;
+    /** Built-in subagent type used by this instance */
+    subagent_type?: string | null;
+    /** Event from subagent, nested Wire message format */
+    event: {
+        type: string;
+        payload: object;
+    };
+}
+export interface SteerInput {
+    /** User input, can be plain text or array of content parts */
+    user_input: string | ContentPart[];
+}
+export interface PlanDisplay {
+    /** Full markdown content of the plan */
+    content: string;
+    /** Path to the plan file */
+    file_path: string;
+}
+export interface HookTriggered {
+    /** Hook event type */
+    event: string;
+    /** Target of the hook */
+    target: string;
+    /** Number of matched hooks running in parallel */
+    hook_count: number;
+}
+export interface HookResolved {
+    /** Hook event type */
+    event: string;
+    /** Same as HookTriggered.target */
+    target: string;
+    /** Aggregate decision */
+    action: "allow" | "block";
+    /** Reason for blocking, empty if allowed */
+    reason: string;
+    /** Wall-clock time for the entire batch in milliseconds */
+    duration_ms: number;
+}
+/** Union of all event payloads */
+export type WireEventPayload = TurnBegin | TurnEnd | StepBegin | StepInterrupted | CompactionBegin | CompactionEnd | StatusUpdate | TextPart | ThinkPart | ImageURLPart | AudioURLPart | VideoURLPart | ToolCallEvent | ToolCallPart | ToolResultEvent | ApprovalResponseEvent | SubagentEvent | SteerInput | PlanDisplay | HookTriggered | HookResolved;
+/** Strongly-typed wire event emitted by the client */
+export type WireEvent = {
+    type: "TurnBegin";
+    payload: TurnBegin;
+} | {
+    type: "TurnEnd";
+} | {
+    type: "StepBegin";
+    payload: StepBegin;
+} | {
+    type: "StepInterrupted";
+} | {
+    type: "CompactionBegin";
+} | {
+    type: "CompactionEnd";
+} | {
+    type: "StatusUpdate";
+    payload: StatusUpdate;
+} | {
+    type: "ContentPart";
+    payload: ContentPart;
+} | {
+    type: "ToolCall";
+    payload: ToolCallEvent;
+} | {
+    type: "ToolCallPart";
+    payload: ToolCallPart;
+} | {
+    type: "ToolResult";
+    payload: ToolResultEvent;
+} | {
+    type: "ApprovalResponse";
+    payload: ApprovalResponseEvent;
+} | {
+    type: "SubagentEvent";
+    payload: SubagentEvent;
+} | {
+    type: "SteerInput";
+    payload: SteerInput;
+} | {
+    type: "PlanDisplay";
+    payload: PlanDisplay;
+} | {
+    type: "HookTriggered";
+    payload: HookTriggered;
+} | {
+    type: "HookResolved";
+    payload: HookResolved;
+};
+export interface ApprovalRequest {
+    /** Request ID */
+    id: string;
+    /** Associated tool call ID */
+    tool_call_id: string;
+    /** Sender (tool name) */
+    sender: string;
+    /** Action description */
+    action: string;
+    /** Detailed description */
+    description: string;
+    /** Display blocks shown to user */
+    display?: DisplayBlock[];
+    /** Where the request originated */
+    source_kind?: "foreground_turn" | "background_agent" | null;
+    /** Source identifier */
+    source_id?: string | null;
+    /** Subagent instance ID if from a subagent */
+    agent_id?: string | null;
+    /** Subagent type if from a subagent */
+    subagent_type?: string | null;
+    /** Human-readable source description */
+    source_description?: string | null;
+}
+export interface ToolCallRequest {
+    /** Tool call ID */
+    id: string;
+    /** Tool name */
+    name: string;
+    /** JSON-format argument string */
+    arguments?: string | null;
+}
+export interface QuestionRequest {
+    /** Request ID */
+    id: string;
+    /** Associated tool call ID */
+    tool_call_id: string;
+    /** Questions list (1–4 questions) */
+    questions: QuestionItem[];
+}
+export interface QuestionItem {
+    /** Question text */
+    question: string;
+    /** Short label, max 12 characters */
+    header?: string;
+    /** Available options (2–4) */
+    options: QuestionOption[];
+    /** Whether multiple options can be selected */
+    multi_select?: boolean;
+}
+export interface QuestionOption {
+    /** Option label */
+    label: string;
+    /** Option description */
+    description?: string;
+}
+export interface QuestionResponse {
+    /** Corresponding request ID */
+    request_id: string;
+    /** Answer mapping */
+    answers: Record<string, string>;
+}
+export interface HookRequest {
+    /** Request ID */
+    id: string;
+    /** Subscription ID */
+    subscription_id: string;
+    /** Hook event type */
+    event: string;
+    /** Target that triggered the hook */
+    target: string;
+    /** Complete event payload */
+    input_data: object;
+}
+export interface HookResponse {
+    /** Corresponding request ID */
+    request_id: string;
+    /** Decision */
+    action: "allow" | "block";
+    /** Reason for blocking */
+    reason: string;
+}
+/** Union of all request payloads */
+export type WireRequestPayload = ApprovalRequest | ToolCallRequest | QuestionRequest | HookRequest;
+/** Strongly-typed wire request received from the agent */
+export type WireRequest = {
+    type: "ApprovalRequest";
+    payload: ApprovalRequest;
+} | {
+    type: "ToolCallRequest";
+    payload: ToolCallRequest;
+} | {
+    type: "QuestionRequest";
+    payload: QuestionRequest;
+} | {
+    type: "HookRequest";
+    payload: HookRequest;
+};
+export type DisplayBlock = UnknownDisplayBlock | BriefDisplayBlock | DiffDisplayBlock | TodoDisplayBlock | ShellDisplayBlock;
+export interface UnknownDisplayBlock {
+    type: string;
+    data: object;
+}
+export interface BriefDisplayBlock {
+    type: "brief";
+    text: string;
+}
+export interface DiffDisplayBlock {
+    type: "diff";
+    path: string;
+    old_text: string;
+    new_text: string;
+}
+export interface TodoDisplayBlock {
+    type: "todo";
+    items: TodoDisplayItem[];
+}
+export interface TodoDisplayItem {
+    title: string;
+    status: "pending" | "in_progress" | "done";
+}
+export interface ShellDisplayBlock {
+    type: "shell";
+    language: string;
+    command: string;
+}
+export declare function isTextPart(part: ContentPart): part is TextPart;
+export declare function isThinkPart(part: ContentPart): part is ThinkPart;
+export declare function isImageURLPart(part: ContentPart): part is ImageURLPart;
+export declare function isAudioURLPart(part: ContentPart): part is AudioURLPart;
+export declare function isVideoURLPart(part: ContentPart): part is VideoURLPart;
+export declare function isWireEventMessage(msg: unknown): msg is {
+    type: string;
+    payload: object;
+};
+export declare function isDisplayBlock(value: unknown): value is DisplayBlock;
+export interface EventParams {
+    type: string;
+    payload: object;
+}
+export interface RequestParams {
+    type: "ApprovalRequest" | "ToolCallRequest" | "QuestionRequest" | "HookRequest";
+    payload: object;
+}
+/** Union of all wire messages (events + requests) */
+export type WireMessage = WireEvent | WireRequest;
+/** Type guard for wire request messages */
+export declare function isWireRequestMessage(msg: unknown): msg is {
+    type: string;
+    payload: object;
+};

package/dist/adapters/kimi/wire-protocol-types.js

@@ -0,0 +1,59 @@
+/**
+ * Kimi Wire Protocol Types — aligned with official spec v1.7
+ *
+ * Source: https://www.kimi.com/code/docs/en/kimi-code-cli/customization/wire-protocol.html
+ * Protocol: JSON-RPC 2.0 based, bidirectional via stdin/stdout
+ */
+// ───────────────────────────────────────────────────────────────
+// Standard Error Codes
+// ───────────────────────────────────────────────────────────────
+export const JSONRPC_PARSE_ERROR = -32700;
+export const JSONRPC_INVALID_REQUEST = -32600;
+export const JSONRPC_METHOD_NOT_FOUND = -32601;
+export const JSONRPC_INVALID_PARAMS = -32602;
+export const JSONRPC_INTERNAL_ERROR = -32603;
+export const WIRE_TURN_IN_PROGRESS = -32000;
+export const WIRE_LLM_NOT_SET = -32001;
+export const WIRE_LLM_NOT_SUPPORTED = -32002;
+export const WIRE_LLM_SERVICE_ERROR = -32003;
+// ───────────────────────────────────────────────────────────────
+// Type Guards
+// ───────────────────────────────────────────────────────────────
+export function isTextPart(part) {
+    return part.type === "text";
+}
+export function isThinkPart(part) {
+    return part.type === "think";
+}
+export function isImageURLPart(part) {
+    return part.type === "image_url";
+}
+export function isAudioURLPart(part) {
+    return part.type === "audio_url";
+}
+export function isVideoURLPart(part) {
+    return part.type === "video_url";
+}
+export function isWireEventMessage(msg) {
+    return (typeof msg === "object" &&
+        msg !== null &&
+        "type" in msg &&
+        typeof msg.type === "string" &&
+        "payload" in msg &&
+        typeof msg.payload === "object");
+}
+export function isDisplayBlock(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "type" in value &&
+        typeof value.type === "string");
+}
+/** Type guard for wire request messages */
+export function isWireRequestMessage(msg) {
+    return (typeof msg === "object" &&
+        msg !== null &&
+        "type" in msg &&
+        typeof msg.type === "string" &&
+        "payload" in msg &&
+        typeof msg.payload === "object");
+}

package/dist/adapters/opencode/opencode-cli-adapter.d.ts

@@ -0,0 +1,9 @@
+/**
+ * OpenCodeCliAdapter — wraps the `opencode` CLI as an AgentRuntime.
+ */
+export interface OpencodeCliAdapterOptions {
+    bin?: string;
+    cwd?: string;
+    env?: Record<string, string>;
+}
+export declare function createOpencodeCliAdapter(options?: OpencodeCliAdapterOptions): import("../../runtime/agent-runtime.js").AgentRuntime;

package/dist/adapters/opencode/opencode-cli-adapter.js

@@ -0,0 +1,43 @@
+/**
+ * OpenCodeCliAdapter — wraps the `opencode` CLI as an AgentRuntime.
+ */
+import { createExternalCliAdapter } from "../../runtime/external-cli-adapter.js";
+export function createOpencodeCliAdapter(options = {}) {
+    const bin = options.bin ?? process.env.OPENCODE_BIN ?? "opencode";
+    return createExternalCliAdapter({
+        id: "opencode-cli",
+        displayName: "OpenCode CLI",
+        bin,
+        cwd: options.cwd,
+        env: options.env,
+        priority: 70,
+        capabilities: {
+            read: true,
+            write: true,
+            shell: true,
+            mcp: false,
+            patch: true,
+            review: true,
+            merge: false,
+            vision: false,
+        },
+        promptTransport: "tempfile",
+        buildArgs(_capsule, prompt) {
+            const promptFile = prompt.promptFile;
+            if (!promptFile) {
+                return [
+                    "run",
+                    "--print",
+                    "Prompt file transport was unavailable; stop and report OMK prompt transport failure.",
+                ];
+            }
+            return [
+                "run",
+                "--print",
+                "--file",
+                promptFile,
+                "Read the attached prompt file exactly and execute the user request it contains. Enforce OMK_TASK_RISK, OMK_APPROVAL_POLICY, and OMK_SANDBOX_MODE from the environment before any write or shell action.",
+            ];
+        },
+    });
+}

package/dist/awareness/classifiers/browser-console-classifier.d.ts

@@ -0,0 +1,3 @@
+import type { BrowserObservation } from "../../browser/browser-observer.js";
+import type { Notice } from "../notice.js";
+export declare function classifyBrowserConsole(observation: BrowserObservation): Promise<Notice | null>;