@tyvm/knowhow 0.0.130 → 0.0.132

package/src/index.ts

@@ -1,14 +1,8 @@
 import { summarizeFiles, summarizeFile } from "./ai";
-import {
-  saveAllFileHashes,
-  saveHashes,
-  getHashes,
-  checkNoFilesChanged,
-} from "./hashes";
+import type { AgentOptions } from "./ai";
 import * as fs from "fs";
 import * as path from "path";
 import * as crypto from "crypto";
-import { promisify } from "util";
 import { globSync } from "glob";
 
 import { Prompts } from "./prompts";
@@ -37,12 +31,25 @@ import {
   getConfiguredEmbeddingMap,
 } from "./embeddings";
 
-import { abort } from "process";
 import { convertToText } from "./conversion";
 import { knowhowMcpClient } from "./services/Mcp";
 import { services } from "./services/";
 import { Models } from "./types";
 
+// ---------------------------------------------------------------------------
+// Re-export generate pipeline (moved to src/generate.ts)
+// ---------------------------------------------------------------------------
+export {
+  generate,
+  GenerateOptions,
+  buildWaves,
+  normalizeInputPattern,
+  withOutputTarget,
+  writeAgentOrSummaryOutput,
+  handleMultiOutputGeneration,
+  handleSingleOutputGeneration,
+} from "./generate";
+
 export * as clients from "./clients";
 export * as agents from "./agents";
 export * as services from "./services";
@@ -65,8 +72,11 @@ export { SkillsPlugin } from "./plugins/SkillsPlugin";
 // Export embedding types
 export { MinimalEmbedding, Embeddable } from "./types";
 
+// ---------------------------------------------------------------------------
+// Embed
+// ---------------------------------------------------------------------------
+
 export async function embed() {
-  // load config
   const config = await getConfig();
   const ignorePattern = await getIgnorePattern();
 
@@ -74,7 +84,6 @@ export async function embed() {
     config.embeddingModel || EmbeddingModels.openai.EmbeddingAda2;
 
   if (!config.embedSources) {
-    // No embeddings configured
     return;
   }
 
@@ -83,6 +92,10 @@ export async function embed() {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Purge
+// ---------------------------------------------------------------------------
+
 export async function purge(globPath: string) {
   const files = globSync(globPath);
   const embeddings = await getConfiguredEmbeddingMap();
@@ -109,6 +122,10 @@ export async function purge(globPath: string) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Upload
+// ---------------------------------------------------------------------------
+
 export async function upload() {
   const config = await getConfig();
   const { AwsS3, Embeddings, knowhowApiClient } = services();
@@ -126,10 +143,6 @@ export async function upload() {
     }
     const items = JSON.parse(await readFile(source.output, "utf8"));
     const { name: embeddingName } = path.parse(source.output);
-    const data = {
-      embeddingName,
-      items,
-    };
 
     if (Embeddings.hasResolver(source.remoteType) && source.remoteType !== "knowhow") {
       console.log(
@@ -144,7 +157,6 @@ export async function upload() {
       if (!source.remoteId) {
         throw new Error("remoteId is required for knowhow uploads");
       }
-      // Warn if the local embeddingModel differs from the one stored on the backend
       try {
         const remoteEmbedding = await knowhowApiClient.getOrgEmbedding(source.remoteId);
         const localModel = config.embeddingModel || EmbeddingModels.openai.EmbeddingAda2;
@@ -159,12 +171,11 @@ export async function upload() {
           );
         }
       } catch (e) {
-        // Non-fatal — don't block upload if metadata fetch fails
+        // Non-fatal
       }
       const url = await knowhowApiClient.getPresignedUploadUrl(source);
       console.log("Uploading to", url);
       await AwsS3.uploadToPresignedUrl(url, source.output);
-      // Sync config metadata back to the backend DB
       await knowhowApiClient.updateEmbeddingMetadata(source.remoteId, {
         inputGlob: source.input,
         outputPath: source.output,
@@ -183,201 +194,9 @@ export async function upload() {
   }
 }
 
-/**
- * Normalizes an input pattern to a valid glob pattern.
- * Supports:
- *   - Standard glob patterns (e.g. "src/**\/*.ts")
- *   - Brace expansion (e.g. "{src/a.ts,src/b.ts}")
- *   - Comma-separated file paths (e.g. "src/a.ts,src/b.ts") — auto-converted to brace expansion
- *   - Mixed comma-separated list with globs (e.g. "src/a.ts,src/commands/**\/*.ts")
- */
-function normalizeInputPattern(input: string): string {
-  // If it already has braces, use as-is (already brace-expanded)
-  if (input.includes("{")) {
-    return input;
-  }
-  // If it contains commas, treat as comma-separated list and wrap in braces
-  // This also handles the mixed case: "src/a.ts,src/commands/**/*.ts"
-  if (input.includes(",")) {
-    const parts = input.split(",").map((p) => p.trim());
-    return `{${parts.join(",")}}`;
-  }
-  return input;
-}
-
-export async function generate(): Promise<void> {
-  const config = await getConfig();
-  for (const source of config.sources) {
-    console.log("Generating", source.input, "to", source.output);
-    if (source.kind === "file" || !source.kind) {
-      const files = globSync(normalizeInputPattern(source.input));
-      const prompt = await loadPrompt(source.prompt);
-
-      if (source.output.endsWith("/")) {
-        await handleMultiOutputGeneration(
-          source.model,
-          source.input,
-          files,
-          prompt,
-          source.output,
-          source.outputExt,
-          source.outputName,
-          source.kind,
-          source.agent
-        );
-      } else {
-        await handleSingleOutputGeneration(
-          source.model,
-          files,
-          prompt,
-          source.output,
-          source.kind,
-          source.agent
-        );
-      }
-    } else {
-      await handleAllKindsGeneration(source);
-    }
-  }
-}
-
-async function handleAllKindsGeneration(source: GenerationSource) {
-  const { Plugins } = services();
-  const { kind, input } = source;
-  if (Plugins.isPlugin(kind)) {
-    const data = await Plugins.call(kind, input);
-    if (source.output.endsWith("/")) {
-      throw new Error(`Plugin ${kind} can only output to a single file`);
-    }
-    await writeFile(source.output, data);
-  }
-  return handleFileKindGeneration(source);
-}
-
-async function handleFileKindGeneration(source: GenerationSource) {
-  const prompt = await loadPrompt(source.prompt);
-  const files = globSync(normalizeInputPattern(source.input));
-  console.log("Analyzing files: ", files);
-
-  if (source.output.endsWith("/")) {
-    await handleMultiOutputGeneration(
-      source.model,
-      source.input,
-      files,
-      prompt,
-      source.output,
-      source.outputExt,
-      source.outputName,
-      source.kind,
-      source.agent
-    );
-  } else {
-    await handleSingleOutputGeneration(
-      source.model,
-      files,
-      prompt,
-      source.output,
-      source.kind,
-      source.agent
-    );
-  }
-}
-export async function handleMultiOutputGeneration(
-  model: string,
-  inputPattern: string,
-  files: string[],
-  prompt: string,
-  output: string,
-  outputExt = "mdx",
-  outputName?: string,
-  kind?: string,
-  agent?: string
-) {
-  // get the hash of the prompt
-  const promptHash = crypto.createHash("md5").update(prompt).digest("hex");
-
-  // get the files matching the input pattern
-  const hashes = await getHashes();
-
-  const inputPath = inputPattern.includes("**")
-    ? inputPattern.split("**")[0]
-    : "";
-
-  for (const file of files) {
-    // get the hash of the file
-    const fileContent = await convertToText(file);
-    const fileHash = crypto.createHash("md5").update(fileContent).digest("hex");
-
-    if (!hashes[file]) {
-      hashes[file] = { promptHash: "", fileHash: "" };
-    }
-
-    // write the summary to the output file
-    const { name, ext, dir } = path.parse(file);
-    const nestedFolder = inputPath ? (dir + "/").replace(inputPath, "") : "";
-    const outputFolder = path.join(output, nestedFolder);
-
-    if (!fs.existsSync(outputFolder)) {
-      fs.mkdirSync(outputFolder, { recursive: true });
-    }
-
-    const outputFileName = outputName || name;
-    const outputFile = path.join(
-      outputFolder,
-      outputFileName + "." + outputExt
-    );
-    console.log({ dir, inputPath, nestedFolder, outputFile });
-
-    const toCheck = [file, outputFile];
-    const noChanges = await checkNoFilesChanged(toCheck, promptHash, hashes);
-    if (noChanges) {
-      console.log("Skipping file", file, "because it hasn't changed");
-      continue;
-    }
-
-    // summarize the file
-    console.log("Summarizing", file);
-    const summary = prompt
-      ? await summarizeFile(file, prompt, model, agent)
-      : fileContent;
-
-    console.log("Writing summary to", outputFile);
-    await writeFile(outputFile, summary);
-
-    await saveAllFileHashes(toCheck, promptHash);
-  }
-}
-
-export async function handleSingleOutputGeneration(
-  model: string,
-  files: string[],
-  prompt: string,
-  outputFile: string,
-  kind?: string,
-  agent?: string
-) {
-  const hashes = await getHashes();
-  const promptHash = crypto.createHash("md5").update(prompt).digest("hex");
-
-  const filesToCheck = [outputFile, ...files];
-  const noChanges = await checkNoFilesChanged(filesToCheck, promptHash, hashes);
-  if (noChanges) {
-    console.log(`Skipping ${files.length} files because they haven't changed`);
-    return;
-  }
-
-  console.log("Summarizing", files.length, "files");
-  const summary = prompt
-    ? await summarizeFiles(files, prompt, model, agent)
-    : (await Promise.all(files.map(convertToText))).join("\n\n");
-
-  const fileHash = crypto.createHash("md5").update(summary).digest("hex");
-
-  console.log("Writing summary to", outputFile);
-  await writeFile(outputFile, summary);
-
-  await saveAllFileHashes(filesToCheck, promptHash);
-}
+// ---------------------------------------------------------------------------
+// Download
+// ---------------------------------------------------------------------------
 
 export async function download() {
   const config = await getConfig();
@@ -421,10 +240,7 @@ export async function download() {
         "to",
         destinationPath
       );
-      const preSignedUrl = await knowhowApiClient.getPresignedDownloadUrl(
-        source
-      );
-      // Ensure output directory exists
+      const preSignedUrl = await knowhowApiClient.getPresignedDownloadUrl(source);
       const outputDir = path.dirname(destinationPath);
       if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
       await AwsS3.downloadFromPresignedUrl(preSignedUrl, destinationPath);

package/src/services/BehaviorsService.ts

@@ -190,6 +190,38 @@ export class BehaviorsService {
     return null;
   }
 
+  /**
+   * Find a behavior from local disk by its ID field.
+   */
+  findBehaviorById(id: string): Behavior | null {
+    const behaviors = this.loadLocal();
+    return behaviors.find((b) => b.id === id) ?? null;
+  }
+
+  /**
+   * Load a behavior directly from a file path (.json or .md).
+   */
+  loadBehaviorFromFile(filePath: string): Behavior | null {
+    const resolved = path.isAbsolute(filePath)
+      ? filePath
+      : path.resolve(process.cwd(), filePath);
+
+    if (!fs.existsSync(resolved)) {
+      return null;
+    }
+
+    try {
+      const raw = fs.readFileSync(resolved, "utf-8");
+      if (resolved.endsWith(".md")) {
+        return this.parseMdBehavior(raw);
+      } else {
+        return JSON.parse(raw) as Behavior;
+      }
+    } catch {
+      return null;
+    }
+  }
+
   async list(opts: { skillsOnly?: boolean; includeInternal?: boolean } = {}) {
     const behaviors = opts.skillsOnly
       ? await this.client.getOrgSkills(opts.includeInternal ?? true)

package/src/services/SkillsService.ts

@@ -3,6 +3,7 @@ import * as path from "path";
 import * as os from "os";
 import { createHash } from "crypto";
 import * as https from "https";
+import { KnowhowSimpleClient } from "./KnowhowClient";
 
 // Default local install dir (relative to cwd)
 const LOCAL_SKILLS_DIR = ".knowhow/skills";
@@ -236,6 +237,7 @@ export class SkillsService {
   private cwd: string;
   private isGlobal: boolean;
   private customInstallDir?: string;
+  public client = new KnowhowSimpleClient();
 
   constructor(opts: SkillsServiceOptions = {}) {
     this.cwd = opts.cwd ?? process.cwd();
@@ -619,4 +621,200 @@ export class SkillsService {
       `\nDone: ${updated} updated, ${unchanged} unchanged, ${failed} failed.`
     );
   }
+
+  /**
+   * Upload locally installed skills (from .knowhow/skills/<name>/SKILL.md) to the backend as behaviors.
+   * Each skill is upserted: created if it has no id in frontmatter, updated if it does.
+   */
+  async upload(): Promise<void> {
+    const installDir = this.getInstallDir();
+
+    if (!fs.existsSync(installDir)) {
+      console.error(
+        `No skills directory found at ${installDir}. Run 'knowhow skills add <ref>' first.`
+      );
+      return;
+    }
+
+    const entries = fs.readdirSync(installDir, { withFileTypes: true });
+    const skillDirs = entries.filter((e) => e.isDirectory());
+
+    if (skillDirs.length === 0) {
+      console.log("No skill directories found. Nothing to upload.");
+      return;
+    }
+
+    let uploaded = 0;
+    let failed = 0;
+
+    for (const dir of skillDirs) {
+      const skillFile = path.join(installDir, dir.name, "SKILL.md");
+      if (!fs.existsSync(skillFile)) {
+        console.warn(`  ⚠ ${dir.name}: no SKILL.md found, skipping.`);
+        continue;
+      }
+
+      try {
+        const raw = fs.readFileSync(skillFile, "utf-8");
+        const behavior = this.parseSkillMd(raw, dir.name);
+
+        // Always mark as a skill
+        const payload: Record<string, unknown> = {
+          ...behavior,
+          isSkill: true,
+        };
+
+        if (behavior.id) {
+          await this.client.updateOrgBehavior(behavior.id as string, payload);
+          console.log(`  📝 Updated: ${behavior.name} (${behavior.id as string})`);
+        } else {
+          const result = await this.client.createOrgBehavior(payload);
+          const created = result.data as Record<string, unknown>;
+          if (created.id) {
+            // Write the assigned id back into the SKILL.md frontmatter so future uploads update instead of create
+            const withId = this.injectIdIntoSkillMd(raw, created.id as string);
+            fs.writeFileSync(skillFile, withId, "utf-8");
+            console.log(`  ✨ Created: ${behavior.name} (id: ${created.id})`);
+          } else {
+            console.log(`  ✨ Created: ${behavior.name}`);
+          }
+        }
+        uploaded++;
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.error(`  ❌ ${dir.name}: ${msg}`);
+        failed++;
+      }
+    }
+
+    console.log(`\nUploaded ${uploaded} skill(s). Failed: ${failed}.`);
+  }
+
+  /**
+   * Download skill behaviors from the backend and write them as SKILL.md files
+   * into the skills install directory (.knowhow/skills/<name>/SKILL.md).
+   */
+  async download(): Promise<void> {
+    const installDir = this.getInstallDir();
+    const result = await this.client.getOrgSkills(false); // false = exclude platform/internal skills
+    const skills = result.data as Record<string, unknown>[];
+
+    if (skills.length === 0) {
+      console.log("No skills found on backend.");
+      return;
+    }
+
+    let created = 0;
+    let updated = 0;
+    let unchanged = 0;
+
+    for (const skill of skills) {
+      const name = ((skill.name as string) || "unnamed")
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, "-");
+      const skillDir = path.join(installDir, name);
+      fs.mkdirSync(skillDir, { recursive: true });
+
+      const skillFile = path.join(skillDir, "SKILL.md");
+      const content = this.serializeSkillMd(skill);
+
+      const hash = (s: string) => createHash("sha256").update(s).digest("hex");
+      if (!fs.existsSync(skillFile)) {
+        fs.writeFileSync(skillFile, content, "utf-8");
+        console.log(`  ✨ Created: ${skillFile}`);
+        created++;
+      } else {
+        const existing = fs.readFileSync(skillFile, "utf-8");
+        if (hash(existing) !== hash(content)) {
+          fs.writeFileSync(skillFile, content, "utf-8");
+          console.log(`  📝 Updated: ${skillFile}`);
+          updated++;
+        } else {
+          unchanged++;
+        }
+      }
+    }
+
+    console.log(
+      `\nSync complete: ${created} created, ${updated} updated, ${unchanged} unchanged → ${installDir}/`
+    );
+  }
+
+  /**
+   * Parse a SKILL.md file into a behavior object.
+   * Falls back to using the directory name if name is missing from frontmatter.
+   */
+  private parseSkillMd(content: string, fallbackName: string): Record<string, unknown> {
+    const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+    if (!match) {
+      return { name: fallbackName, description: "", instructions: content.trim(), isSkill: true };
+    }
+
+    const meta: Record<string, string> = {};
+    for (const line of match[1].split("\n")) {
+      const colonIdx = line.indexOf(":");
+      if (colonIdx > 0) {
+        const key = line.slice(0, colonIdx).trim();
+        const val = line.slice(colonIdx + 1).trim();
+        meta[key] = val;
+      }
+    }
+
+    return {
+      id: meta.id || undefined,
+      name: meta.name || fallbackName,
+      description: meta.description || "",
+      instructions: match[2].trim(),
+      textTrigger: meta.textTrigger || undefined,
+      semanticTriggerText: meta.semanticTriggerText || undefined,
+      model: meta.model || undefined,
+      mcpServers: meta.mcpServers || undefined,
+      tools: meta.tools || undefined,
+      embeddings: meta.embeddings || undefined,
+      isSkill: true,
+      isPublic: meta.isPublic === "true",
+    };
+  }
+
+  /**
+   * Serialize a backend behavior record as a SKILL.md string.
+   */
+  private serializeSkillMd(skill: Record<string, unknown>): string {
+    const lines: string[] = ["---"];
+    lines.push(`name: ${skill.name || ""}`);
+    lines.push(`description: ${skill.description || ""}`);
+    if (skill.model) lines.push(`model: ${skill.model}`);
+    if (skill.textTrigger) lines.push(`textTrigger: ${skill.textTrigger}`);
+    if (skill.semanticTriggerText) lines.push(`semanticTriggerText: ${skill.semanticTriggerText}`);
+    if (skill.mcpServers) lines.push(`mcpServers: ${skill.mcpServers}`);
+    if (skill.tools) lines.push(`tools: ${skill.tools}`);
+    if (skill.embeddings) lines.push(`embeddings: ${skill.embeddings}`);
+    if (skill.isPublic !== undefined) lines.push(`isPublic: ${skill.isPublic}`);
+    if (skill.id) lines.push(`id: ${skill.id}`);
+    lines.push("---");
+    lines.push("");
+    lines.push(((skill.instructions as string) || "").trim());
+    lines.push("");
+    return lines.join("\n");
+  }
+
+  /**
+   * Inject or replace the `id:` field in a SKILL.md frontmatter.
+   */
+  private injectIdIntoSkillMd(content: string, id: string): string {
+    const match = content.match(/^(---\n[\s\S]*?\n---\n?)([\s\S]*)$/);
+    if (!match) return content;
+
+    let frontmatter = match[1];
+    const body = match[2];
+
+    if (/^id:/m.test(frontmatter)) {
+      frontmatter = frontmatter.replace(/^id:.*$/m, `id: ${id}`);
+    } else {
+      // Insert before closing ---
+      frontmatter = frontmatter.replace(/\n---\n?$/, `\nid: ${id}\n---\n`);
+    }
+
+    return frontmatter + body;
+  }
 }

package/src/types.ts

@@ -1,23 +1,55 @@
 import { AssistantTool } from "openai/resources/beta";
 import { WebSocket } from "ws";
 
+/**
+ * Flexible hash store. Each key is either:
+ *   - a file path (legacy): { fileHash, promptHash, [promptHash]: fileHash }
+ *   - a named build slot (new): { [inputKey: string]: hashValue }
+ *
+ * Both formats use the same shape: an object of string→string pairs.
+ * `fileHash` and `promptHash` are just conventional keys in the legacy format.
+ */
 export type Hashes = {
-  [file: string]: {
-    [promptHash: string]: string;
-    promptHash: string;
-    fileHash: string;
+  [key: string]: {
+    [inputKey: string]: string;
   };
 };
 
+/**
+ * A reference to an external JSON file containing an array of GenerationSource
+ * or EmbedSource entries. Used in knowhow.json `sources` / `embedSources` arrays
+ * to split a large config across multiple files:
+ *   { "from": "./generate/autodoc.json" }
+ */
+export type SourceRef = { from: string };
+
 export type GenerationSource = {
   model?: string;
   agent?: string;
+  name?: string;
   input: string;
   output: string;
   prompt: string;
   kind?: string;
   outputExt?: string;
   outputName?: string;
+  /** Pass to runAgentTask: enable .knowhow/processes/agents/<taskId> directory */
+  syncFs?: boolean;
+  /**
+   * Deterministic task ID for this source (used with syncFs).
+   * Defaults to "generate:<sanitized-output>" when syncFs is enabled.
+   */
+  taskId?: string;
+  /** Time limit in minutes for the agent (optional) */
+  maxTimeLimit?: number;
+  /** Cost limit in dollars for the agent (optional) */
+  maxSpendLimit?: number;
+  /**
+   * Names of other GenerationSource entries (by `name` field) that must
+   * complete before this source runs. Used for explicit dependency ordering
+   * when automatic I/O overlap detection is insufficient.
+   */
+  dependsOn?: string[];
 };
 
 export type EmbedSource = {

package/ts_build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tyvm/knowhow",
-    "version": "0.0.130",
+    "version": "0.0.132",
     "description": "ai cli with plugins and agents",
     "main": "ts_build/src/index.js",
     "bin": {

package/ts_build/src/agents/configurable/ConfigAgent.js.map

@@ -1 +1 @@
-{"version":3,"file":"ConfigAgent.js","sourceRoot":"","sources":["../../../../src/agents/configurable/ConfigAgent.ts"],"names":[],"mappings":";;;AAAA,uCAAuD;AAMvD,MAAa,WAAY,SAAQ,gBAAS;IAIpB;IAHpB,IAAI,CAAS;IACb,WAAW,CAAS;IAEpB,YAAoB,MAAiB,EAAE,OAAqB;QAC1D,KAAK,CAAC,OAAO,CAAC,CAAC;QADG,WAAM,GAAN,MAAM,CAAW;QAEnC,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;QACxB,IAAI,CAAC,mBAAmB,CAAC;YACvB,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE;SACnD,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,kBAAkB,CAAC,SAAiB;QACxC,OAAO;YACL,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE;YACrD,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE;SACxB,CAAC;IACjB,CAAC;CACF;AAlBD,kCAkBC"}
+{"version":3,"file":"ConfigAgent.js","sourceRoot":"","sources":["../../../../src/agents/configurable/ConfigAgent.ts"],"names":[],"mappings":";;;AAAA,uCAAuD;AAKvD,MAAa,WAAY,SAAQ,gBAAS;IAIpB;IAHpB,IAAI,CAAS;IACb,WAAW,CAAS;IAEpB,YAAoB,MAAiB,EAAE,OAAqB;QAC1D,KAAK,CAAC,OAAO,CAAC,CAAC;QADG,WAAM,GAAN,MAAM,CAAW;QAEnC,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;QACxB,IAAI,CAAC,mBAAmB,CAAC;YACvB,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE;SACnD,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,kBAAkB,CAAC,SAAiB;QACxC,OAAO;YACL,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE;YACrD,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE;SACxB,CAAC;IACjB,CAAC;CACF;AAlBD,kCAkBC"}

package/ts_build/src/agents/tools/startAgentTask.d.ts

@@ -1,5 +1,5 @@
 import { Tool } from "../../clients/types";
-interface StartAgentTaskParams {
+export interface StartAgentTaskParams {
     messageId?: string;
     syncFs?: boolean;
     taskId?: string;
@@ -10,7 +10,7 @@ interface StartAgentTaskParams {
     agentName?: string;
     maxTimeLimit?: number;
     maxSpendLimit?: number;
+    waitForCompletion?: boolean;
 }
 export declare function startAgentTask(params: StartAgentTaskParams): Promise<string>;
 export declare const startAgentTaskDefinition: Tool;
-export {};