@poncho-ai/cli 0.37.0 → 0.38.0

package/dist/run-interactive-ink-CE7U47S5.js

@@ -0,0 +1,679 @@
+import {
+  consumeFirstRunIntro,
+  getMascotLines,
+  inferConversationTitle,
+  resolveHarnessEnvironment
+} from "./chunk-U643TWFX.js";
+
+// src/run-interactive-ink.ts
+import * as readline from "readline";
+import { readFile } from "fs/promises";
+import { resolve, basename } from "path";
+import { stdout } from "process";
+import {
+  parseAgentFile
+} from "@poncho-ai/harness";
+var C = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  gray: "\x1B[90m",
+  magenta: "\x1B[35m"
+};
+var green = (s) => `${C.green}${s}${C.reset}`;
+var yellow = (s) => `${C.yellow}${s}${C.reset}`;
+var red = (s) => `${C.red}${s}${C.reset}`;
+var gray = (s) => `${C.gray}${s}${C.reset}`;
+var magenta = (s) => `${C.magenta}${s}${C.reset}`;
+var FAUX_TOOL_LOG_PATTERN = /Tool Used:|Tool Result:|\blist_skills\b|\bcreate_skill\b|\bedit_skill\b/i;
+var formatDuration = (ms) => ms < 1e3 ? `${ms}ms` : `${(ms / 1e3).toFixed(1)}s`;
+var stringifyValue = (v) => {
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+};
+var truncate = (v, max) => v.length <= max ? v : `${v.slice(0, Math.max(0, max - 3))}...`;
+var compactPreview = (v, max = 120) => truncate(stringifyValue(v).replace(/\s+/g, " "), max);
+var loadMetadata = async (workingDir) => {
+  let agentName = "agent";
+  let model = "unknown";
+  let provider = "unknown";
+  try {
+    const parsed = await parseAgentFile(workingDir);
+    agentName = parsed.frontmatter.name ?? agentName;
+    model = parsed.frontmatter.model?.name ?? model;
+    provider = parsed.frontmatter.model?.provider ?? provider;
+  } catch {
+  }
+  return {
+    agentName,
+    model,
+    provider,
+    workingDir,
+    environment: resolveHarnessEnvironment()
+  };
+};
+var ask = (rl, prompt) => new Promise((res) => {
+  rl.question(prompt, (answer) => res(answer));
+});
+var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+var streamTextAsTokens = async (text) => {
+  const tokens = text.match(/\S+\s*|\n/g) ?? [text];
+  for (const token of tokens) {
+    stdout.write(token);
+    const trimmed = token.trim();
+    const delay = trimmed.length === 0 ? 0 : Math.max(4, Math.min(18, Math.floor(trimmed.length / 2)));
+    await sleep(delay);
+  }
+};
+var EXT_MIME = {
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  png: "image/png",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  pdf: "application/pdf",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  txt: "text/plain",
+  json: "application/json",
+  csv: "text/csv",
+  html: "text/html"
+};
+var extToMime = (ext) => EXT_MIME[ext] ?? "application/octet-stream";
+var readPendingFiles = async (files) => {
+  const results = [];
+  for (const f of files) {
+    try {
+      const buf = await readFile(f.resolved);
+      const ext = f.resolved.split(".").pop()?.toLowerCase() ?? "";
+      results.push({
+        data: buf.toString("base64"),
+        mediaType: extToMime(ext),
+        filename: basename(f.path)
+      });
+    } catch {
+      console.log(`${C.yellow}warn: could not read ${f.path}, skipping${C.reset}`);
+    }
+  }
+  return results;
+};
+var OWNER_ID = "local-owner";
+var computeTurn = (messages) => Math.max(1, Math.floor(messages.length / 2) + 1);
+var formatDate = (value) => {
+  try {
+    return new Date(value).toLocaleString();
+  } catch {
+    return String(value);
+  }
+};
+var handleSlash = async (command, state, conversationStore, harness) => {
+  const [rawCommand, ...args] = command.trim().split(/\s+/);
+  const norm = rawCommand.toLowerCase();
+  if (norm === "/help") {
+    console.log(
+      gray(
+        "commands> /help /clear /exit /tools /attach <path> /files /list /open <id> /new [title] /delete [id] /continue /compact [focus] /reset [all]"
+      )
+    );
+    return { shouldExit: false };
+  }
+  if (norm === "/clear") {
+    process.stdout.write("\x1B[2J\x1B[H");
+    return { shouldExit: false };
+  }
+  if (norm === "/exit") {
+    return { shouldExit: true };
+  }
+  if (norm === "/list") {
+    const conversations = await conversationStore.list(OWNER_ID);
+    if (conversations.length === 0) {
+      console.log(gray("conversations> none"));
+      return { shouldExit: false };
+    }
+    console.log(gray("conversations>"));
+    for (const conversation of conversations) {
+      const activeMarker = state.activeConversationId === conversation.conversationId ? "*" : " ";
+      const maxTitleLen = 40;
+      const title = conversation.title.length > maxTitleLen ? conversation.title.slice(0, maxTitleLen - 1) + "\u2026" : conversation.title;
+      console.log(
+        gray(
+          `${activeMarker} ${conversation.conversationId} | ${title} | ${formatDate(conversation.updatedAt)}`
+        )
+      );
+    }
+    return { shouldExit: false };
+  }
+  if (norm === "/open") {
+    const conversationId = args[0];
+    if (!conversationId) {
+      console.log(yellow("usage> /open <conversationId>"));
+      return { shouldExit: false };
+    }
+    const conversation = await conversationStore.get(conversationId);
+    if (!conversation) {
+      console.log(yellow(`conversations> not found: ${conversationId}`));
+      return { shouldExit: false };
+    }
+    state.activeConversationId = conversation.conversationId;
+    state.messages = [...conversation.messages];
+    state.turn = computeTurn(state.messages);
+    console.log(gray(`conversations> opened ${conversation.conversationId}`));
+    return { shouldExit: false };
+  }
+  if (norm === "/new") {
+    const title = args.join(" ").trim();
+    const conversation = await conversationStore.create(OWNER_ID, title || void 0);
+    state.activeConversationId = conversation.conversationId;
+    state.messages = [];
+    state.turn = 1;
+    console.log(gray(`conversations> new ${conversation.conversationId}`));
+    return { shouldExit: false };
+  }
+  if (norm === "/delete") {
+    const targetConversationId = args[0] ?? state.activeConversationId ?? "";
+    if (!targetConversationId) {
+      console.log(yellow("usage> /delete <conversationId>"));
+      return { shouldExit: false };
+    }
+    const removed = await conversationStore.delete(targetConversationId);
+    if (!removed) {
+      console.log(yellow(`conversations> not found: ${targetConversationId}`));
+      return { shouldExit: false };
+    }
+    if (state.activeConversationId === targetConversationId) {
+      state.activeConversationId = null;
+      state.messages = [];
+      state.turn = 1;
+    }
+    console.log(gray(`conversations> deleted ${targetConversationId}`));
+    return { shouldExit: false };
+  }
+  if (norm === "/continue") {
+    const conversations = await conversationStore.list(OWNER_ID);
+    const latest = conversations[0];
+    if (!latest) {
+      console.log(yellow("conversations> no conversations to continue"));
+      return { shouldExit: false };
+    }
+    state.activeConversationId = latest.conversationId;
+    state.messages = [...latest.messages];
+    state.turn = computeTurn(state.messages);
+    console.log(gray(`conversations> continued ${latest.conversationId}`));
+    return { shouldExit: false };
+  }
+  if (norm === "/reset") {
+    if (args[0]?.toLowerCase() === "all") {
+      const conversations = await conversationStore.list(OWNER_ID);
+      for (const conversation2 of conversations) {
+        await conversationStore.delete(conversation2.conversationId);
+      }
+      state.activeConversationId = null;
+      state.messages = [];
+      state.turn = 1;
+      console.log(gray("conversations> reset all"));
+      return { shouldExit: false };
+    }
+    if (!state.activeConversationId) {
+      state.messages = [];
+      state.turn = 1;
+      console.log(gray("conversations> current session reset"));
+      return { shouldExit: false };
+    }
+    const conversation = await conversationStore.get(state.activeConversationId);
+    if (!conversation) {
+      state.activeConversationId = null;
+      state.messages = [];
+      state.turn = 1;
+      console.log(yellow("conversations> active conversation no longer exists"));
+      return { shouldExit: false };
+    }
+    await conversationStore.update({
+      ...conversation,
+      messages: []
+    });
+    state.messages = [];
+    state.turn = 1;
+    console.log(gray(`conversations> reset ${conversation.conversationId}`));
+    return { shouldExit: false };
+  }
+  if (norm === "/attach") {
+    const filePath = args.join(" ").trim();
+    if (!filePath) {
+      console.log(yellow("usage> /attach <path>"));
+      return { shouldExit: false };
+    }
+    const resolvedPath = resolve(process.cwd(), filePath);
+    try {
+      await readFile(resolvedPath);
+      state.pendingFiles.push({ path: filePath, resolved: resolvedPath });
+      console.log(gray(`attached> ${filePath} [${state.pendingFiles.length} file(s) queued]`));
+    } catch {
+      console.log(yellow(`attach> file not found: ${filePath}`));
+    }
+    return { shouldExit: false };
+  }
+  if (norm === "/files") {
+    if (state.pendingFiles.length === 0) {
+      console.log(gray("files> none attached"));
+    } else {
+      console.log(gray("files>"));
+      for (const f of state.pendingFiles) {
+        console.log(gray(`  ${f.path}`));
+      }
+    }
+    return { shouldExit: false };
+  }
+  if (norm === "/compact") {
+    if (state.messages.length < 4) {
+      console.log(gray("compact> not enough messages to compact"));
+      return { shouldExit: false };
+    }
+    const focusHint = args.join(" ").trim() || void 0;
+    console.log(gray("compact> compacting conversation..."));
+    const result = await harness.compact(
+      state.messages,
+      focusHint ? { instructions: focusHint } : void 0
+    );
+    if (result.compacted) {
+      state.messages = result.messages;
+      console.log(
+        gray(
+          `compact> done (${result.messagesBefore} \u2192 ${result.messagesAfter} messages)`
+        )
+      );
+    } else {
+      console.log(yellow(`compact> ${result.warning ?? "compaction skipped"}`));
+    }
+    return { shouldExit: false };
+  }
+  console.log(yellow(`Unknown command: ${command}`));
+  return { shouldExit: false };
+};
+var runInteractiveInk = async ({
+  harness,
+  params,
+  workingDir,
+  config,
+  conversationStore
+}) => {
+  const metadata = await loadMetadata(workingDir);
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+  console.log("");
+  for (const line of getMascotLines()) {
+    console.log(line);
+  }
+  console.log(`${C.bold}${C.cyan}                             poncho${C.reset}`);
+  console.log("");
+  console.log(
+    gray(
+      `  ${metadata.agentName} \xB7 ${metadata.provider}/${metadata.model} \xB7 ${metadata.environment}`
+    )
+  );
+  console.log(gray('  Type "exit" to quit, "/help" for commands'));
+  console.log(gray("  Press Ctrl+C during a run to stop streaming output."));
+  console.log(
+    gray("  Conversation: /list /open <id> /new [title] /delete [id] /continue /reset [all]")
+  );
+  console.log(
+    gray("  Files: /attach <path> /files\n")
+  );
+  const intro = await consumeFirstRunIntro(workingDir, {
+    agentName: metadata.agentName,
+    provider: metadata.provider,
+    model: metadata.model,
+    config
+  });
+  if (intro) {
+    console.log(green("assistant>"));
+    await streamTextAsTokens(intro);
+    stdout.write("\n\n");
+  }
+  let messages = intro ? [{ role: "assistant", content: intro }] : [];
+  let turn = 1;
+  let activeConversationId = null;
+  let showToolPayloads = false;
+  let activeRunAbortController = null;
+  let pendingFiles = [];
+  rl.on("SIGINT", () => {
+    if (activeRunAbortController && !activeRunAbortController.signal.aborted) {
+      activeRunAbortController.abort();
+      process.stdout.write("\n");
+      console.log(gray("stop> cancelling current run..."));
+      return;
+    }
+    rl.close();
+  });
+  while (true) {
+    const filesTag = pendingFiles.length > 0 ? `${C.dim}[${pendingFiles.length} file(s)] ${C.reset}` : "";
+    const prompt = `${filesTag}${C.cyan}you> ${C.reset}`;
+    let task;
+    try {
+      task = await ask(rl, prompt);
+    } catch {
+      break;
+    }
+    const trimmed = task.trim();
+    if (!trimmed) continue;
+    if (trimmed.toLowerCase() === "exit") break;
+    if (trimmed.startsWith("/")) {
+      if (trimmed.toLowerCase() === "/exit") break;
+      if (trimmed.toLowerCase() === "/tools") {
+        showToolPayloads = !showToolPayloads;
+        console.log(gray(`tool payloads: ${showToolPayloads ? "on" : "off"}`));
+        continue;
+      }
+      const interactiveState = {
+        messages,
+        turn,
+        activeConversationId,
+        pendingFiles
+      };
+      const slashResult = await handleSlash(
+        trimmed,
+        interactiveState,
+        conversationStore,
+        harness
+      );
+      if (slashResult.shouldExit) {
+        break;
+      }
+      messages = interactiveState.messages;
+      turn = interactiveState.turn;
+      activeConversationId = interactiveState.activeConversationId;
+      pendingFiles = interactiveState.pendingFiles;
+      continue;
+    }
+    console.log(gray(`
+--- turn ${turn} ---`));
+    process.stdout.write(gray("thinking..."));
+    let thinkingCleared = false;
+    const clearThinking = () => {
+      if (thinkingCleared) return;
+      thinkingCleared = true;
+      readline.clearLine(process.stdout, 0);
+      readline.cursorTo(process.stdout, 0);
+    };
+    let responseText = "";
+    let streamedText = "";
+    let committedText = false;
+    let sawChunk = false;
+    let toolEvents = 0;
+    const toolTimeline = [];
+    const sections = [];
+    let currentText = "";
+    let currentTools = [];
+    let runFailed = false;
+    let runCancelled = false;
+    let usage;
+    let latestRunId = "";
+    const startedAt = Date.now();
+    activeRunAbortController = new AbortController();
+    const turnFiles = pendingFiles.length > 0 ? await readPendingFiles(pendingFiles) : [];
+    if (pendingFiles.length > 0) {
+      console.log(gray(`  sending ${turnFiles.length} file(s)`));
+      pendingFiles = [];
+    }
+    let eventSource = harness.run({
+      task: trimmed,
+      parameters: params,
+      messages,
+      files: turnFiles.length > 0 ? turnFiles : void 0,
+      abortSignal: activeRunAbortController.signal
+    });
+    try {
+      while (true) {
+        let checkpointEvent = null;
+        for await (const event of eventSource) {
+          if (event.type === "run:started") {
+            latestRunId = event.runId;
+          }
+          if (event.type === "model:chunk") {
+            sawChunk = true;
+            if (currentTools.length > 0) {
+              sections.push({ type: "tools", content: currentTools });
+              currentTools = [];
+              if (responseText.length > 0 && !/\s$/.test(responseText)) {
+                responseText += " ";
+              }
+            }
+            responseText += event.content;
+            streamedText += event.content;
+            currentText += event.content;
+            if (!thinkingCleared) {
+              clearThinking();
+              process.stdout.write(`${C.green}assistant> ${C.reset}`);
+            }
+            process.stdout.write(event.content);
+          } else if (event.type === "tool:started" || event.type === "tool:completed" || event.type === "tool:error" || event.type === "tool:approval:required") {
+            if (streamedText.length > 0) {
+              committedText = true;
+              streamedText = "";
+              process.stdout.write("\n");
+            }
+            clearThinking();
+            if (event.type === "tool:started") {
+              if (currentText.length > 0) {
+                sections.push({ type: "text", content: currentText });
+                currentText = "";
+              }
+              const preview2 = showToolPayloads ? compactPreview(event.input, 400) : compactPreview(event.input, 100);
+              console.log(yellow(`tools> start ${event.tool} input=${preview2}`));
+              const toolText = `- start \`${event.tool}\``;
+              toolTimeline.push(toolText);
+              currentTools.push(toolText);
+              toolEvents += 1;
+            } else if (event.type === "tool:completed") {
+              const preview2 = showToolPayloads ? compactPreview(event.output, 400) : compactPreview(event.output, 100);
+              console.log(
+                yellow(
+                  `tools> done  ${event.tool} in ${formatDuration(event.duration)}`
+                )
+              );
+              if (showToolPayloads) {
+                console.log(yellow(`tools> output ${preview2}`));
+              }
+              const toolText = `- done \`${event.tool}\` in ${formatDuration(event.duration)}`;
+              toolTimeline.push(toolText);
+              currentTools.push(toolText);
+            } else if (event.type === "tool:error") {
+              console.log(
+                red(`tools> error ${event.tool}: ${event.error}`)
+              );
+              const toolText = `- error \`${event.tool}\`: ${event.error}`;
+              toolTimeline.push(toolText);
+              currentTools.push(toolText);
+            } else if (event.type === "tool:approval:required") {
+              console.log(
+                magenta(`tools> approval required for ${event.tool}`)
+              );
+              const toolText = `- approval required \`${event.tool}\``;
+              toolTimeline.push(toolText);
+              currentTools.push(toolText);
+            }
+          } else if (event.type === "tool:approval:checkpoint") {
+            checkpointEvent = event;
+          } else if (event.type === "run:error") {
+            clearThinking();
+            runFailed = true;
+            console.log(red(`error> ${event.error.message}`));
+          } else if (event.type === "run:cancelled") {
+            clearThinking();
+            runCancelled = true;
+          } else if (event.type === "compaction:completed") {
+            clearThinking();
+            if (event.compactedMessages) {
+              messages.length = 0;
+              messages.push(...event.compactedMessages);
+            }
+            console.log(
+              gray(
+                `compact> ${event.messagesBefore} \u2192 ${event.messagesAfter} messages (${event.tokensBefore.toLocaleString()} \u2192 ${event.tokensAfter.toLocaleString()} tokens est.)`
+              )
+            );
+          } else if (event.type === "compaction:warning") {
+            clearThinking();
+            console.log(gray(`compact> ${event.reason}`));
+          } else if (event.type === "model:response") {
+            usage = event.usage;
+          } else if (event.type === "run:completed" && !sawChunk) {
+            clearThinking();
+            responseText = event.result.response ?? "";
+            if (responseText.length > 0) {
+              process.stdout.write(
+                `${C.green}assistant> ${C.reset}${responseText}
+`
+              );
+            }
+          }
+        }
+        if (!checkpointEvent) break;
+        if (streamedText.length > 0) {
+          process.stdout.write("\n");
+          streamedText = "";
+        }
+        clearThinking();
+        const preview = compactPreview(checkpointEvent.input, 100);
+        const answer = await ask(
+          rl,
+          `${C.yellow}${C.bold}Tool "${checkpointEvent.tool}" requires approval${C.reset}
+${C.gray}input: ${preview}${C.reset}
+${C.yellow}approve? (y/n): ${C.reset}`
+        );
+        const approved = answer.trim().toLowerCase() === "y";
+        console.log(
+          approved ? green(`  approved ${checkpointEvent.tool}`) : magenta(`  denied ${checkpointEvent.tool}`)
+        );
+        const approvalText = approved ? `- approval granted (${checkpointEvent.approvalId})` : `- approval denied (${checkpointEvent.approvalId})`;
+        toolTimeline.push(approvalText);
+        currentTools.push(approvalText);
+        let toolResults;
+        if (approved) {
+          const execResults = await harness.executeTools(
+            [{ id: checkpointEvent.toolCallId, name: checkpointEvent.tool, input: checkpointEvent.input }],
+            { runId: latestRunId, agentId: "interactive", step: 0, workingDir, parameters: params }
+          );
+          toolResults = execResults.map((r) => ({
+            callId: r.callId,
+            toolName: r.tool,
+            result: r.output,
+            error: r.error
+          }));
+          for (const r of execResults) {
+            if (r.error) {
+              console.log(red(`tools> error ${r.tool}: ${r.error}`));
+              const toolText = `- error \`${r.tool}\`: ${r.error}`;
+              toolTimeline.push(toolText);
+              currentTools.push(toolText);
+            } else {
+              console.log(yellow(`tools> done  ${r.tool}`));
+              const toolText = `- done \`${r.tool}\``;
+              toolTimeline.push(toolText);
+              currentTools.push(toolText);
+            }
+          }
+        } else {
+          toolResults = [{
+            callId: checkpointEvent.toolCallId,
+            toolName: checkpointEvent.tool,
+            error: "Tool execution denied by user"
+          }];
+        }
+        const fullMessages = [...messages, ...checkpointEvent.checkpointMessages];
+        eventSource = harness.continueFromToolResult({
+          messages: fullMessages,
+          toolResults,
+          abortSignal: activeRunAbortController.signal
+        });
+        process.stdout.write(gray("thinking..."));
+        thinkingCleared = false;
+      }
+    } catch (error) {
+      clearThinking();
+      if (activeRunAbortController?.signal.aborted) {
+        runCancelled = true;
+      } else {
+        runFailed = true;
+        console.log(
+          red(
+            `error> ${error instanceof Error ? error.message : "Unknown error"}`
+          )
+        );
+      }
+    } finally {
+      activeRunAbortController = null;
+    }
+    if (sawChunk && streamedText.length > 0) {
+      process.stdout.write("\n");
+    } else if (!sawChunk && !runFailed && !runCancelled && responseText.length === 0) {
+      clearThinking();
+      console.log(green("assistant> (no response)"));
+    }
+    const fullResponse = responseText || streamedText;
+    if (!runFailed && toolEvents === 0 && FAUX_TOOL_LOG_PATTERN.test(fullResponse)) {
+      console.log(
+        magenta(
+          "warning> assistant described tool execution but no real tool events occurred."
+        )
+      );
+    }
+    const durationMs = Date.now() - startedAt;
+    console.log(
+      gray(`meta> ${formatDuration(durationMs)} | tools: ${toolEvents}
+`)
+    );
+    if (!activeConversationId) {
+      const created = await conversationStore.create(
+        OWNER_ID,
+        inferConversationTitle(trimmed)
+      );
+      activeConversationId = created.conversationId;
+    }
+    if (currentTools.length > 0) {
+      sections.push({ type: "tools", content: currentTools });
+    }
+    if (currentText.length > 0) {
+      sections.push({ type: "text", content: currentText });
+    }
+    messages.push({ role: "user", content: trimmed });
+    const hasAssistantContent = responseText.length > 0 || toolTimeline.length > 0 || sections.length > 0;
+    if (hasAssistantContent) {
+      messages.push({
+        role: "assistant",
+        content: responseText,
+        metadata: toolTimeline.length > 0 || sections.length > 0 ? {
+          toolActivity: toolTimeline,
+          sections: sections.length > 0 ? sections : void 0
+        } : void 0
+      });
+    }
+    turn = computeTurn(messages);
+    const conversation = await conversationStore.get(activeConversationId);
+    if (conversation) {
+      const maybeTitle = conversation.messages.length === 0 && (conversation.title === "New conversation" || conversation.title.trim().length === 0) ? inferConversationTitle(trimmed) : conversation.title;
+      await conversationStore.update({
+        ...conversation,
+        title: maybeTitle,
+        messages: [...messages],
+        runtimeRunId: latestRunId || conversation.runtimeRunId
+      });
+    }
+  }
+  rl.close();
+};
+export {
+  runInteractiveInk
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poncho-ai/cli",
-  "version": "0.37.0",
+  "version": "0.38.0",
   "description": "CLI for building and deploying AI agents",
   "repository": {
     "type": "git",
@@ -28,9 +28,9 @@
     "react": "^19.2.4",
     "react-devtools-core": "^6.1.5",
     "yaml": "^2.8.1",
-    "@poncho-ai/harness": "0.38.0",
-    "@poncho-ai/messaging": "0.8.3",
-    "@poncho-ai/sdk": "1.8.1"
+    "@poncho-ai/harness": "0.39.0",
+    "@poncho-ai/messaging": "0.8.4",
+    "@poncho-ai/sdk": "1.9.0"
   },
   "devDependencies": {
     "@types/busboy": "^1.5.4",