@theokit/sdk 2.2.0 → 2.4.0

package/dist/a2a/index.js

@@ -1,4 +1,4 @@
-import { existsSync, realpathSync, lstatSync, readlinkSync, mkdirSync, readFileSync, readdirSync } from 'fs';
+import { existsSync, realpathSync, mkdirSync, lstatSync, readlinkSync, readFileSync, readdirSync } from 'fs';
 import { randomUUID, createHash, randomBytes } from 'crypto';
 import { join, dirname, resolve, sep, relative, isAbsolute } from 'path';
 import { stat, mkdir, readFile, rename, rm, readdir, appendFile, open, unlink, statfs, access } from 'fs/promises';
@@ -3000,6 +3000,18 @@ var init_cloud_agent = __esm({
           "fork"
         );
       }
+      /**
+       * The continuation driver re-sends against a stateful local session; the
+       * cloud runtime manages its own continuation policy server-side (M1 Phase 3).
+       *
+       * @public
+       */
+      runToCompletion() {
+        throw new UnsupportedRunOperationError(
+          "Agent.runToCompletion() is not supported on cloud agents. Cloud runtime manages continuation server-side. Use a local agent.",
+          "runToCompletion"
+        );
+      }
       /**
        * Personality presets require consistent server-side enforcement that
        * the cloud runtime (pre-release) does not yet provide. Reject explicitly
@@ -4907,6 +4919,8 @@ function parseSubagentMarkdown(raw, filename) {
   if (fields.model !== void 0) {
     definition.model = fields.model === "inherit" ? "inherit" : { id: fields.model };
   }
+  const tools = fields.tools?.split(/[\s,]+/).map((t) => t.trim()).filter((t) => t.length > 0);
+  if (tools !== void 0 && tools.length > 0) definition.tools = tools;
   return { name, definition };
 }
 function splitFrontmatter2(raw, filename) {
@@ -5110,25 +5124,33 @@ ${lines.join("\n")}
   }
 });
 
+// src/internal/runtime/skills/skills-block.ts
+function buildSkillsBlock(skills) {
+  if (skills.length === 0) return void 0;
+  const lines = skills.map(
+    (skill) => `  - ${escapeBlockBody(skill.name)}: ${escapeBlockBody(skill.description)}`
+  );
+  return `<skills>
+${lines.join("\n")}
+</skills>`;
+}
+var init_skills_block = __esm({
+  "src/internal/runtime/skills/skills-block.ts"() {
+    init_escape();
+  }
+});
+
 // src/internal/runtime/system-prompt/sources/skills-provider.ts
 var SkillsPromptProvider;
 var init_skills_provider = __esm({
   "src/internal/runtime/system-prompt/sources/skills-provider.ts"() {
-    init_escape();
+    init_skills_block();
     SkillsPromptProvider = class {
       id = "skills";
       priority = 20;
       contribute(ctx) {
         if (ctx.skillsAutoInject === false) return Promise.resolve(void 0);
-        if (ctx.skills.length === 0) return Promise.resolve(void 0);
-        const lines = ctx.skills.map((skill) => {
-          const name = escapeBlockBody(skill.name);
-          const description = escapeBlockBody(skill.description);
-          return `  - ${name}: ${description}`;
-        });
-        return Promise.resolve(`<skills>
-${lines.join("\n")}
-</skills>`);
+        return Promise.resolve(buildSkillsBlock(ctx.skills));
       }
     };
   }
@@ -6384,36 +6406,71 @@ var init_skill_frontmatter = __esm({
     init_yaml_frontmatter();
   }
 });
-function tryParseSkill(raw, fallbackName, source) {
+async function discoverSkills(dir, options) {
+  let entries;
+  try {
+    entries = await readWorkspaceDir(dir, "skills_read_error", "skills directory");
+  } catch {
+    return [];
+  }
+  const skills = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    let skillDir;
+    try {
+      skillDir = safePathJoin(dir, entry.name);
+      assertNoSymlinkEscape(skillDir, dir);
+    } catch {
+      continue;
+    }
+    const skillPath = join(skillDir, "SKILL.md");
+    let raw;
+    try {
+      raw = await readFile(skillPath, "utf8");
+    } catch {
+      continue;
+    }
+    const skill = tryParseSkill(raw, entry.name, skillPath, options);
+    if (skill !== void 0) skills.push(skill);
+  }
+  return skills;
+}
+function tryParseSkill(raw, fallbackName, source, options) {
   try {
     const frontmatter = parseSkillFrontmatter(raw, fallbackName);
-    const metadata = {
+    const skill = {
       name: frontmatter.name,
       description: frontmatter.description,
       source
     };
-    if (frontmatter.category !== void 0) metadata.category = frontmatter.category;
-    if (frontmatter.dependencies !== void 0) metadata.dependencies = frontmatter.dependencies;
-    return metadata;
+    if (frontmatter.category !== void 0) skill.category = frontmatter.category;
+    if (frontmatter.dependencies !== void 0) skill.dependencies = frontmatter.dependencies;
+    return skill;
   } catch (cause) {
     if (cause instanceof ConfigurationError) {
-      const code = cause.code ?? "unknown";
-      process.stderr.write(
-        `[theokit-sdk] skill ${fallbackName} skipped (${code}): ${cause.message}
-`
-      );
+      options?.onInvalidSkill?.({
+        name: fallbackName,
+        source,
+        code: cause.code ?? "unknown",
+        message: cause.message
+      });
       return void 0;
     }
     throw cause;
   }
 }
-var SkillsManager;
-var init_skills_manager = __esm({
-  "src/internal/runtime/skills/skills-manager.ts"() {
+var init_discover_skills = __esm({
+  "src/internal/runtime/skills/discover-skills.ts"() {
     init_errors();
     init_path_guard();
     init_workspace_dir();
     init_skill_frontmatter();
+  }
+});
+var SkillsManager;
+var init_skills_manager = __esm({
+  "src/internal/runtime/skills/skills-manager.ts"() {
+    init_discover_skills();
     SkillsManager = class {
       constructor(cwd, _enabled, settingSourcesIncludeProject) {
         this.cwd = cwd;
@@ -6430,28 +6487,15 @@ var init_skills_manager = __esm({
         await this.refresh();
       }
       async refresh() {
-        this.skills = [];
         const skillsRoot = join(this.cwd, ".theokit", "skills");
-        const entries = await readWorkspaceDir(skillsRoot, "skills_read_error", "skills directory");
-        for (const entry of entries) {
-          if (!entry.isDirectory()) continue;
-          let skillDir;
-          try {
-            skillDir = safePathJoin(skillsRoot, entry.name);
-            assertNoSymlinkEscape(skillDir, skillsRoot);
-          } catch {
-            continue;
-          }
-          const skillPath = join(skillDir, "SKILL.md");
-          let raw;
-          try {
-            raw = await readFile(skillPath, "utf8");
-          } catch {
-            continue;
+        this.skills = await discoverSkills(skillsRoot, {
+          onInvalidSkill: (info) => {
+            process.stderr.write(
+              `[theokit-sdk] skill ${info.name} skipped (${info.code}): ${info.message}
+`
+            );
           }
-          const metadata = tryParseSkill(raw, entry.name, skillPath);
-          if (metadata !== void 0) this.skills.push(metadata);
-        }
+        });
       }
       list() {
         return Promise.resolve(this.skills);
@@ -6913,6 +6957,7 @@ async function initLoopContext(inputs) {
     finalStatus: "finished",
     usage: new UsageAccumulator(),
     nudgeAttempts: 0,
+    stopFeedbackAttempts: 0,
     ...memoryProviderHandle !== void 0 ? { memoryProviderHandle } : {},
     ...memorySystemPromptAdditions !== void 0 ? { memorySystemPromptAdditions } : {}
   };
@@ -7068,8 +7113,9 @@ function registerLoopError(ctx, cause) {
   if (ctx.error !== void 0) return;
   const rawMessage = cause?.message;
   const message = typeof rawMessage === "string" ? rawMessage : cause instanceof Error ? cause.message : String(cause);
+  const metaCode = cause?.metadata?.code;
   const rawCode = cause?.code;
-  const code = typeof rawCode === "string" ? rawCode : void 0;
+  const code = typeof metaCode === "string" ? metaCode : typeof rawCode === "string" ? rawCode : void 0;
   ctx.error = code !== void 0 ? { message, code, cause } : { message, cause };
 }
 async function runCollectorLoop(generator, inputs, ctx) {
@@ -8152,6 +8198,28 @@ function shouldNudgeAndContinue(ctx, llmOutput) {
   });
   return true;
 }
+async function reflectAfterStop(inputs, ctx) {
+  const result = await inputs.hooks.run({
+    event: "stop",
+    agentId: inputs.agentId,
+    runId: inputs.runId
+  });
+  if (result.blocked) return false;
+  if (ctx.stopFeedbackAttempts >= MAX_STOP_FEEDBACK_ATTEMPTS) return false;
+  const feedback = result.decisions.find(
+    (d) => d.decision === "feedback" && (d.feedback ?? "").length > 0
+  )?.feedback;
+  if (feedback === void 0) return false;
+  ctx.stopFeedbackAttempts += 1;
+  ctx.messages.push({ role: "user", content: [{ type: "text", text: feedback }] });
+  return true;
+}
+async function finishOrReflect(inputs, ctx, llmOutput) {
+  if (shouldNudgeAndContinue(ctx, llmOutput)) return "continue";
+  if (await reflectAfterStop(inputs, ctx)) return "continue";
+  ctx.finalStatus = "finished";
+  return "done";
+}
 async function runIteration(inputs, ctx) {
   const llmOutput = await streamLlmTurn(inputs, ctx);
   accumulateUsage(ctx.usage, llmOutput);
@@ -8185,9 +8253,7 @@ async function continueOrTerminate(inputs, ctx, llmOutput) {
     await emitAssistantTextStep(inputs, ctx, llmOutput.text);
   }
   if (llmOutput.stopReason !== "tool_use" || llmOutput.toolCalls.length === 0) {
-    if (shouldNudgeAndContinue(ctx, llmOutput)) return "continue";
-    ctx.finalStatus = "finished";
-    return "done";
+    return finishOrReflect(inputs, ctx, llmOutput);
   }
   ctx.messages.push(buildAssistantTurn(llmOutput.text, llmOutput.toolCalls));
   const toolResults = await dispatchTools(inputs, ctx.tools, llmOutput.toolCalls, ctx.events);
@@ -8210,7 +8276,7 @@ async function continueOrTerminate(inputs, ctx, llmOutput) {
   pushToolConversationSteps(ctx, llmOutput.toolCalls, toolResults);
   return handleToolErrorContinuation(inputs, ctx, toolResults);
 }
-var MAX_NUDGE_ATTEMPTS;
+var MAX_NUDGE_ATTEMPTS, MAX_STOP_FEEDBACK_ATTEMPTS;
 var init_loop = __esm({
   "src/internal/agent-loop/loop.ts"() {
     init_budget();
@@ -8223,6 +8289,7 @@ var init_loop = __esm({
     init_tool_dispatch();
     init_usage_and_cost();
     MAX_NUDGE_ATTEMPTS = 2;
+    MAX_STOP_FEEDBACK_ATTEMPTS = 2;
   }
 });
 
@@ -14187,6 +14254,71 @@ var init_agent_factory_registry = __esm({
   }
 });
 
+// src/internal/runtime/lifecycle/run-to-completion.ts
+var run_to_completion_exports = {};
+__export(run_to_completion_exports, {
+  classifyRound: () => classifyRound,
+  runToCompletionImpl: () => runToCompletionImpl
+});
+function isEmptyRound(result) {
+  return (result.result ?? "").trim() === "";
+}
+function classifyRound(result, round, maxRounds, emptyStreak) {
+  if (result.stoppedAtIterationLimit !== true) return "done";
+  if (isEmptyRound(result) && emptyStreak >= 1) return "no_progress";
+  if (round >= maxRounds) return "step_limit";
+  return "continue";
+}
+function addUsage(acc, u) {
+  if (u === void 0) return acc;
+  const inputTokens = (acc?.inputTokens ?? 0) + u.inputTokens;
+  const outputTokens = (acc?.outputTokens ?? 0) + u.outputTokens;
+  const sumOpt = (a, b) => a === void 0 && b === void 0 ? void 0 : (a ?? 0) + (b ?? 0);
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: inputTokens + outputTokens,
+    cacheReadTokens: sumOpt(acc?.cacheReadTokens, u.cacheReadTokens),
+    cacheWriteTokens: sumOpt(acc?.cacheWriteTokens, u.cacheWriteTokens),
+    reasoningTokens: sumOpt(acc?.reasoningTokens, u.reasoningTokens)
+  };
+}
+function buildResult(terminal, rounds, lastResult, usage) {
+  return { terminal, rounds, lastResult, ...usage !== void 0 ? { usage } : {} };
+}
+async function stepRound(agent, prompt, sendOptions, round, maxRounds, state2) {
+  const run = await agent.send(prompt, sendOptions);
+  const result = await run.wait();
+  const usage = addUsage(state2.usage, result.usage);
+  const decision = classifyRound(result, round, maxRounds, state2.emptyStreak);
+  if (decision !== "continue") return { terminal: buildResult(decision, round, result, usage) };
+  const emptyStreak = isEmptyRound(result) ? state2.emptyStreak + 1 : 0;
+  return { next: { usage, emptyStreak }, lastResult: result };
+}
+async function runToCompletionImpl(agent, message, options) {
+  const maxRounds = options?.maxRounds ?? DEFAULT_MAX_ROUNDS;
+  const continuationPrompt = options?.continuationPrompt ?? DEFAULT_CONTINUATION_PROMPT;
+  const { onTruncated, signal, sendOptions } = options ?? {};
+  let state2 = { usage: void 0, emptyStreak: 0 };
+  for (let round = 0; ; round += 1) {
+    const prompt = round === 0 ? message : continuationPrompt;
+    const outcome = await stepRound(agent, prompt, sendOptions, round, maxRounds, state2);
+    if ("terminal" in outcome) return outcome.terminal;
+    state2 = outcome.next;
+    await onTruncated?.({ round });
+    if (signal?.aborted === true) {
+      return buildResult("step_limit", round, outcome.lastResult, state2.usage);
+    }
+  }
+}
+var DEFAULT_MAX_ROUNDS, DEFAULT_CONTINUATION_PROMPT;
+var init_run_to_completion = __esm({
+  "src/internal/runtime/lifecycle/run-to-completion.ts"() {
+    DEFAULT_MAX_ROUNDS = 5;
+    DEFAULT_CONTINUATION_PROMPT = "Continue from where you left off and finish the task. If it is already complete, give the final answer.";
+  }
+});
+
 // src/internal/runtime/lifecycle/fork-agent.ts
 var fork_agent_exports = {};
 __export(fork_agent_exports, {
@@ -14267,6 +14399,13 @@ function localAgentRunUntil(agent, goal, options) {
   }
   return wrap();
 }
+function localAgentRunToCompletion(agent, message, options) {
+  async function run() {
+    const { runToCompletionImpl: runToCompletionImpl2 } = await Promise.resolve().then(() => (init_run_to_completion(), run_to_completion_exports));
+    return runToCompletionImpl2({ send: (m, o) => agent.send(m, o) }, message, options);
+  }
+  return run();
+}
 async function localAgentFork(parent, options) {
   const { forkAgentImpl: forkAgentImpl2 } = await Promise.resolve().then(() => (init_fork_agent(), fork_agent_exports));
   const { getAgentFacade: getAgentFacade2 } = await Promise.resolve().then(() => (init_agent_factory_registry(), agent_factory_registry_exports));
@@ -15401,6 +15540,10 @@ var init_local_agent = __esm({
       fork(options) {
         return localAgentFork({ agentId: this.agentId, options: this.options, personalitySlugSnapshot: this.personalityStore.active(this.agentId) }, options);
       }
+      // biome-ignore format: G8 budget — see runUntil comment above.
+      runToCompletion(message, options) {
+        return localAgentRunToCompletion(this, message, options);
+      }
     };
   }
 });