kimiflare 0.76.1 → 0.78.0

package/dist/sdk/index.d.ts

@@ -1,5 +1,7 @@
 import { Readable, Writable } from 'node:stream';
 
+type Mode = "edit" | "plan" | "auto" | "multi-agent-experimental";
+
 type Role = "system" | "user" | "assistant" | "tool";
 interface ToolCall {
     id: string;
@@ -335,6 +337,23 @@ interface KimiConfig {
     };
     /** Id of the Cloudflare Secrets Store kimi-code uses for provider-key BYOK aliases. */
     secretsStoreId?: string;
+    /** Worker endpoint URL for spawning standalone research/executor workers. */
+    workerEndpoint?: string;
+    /** Max cost per worker in USD (default: 1.0). */
+    workerBudgetUsd?: number;
+    /** Max workers to spawn in parallel (default: 3). */
+    workerMaxParallel?: number;
+    /** Timeout per worker in milliseconds (default: 300000 = 5 min). */
+    workerTimeoutMs?: number;
+    /** Enable multi-agent-experimental mode in the mode cycle. Default: false. */
+    multiAgentEnabled?: boolean;
+    /** Bearer/secret for the worker endpoint (sent as X-Worker-Api-Key). */
+    workerApiKey?: string;
+    /** Name of the deployed multi-agent Worker. Used for tear-down. */
+    workerName?: string;
+    /** When true, after plan workers synthesize, spawn one executor worker
+     *  to implement the synthesized plan and open a PR. Off by default. */
+    autoExecute?: boolean;
 }
 declare const DEFAULT_MODEL = "@cf/moonshotai/kimi-k2.6";
 declare const DEFAULT_REASONING_EFFORT: ReasoningEffort;
@@ -506,7 +525,7 @@ interface SessionStatus {
     isCompacting: boolean;
     pendingSteer: string[];
     pendingFollowUp: string[];
-    currentMode: "plan" | "edit" | "auto";
+    currentMode: Mode;
 }
 type PermissionHandler = (req: PermissionRequest) => Promise<PermissionDecision>;
 interface KimiFlareSession {
@@ -534,7 +553,7 @@ declare function createAgentSession(opts: CreateSessionOptions): Promise<{
 }>;
 
 declare function createDefaultPermissionHandler(options: {
-    mode: "plan" | "edit" | "auto";
+    mode: Mode;
     onRequest?: (req: PermissionRequest) => void;
 }): PermissionHandler;
 

package/dist/sdk/index.js

@@ -505,6 +505,8 @@ function modeDescription(m) {
       return "plan \u2014 read-only research; blocks writes/edits/mutating bash until you exit plan mode";
     case "auto":
       return "auto \u2014 autonomous; auto-approves every tool call (use with care)";
+    case "multi-agent-experimental":
+      return "multi-agent \u2014 experimental; for heavy tasks, spawns parallel research workers automatically";
   }
 }
 function isBlockedInPlanMode(toolName) {
@@ -607,13 +609,16 @@ function systemPromptForMode(m) {
   if (m === "auto") {
     return "\n\nAUTO MODE is active. The user has opted into autonomous execution \u2014 every tool call will be auto-approved. Work efficiently, but do not take irreversible destructive actions (rm -rf, git push --force, dropping tables, etc.) without pausing to describe them in chat first. Prefer smaller reversible steps.";
   }
+  if (m === "multi-agent-experimental") {
+    return "\n\nMULTI-AGENT EXPERIMENTAL MODE is active. For heavy tasks, the coordinator will automatically spawn parallel research workers instead of handling everything locally. Do not manually call spawn_worker \u2014 the coordinator handles worker orchestration. For light or medium tasks, the turn runs locally with normal edit-mode permissions. When workers complete, their findings are synthesized into a coherent plan for your review.";
+  }
   return "";
 }
 var MODES, MUTATING_TOOLS, DANGEROUS_PATTERNS, GIT_READONLY_SUBCOMMANDS, READONLY_COMMANDS;
 var init_mode = __esm({
   "src/mode.ts"() {
     "use strict";
-    MODES = ["edit", "plan", "auto"];
+    MODES = ["edit", "plan", "auto", "multi-agent-experimental"];
     MUTATING_TOOLS = /* @__PURE__ */ new Set(["write", "edit", "bash"]);
     DANGEROUS_PATTERNS = /[<>;`$]|\$\(|\$\{|\|\||\b&\s*$/;
     GIT_READONLY_SUBCOMMANDS = {
@@ -5415,6 +5420,182 @@ var memoryForgetTool = {
   }
 };
 
+// src/tools/spawn-worker.ts
+init_logger();
+var DEFAULT_WORKER_TIMEOUT_MS = 3e5;
+var DEFAULT_WORKER_BUDGET_USD = 1;
+async function callWorkerEndpoint(endpoint, apiKey, payload, signal, timeoutMs = DEFAULT_WORKER_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timer2 = setTimeout(() => controller.abort(), timeoutMs);
+  const url = `${endpoint}/worker`;
+  const headers = {
+    "Content-Type": "application/json",
+    ...apiKey ? { "X-Worker-Api-Key": apiKey } : {}
+  };
+  const body = JSON.stringify(payload);
+  const fetchSignal = signal ?? controller.signal;
+  try {
+    const res = await fetch(url, { method: "POST", headers, body, signal: fetchSignal });
+    if (res.ok) {
+      return await res.json();
+    }
+    if (res.status >= 500 && res.status < 600) {
+      logger.warn("spawn_worker:retrying", { status: res.status, endpoint });
+      const retryRes = await fetch(url, { method: "POST", headers, body, signal: fetchSignal });
+      if (retryRes.ok) {
+        return await retryRes.json();
+      }
+      const text2 = await retryRes.text().catch(() => "");
+      throw new Error(`Worker endpoint returned ${retryRes.status}: ${text2.slice(0, 200)}`);
+    }
+    const text = await res.text().catch(() => "");
+    throw new Error(`Worker endpoint returned ${res.status}: ${text.slice(0, 200)}`);
+  } finally {
+    clearTimeout(timer2);
+  }
+}
+var spawnWorkerTool = {
+  name: "spawn_worker",
+  description: [
+    "Spawn a standalone remote worker agent to perform research or execute a plan.",
+    "Workers run independently with their own full context window and tool access.",
+    "Mode 'plan': read-only research worker that returns structured findings.",
+    "Mode 'execute': write-enabled worker that creates a branch, implements changes, and opens a PR.",
+    "Use for heavy tasks that benefit from parallel research (e.g. 'research OAuth2, testing, and migration')."
+  ].join(" "),
+  parameters: {
+    type: "object",
+    properties: {
+      mode: {
+        type: "string",
+        enum: ["plan", "execute"],
+        description: "Worker mode: 'plan' for read-only research, 'execute' for write + PR."
+      },
+      task: {
+        type: "string",
+        description: "The mission brief for the worker. Be specific about what to research or implement."
+      },
+      context: {
+        type: "string",
+        description: "Additional context about the current project state or goals."
+      },
+      budget: {
+        type: "object",
+        properties: {
+          maxCostUsd: { type: "number", description: "Max cost in USD for this worker. Default 1.0." }
+        }
+      },
+      outputFormat: {
+        type: "string",
+        enum: ["structured", "text"],
+        description: "Output format. Default 'structured'."
+      },
+      tools: {
+        type: "string",
+        enum: ["all", "read-only"],
+        description: "Tool set available to the worker. Default 'all' for plan mode, ignored for execute."
+      },
+      model: {
+        type: "string",
+        description: "Model to use for the worker. Defaults to @cf/moonshotai/kimi-k2.6."
+      },
+      branchName: {
+        type: "string",
+        description: "For execute mode: feature branch name to create."
+      },
+      baseBranch: {
+        type: "string",
+        description: "For execute mode: base branch to fork from. Default 'main'."
+      },
+      prTitle: {
+        type: "string",
+        description: "For execute mode: PR title."
+      },
+      prBody: {
+        type: "string",
+        description: "For execute mode: PR body markdown."
+      }
+    },
+    required: ["mode", "task"],
+    additionalProperties: false
+  },
+  needsPermission: true,
+  render: (args) => ({
+    title: `spawn_worker (${args.mode})`,
+    body: args.task.slice(0, 200)
+  }),
+  async run(args, ctx) {
+    const endpoint = process.env.KIMIFLARE_WORKER_ENDPOINT;
+    if (!endpoint) {
+      const msg = "Worker endpoint not configured. Set KIMIFLARE_WORKER_ENDPOINT or workerEndpoint in config.";
+      const bytes = Buffer.byteLength(msg, "utf8");
+      return { content: msg, rawBytes: bytes, reducedBytes: bytes };
+    }
+    const apiKey = process.env.KIMIFLARE_WORKER_API_KEY;
+    const timeoutMs = readNumberEnv("KIMIFLARE_WORKER_TIMEOUT_MS") ?? DEFAULT_WORKER_TIMEOUT_MS;
+    const budgetUsd = args.budget?.maxCostUsd ?? readNumberEnv("KIMIFLARE_WORKER_BUDGET_USD") ?? DEFAULT_WORKER_BUDGET_USD;
+    const payload = {
+      mode: args.mode,
+      task: args.task,
+      context: args.context ?? "",
+      budget: { maxCostUsd: budgetUsd },
+      outputFormat: args.outputFormat ?? "structured",
+      tools: args.tools ?? (args.mode === "plan" ? "read-only" : "all"),
+      model: args.model ?? "@cf/moonshotai/kimi-k2.6",
+      ...args.mode === "execute" ? {
+        branchName: args.branchName,
+        baseBranch: args.baseBranch ?? "main",
+        prTitle: args.prTitle,
+        prBody: args.prBody
+      } : {}
+    };
+    logger.info("spawn_worker:starting", { mode: args.mode, endpoint, taskPreview: args.task.slice(0, 100) });
+    try {
+      const result = await callWorkerEndpoint(endpoint, apiKey, payload, ctx.signal, timeoutMs);
+      if (result.status !== "completed") {
+        const msg = `Worker ${result.workerId} ${result.status}: ${result.error ?? "unknown error"}`;
+        const bytes2 = Buffer.byteLength(msg, "utf8");
+        return { content: msg, rawBytes: bytes2, reducedBytes: bytes2 };
+      }
+      const lines = [
+        `Worker ${result.workerId} completed.`,
+        `Cost: $${result.costUsd.toFixed(2)} \xB7 Tokens: ${result.tokensUsed.toLocaleString()}`,
+        "",
+        "## Findings",
+        ...result.findings.map(
+          (f) => `- **${f.topic}** (${f.confidence}): ${f.summary} [relevance: ${f.relevance}]`
+        ),
+        "",
+        "## Recommendations",
+        ...result.recommendations.map((r) => `- ${r}`)
+      ];
+      if (result.filesRead.length > 0) {
+        lines.push("", "## Files Read", ...result.filesRead.map((f) => `- ${f}`));
+      }
+      if (result.webSources.length > 0) {
+        lines.push("", "## Web Sources", ...result.webSources.map((u) => `- ${u}`));
+      }
+      const content = lines.join("\n");
+      const bytes = Buffer.byteLength(content, "utf8");
+      return { content, rawBytes: bytes, reducedBytes: bytes };
+    } catch (e) {
+      const err = e;
+      const cause = err.cause;
+      const diagnostic = cause ? `${err.message} (${cause.message})` : err.message;
+      const msg = `Failed to spawn worker: ${diagnostic}`;
+      logger.error("spawn_worker:failed", { error: diagnostic });
+      const bytes = Buffer.byteLength(msg, "utf8");
+      return { content: msg, rawBytes: bytes, reducedBytes: bytes };
+    }
+  }
+};
+function readNumberEnv(name) {
+  const raw = process.env[name];
+  if (!raw) return void 0;
+  const parsed = parseInt(raw, 10);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+
 // src/tools/artifact-store.ts
 var ToolArtifactStore = class {
   artifacts = /* @__PURE__ */ new Map();
@@ -5982,7 +6163,8 @@ var ALL_TOOLS = [
   tasksSetTool,
   memoryRememberTool,
   memoryRecallTool,
-  memoryForgetTool
+  memoryForgetTool,
+  spawnWorkerTool
 ];
 function toPermissionResult(d) {
   if (typeof d === "string") {
@@ -8052,7 +8234,7 @@ function readBooleanEnv(name) {
   if (normalized === "0" || normalized === "false") return false;
   return void 0;
 }
-function readNumberEnv(name) {
+function readNumberEnv2(name) {
   const raw = process.env[name];
   if (!raw) return void 0;
   const parsed = parseInt(raw, 10);
@@ -8110,7 +8292,7 @@ async function loadConfig() {
   const envCoauthor = readCoauthorEnv();
   const envAiGatewayId = process.env.KIMIFLARE_AI_GATEWAY_ID;
   warnIfBlankGatewayId(envAiGatewayId, "env");
-  const envAiGatewayCacheTtl = readNumberEnv("KIMIFLARE_AI_GATEWAY_CACHE_TTL");
+  const envAiGatewayCacheTtl = readNumberEnv2("KIMIFLARE_AI_GATEWAY_CACHE_TTL");
   const envAiGatewaySkipCache = readBooleanEnv("KIMIFLARE_AI_GATEWAY_SKIP_CACHE");
   const envAiGatewayCollectLogPayload = readBooleanEnv(
     "KIMIFLARE_AI_GATEWAY_COLLECT_LOG_PAYLOAD"
@@ -8124,8 +8306,8 @@ async function loadConfig() {
   const imageHistoryTurns = envImageTurns ? parseInt(envImageTurns, 10) : void 0;
   const envMemoryEnabled = readBooleanEnv("KIMIFLARE_MEMORY_ENABLED");
   const envMemoryDbPath = process.env.KIMIFLARE_MEMORY_DB_PATH;
-  const envMemoryMaxAgeDays = readNumberEnv("KIMIFLARE_MEMORY_MAX_AGE_DAYS");
-  const envMemoryMaxEntries = readNumberEnv("KIMIFLARE_MEMORY_MAX_ENTRIES");
+  const envMemoryMaxAgeDays = readNumberEnv2("KIMIFLARE_MEMORY_MAX_AGE_DAYS");
+  const envMemoryMaxEntries = readNumberEnv2("KIMIFLARE_MEMORY_MAX_ENTRIES");
   const envMemoryEmbeddingModel = process.env.KIMIFLARE_MEMORY_EMBEDDING_MODEL;
   const envPlumbingModel = process.env.KIMIFLARE_PLUMBING_MODEL;
   const envMemoryExtractionModel = process.env.KIMIFLARE_MEMORY_EXTRACTION_MODEL;
@@ -8135,6 +8317,7 @@ async function loadConfig() {
   const envShell = process.env.KIMIFLARE_SHELL;
   const envProviderKeys = readProviderKeysEnv();
   const envUnifiedBilling = readBooleanEnv("KIMIFLARE_UNIFIED_BILLING");
+  const envMultiAgentEnabled = readBooleanEnv("KIMIFLARE_MULTI_AGENT_ENABLED");
   if (envAccount && envToken) {
     return {
       accountId: envAccount,
@@ -8171,7 +8354,14 @@ async function loadConfig() {
       providerKeys: envProviderKeys ?? persisted?.providerKeys,
       providerKeyAliases: persisted?.providerKeyAliases,
       secretsStoreId: persisted?.secretsStoreId,
-      unifiedBilling: envUnifiedBilling ?? persisted?.unifiedBilling
+      unifiedBilling: envUnifiedBilling ?? persisted?.unifiedBilling,
+      workerEndpoint: process.env.KIMIFLARE_WORKER_ENDPOINT,
+      workerBudgetUsd: readNumberEnv2("KIMIFLARE_WORKER_BUDGET_USD"),
+      workerMaxParallel: readNumberEnv2("KIMIFLARE_WORKER_MAX_PARALLEL"),
+      workerTimeoutMs: readNumberEnv2("KIMIFLARE_WORKER_TIMEOUT_MS"),
+      multiAgentEnabled: envMultiAgentEnabled,
+      workerApiKey: process.env.KIMIFLARE_WORKER_API_KEY,
+      autoExecute: readBooleanEnv("KIMIFLARE_AUTO_EXECUTE")
     };
   }
   if (persisted) {
@@ -8211,7 +8401,14 @@ async function loadConfig() {
         providerKeys: envProviderKeys ?? parsed.providerKeys,
         providerKeyAliases: parsed.providerKeyAliases,
         secretsStoreId: parsed.secretsStoreId,
-        unifiedBilling: envUnifiedBilling ?? parsed.unifiedBilling
+        unifiedBilling: envUnifiedBilling ?? parsed.unifiedBilling,
+        workerEndpoint: process.env.KIMIFLARE_WORKER_ENDPOINT ?? parsed.workerEndpoint,
+        workerBudgetUsd: parsed.workerBudgetUsd,
+        workerMaxParallel: parsed.workerMaxParallel,
+        workerTimeoutMs: parsed.workerTimeoutMs,
+        multiAgentEnabled: envMultiAgentEnabled ?? parsed.multiAgentEnabled,
+        workerApiKey: process.env.KIMIFLARE_WORKER_API_KEY ?? parsed.workerApiKey,
+        autoExecute: parsed.autoExecute
       };
     }
   }