@bunny-agent/sdk 0.9.28

package/dist/index.js

@@ -0,0 +1,790 @@
+// src/index.ts
+import {
+  buildRunnerEnv,
+  DEFAULT_BUNNY_AGENT_DAEMON_URL,
+  isBunnyAgentDaemonHealthy,
+  LocalSandbox
+} from "@bunny-agent/manager";
+
+// src/provider/bunny-agent-language-model.ts
+import {
+  BunnyAgent,
+  streamCodingRunFromSandbox
+} from "@bunny-agent/manager";
+
+// src/provider/logging.ts
+function getProviderLogger(settings) {
+  if (settings.logger === false) {
+    return {
+      debug: () => {
+      },
+      info: () => {
+      },
+      warn: () => {
+      },
+      error: () => {
+      }
+    };
+  }
+  if (settings.logger) {
+    return settings.logger;
+  }
+  const isVerbose = settings.verbose ?? false;
+  return {
+    debug: (msg) => isVerbose && console.debug(msg),
+    info: (msg) => isVerbose && console.info(msg),
+    warn: (msg) => console.warn(msg),
+    error: (msg) => console.error(msg)
+  };
+}
+
+// src/provider/bunny-agent-language-model.ts
+function formatErrorForLog(error) {
+  if (error instanceof Error) {
+    const parts = [error.message];
+    let cause = error.cause;
+    while (cause instanceof Error) {
+      parts.push(cause.message);
+      cause = cause.cause;
+    }
+    return parts.join(" | cause: ");
+  }
+  return String(error);
+}
+function asyncIterableToReadableStream(iterable) {
+  const iterator = iterable[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async pull(controller) {
+      while (true) {
+        const { done, value } = await iterator.next();
+        if (done) {
+          controller.close();
+          return;
+        }
+        if (value.byteLength > 0) {
+          controller.enqueue(value);
+          return;
+        }
+      }
+    },
+    async cancel(reason) {
+      await iterator.return?.(reason);
+    }
+  });
+}
+function getLastUserTextFromMessages(messages) {
+  const lastUser = [...messages].reverse().find((m) => m.role === "user");
+  if (!lastUser) return "";
+  const c = lastUser.content;
+  if (typeof c === "string") return c;
+  return c.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+}
+function createEmptyUsage() {
+  return {
+    inputTokens: {
+      total: 0,
+      noCache: 0,
+      cacheRead: 0,
+      cacheWrite: 0
+    },
+    outputTokens: {
+      total: 0,
+      text: void 0,
+      reasoning: void 0
+    },
+    raw: void 0
+  };
+}
+var BunnyAgentLanguageModel = class {
+  specificationVersion = "v3";
+  provider;
+  modelId;
+  supportedUrls = {
+    "image/*": [/.*/]
+  };
+  options;
+  logger;
+  sessionId;
+  toolNameMap = /* @__PURE__ */ new Map();
+  legacyTextPartCounter = 0;
+  constructor(modelOptions) {
+    this.modelId = modelOptions.id;
+    this.options = modelOptions.options;
+    this.logger = getProviderLogger(modelOptions.options);
+    this.provider = modelOptions.options.daemonUrl ? "bunny-agent-daemon" : "bunny-agent";
+  }
+  async doGenerate(options) {
+    const { stream, request } = await this.doStream(options);
+    const reader = stream.getReader();
+    const content = [];
+    const warnings = [];
+    let finishReason = {
+      unified: "other",
+      raw: void 0
+    };
+    let usage = createEmptyUsage();
+    let providerMetadata;
+    const textParts = /* @__PURE__ */ new Map();
+    const toolInputs = /* @__PURE__ */ new Map();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        switch (value.type) {
+          case "text-start": {
+            textParts.set(value.id, { text: "" });
+            break;
+          }
+          case "text-delta": {
+            const part = textParts.get(value.id);
+            if (part) {
+              part.text += value.delta;
+            }
+            break;
+          }
+          case "text-end": {
+            const part = textParts.get(value.id);
+            if (part) {
+              content.push({
+                type: "text",
+                text: part.text
+              });
+            }
+            break;
+          }
+          case "tool-input-start": {
+            toolInputs.set(value.id, { toolName: value.toolName, input: "" });
+            break;
+          }
+          case "tool-input-delta": {
+            const tool = toolInputs.get(value.id);
+            if (tool) {
+              tool.input += value.delta;
+            }
+            break;
+          }
+          case "tool-input-end": {
+            break;
+          }
+          case "tool-call": {
+            content.push({
+              type: "tool-call",
+              toolCallId: value.toolCallId,
+              toolName: value.toolName,
+              input: value.input,
+              providerExecuted: value.providerExecuted
+            });
+            break;
+          }
+          case "stream-start": {
+            warnings.push(...value.warnings);
+            break;
+          }
+          case "error": {
+            const message = value.error instanceof Error ? value.error.message : typeof value.error === "string" ? value.error : value.error ? String(value.error) : "Unknown error";
+            content.push({ type: "text", text: message });
+            finishReason = { unified: "error", raw: "error" };
+            break;
+          }
+          case "finish": {
+            finishReason = value.finishReason;
+            usage = value.usage;
+            providerMetadata = value.providerMetadata;
+            break;
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    return {
+      content,
+      finishReason,
+      usage,
+      providerMetadata,
+      request,
+      warnings
+    };
+  }
+  async doStream(options) {
+    const { prompt, abortSignal } = options;
+    const messages = this.convertPromptToMessages(prompt);
+    this.resetStreamState();
+    this.logger.debug(
+      `[bunny-agent] Starting stream with ${messages.length} messages`
+    );
+    const sandbox = this.options.sandbox;
+    if (!sandbox) {
+      throw new Error(
+        "BunnyAgent language model requires a sandbox adapter (set `sandbox` on the provider)."
+      );
+    }
+    const daemonUrl = this.options.daemonUrl;
+    if (daemonUrl) {
+      const handle = await sandbox.attach();
+      const sandboxEnv2 = sandbox.getEnv?.() ?? {};
+      const runnerEnv = { ...sandboxEnv2, ...this.options.env };
+      const body = {
+        ...this.buildCodingRunBody(messages, handle.getWorkdir()),
+        ...Object.keys(runnerEnv).length > 0 ? { env: runnerEnv } : {}
+      };
+      const execOpts = {
+        cwd: this.options.cwd ?? handle.getWorkdir(),
+        signal: abortSignal
+      };
+      const iterable = streamCodingRunFromSandbox(
+        handle,
+        daemonUrl,
+        body,
+        execOpts
+      );
+      const bytesStream = asyncIterableToReadableStream(iterable);
+      return this.buildStreamResult(bytesStream, messages);
+    }
+    const sandboxEnv = sandbox.getEnv?.() ?? {};
+    const sandboxWorkdir = this.options.cwd ?? sandbox.getWorkdir?.() ?? "/workspace";
+    const agent = new BunnyAgent({
+      sandbox,
+      runner: this.options.runner,
+      env: { ...sandboxEnv, ...this.options.env }
+    });
+    try {
+      const bytesStream = await agent.stream({
+        messages,
+        workspace: {
+          path: sandboxWorkdir
+        },
+        resume: this.options.resume,
+        signal: abortSignal
+      });
+      return this.buildStreamResult(bytesStream, messages);
+    } catch (error) {
+      await agent.destroy().catch(() => {
+      });
+      throw error;
+    }
+  }
+  resetStreamState() {
+    this.sessionId = void 0;
+    this.toolNameMap = /* @__PURE__ */ new Map();
+    this.legacyTextPartCounter = 0;
+  }
+  buildCodingRunBody(messages, cwdFallback) {
+    const runner = this.options.runner;
+    const cwd = this.options.cwd ?? cwdFallback;
+    return {
+      runner: runner.runnerType ?? "claude",
+      model: this.modelId,
+      userInput: getLastUserTextFromMessages(messages),
+      cwd,
+      resume: this.options.resume,
+      systemPrompt: this.options.systemPrompt ?? runner.systemPrompt,
+      maxTurns: this.options.maxTurns ?? runner.maxTurns,
+      allowedTools: runner.allowedTools ?? this.options.allowedTools,
+      skillPaths: runner.skillPaths ?? this.options.skillPaths,
+      yolo: this.options.yolo
+    };
+  }
+  buildStreamResult(bytesStream, messages) {
+    const reader = bytesStream.getReader();
+    return {
+      stream: this.createLanguageModelStreamFromSseReader(reader),
+      request: {
+        body: JSON.stringify({ messages })
+      }
+    };
+  }
+  createLanguageModelStreamFromSseReader(reader) {
+    const self = this;
+    return new ReadableStream({
+      async start(controller) {
+        try {
+          let buffer = "";
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              if (buffer.trim()) {
+                const parts = self.parseSSEBuffer(buffer);
+                for (const part of parts) {
+                  controller.enqueue(part);
+                }
+              }
+              controller.close();
+              break;
+            }
+            const text = new TextDecoder().decode(value);
+            buffer += text;
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            let foundDone = false;
+            for (const line of lines) {
+              const candidate = line.startsWith("data: ") ? line.slice(6) : line.trim();
+              if (!candidate) continue;
+              if (candidate === "[DONE]") {
+                foundDone = true;
+                continue;
+              }
+              try {
+                const parts = self.parseSSEData(candidate);
+                for (const part of parts) {
+                  controller.enqueue(part);
+                  if (self.sessionId) {
+                    const sessionId = self.sessionId;
+                    if (self.options.artifactProcessors?.length) {
+                      for (const processor of self.options.artifactProcessors) {
+                        Promise.resolve().then(() => processor.onChange(part, sessionId)).catch((e) => {
+                          self.logger.error(
+                            `[bunny-agent] Artifact processor error: ${e}`
+                          );
+                        });
+                      }
+                    }
+                  }
+                }
+              } catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                if (!msg.includes("Unexpected token")) {
+                  self.logger.error(
+                    `[bunny-agent] Failed to parse stream data: ${e}`
+                  );
+                }
+              }
+            }
+            if (foundDone) {
+              controller.close();
+              return;
+            }
+          }
+        } catch (error) {
+          if (error instanceof Error && error.name === "AbortError") {
+            self.logger.info("[bunny-agent] Stream aborted by user");
+          } else {
+            self.logger.error(
+              `[bunny-agent] Stream error: ${formatErrorForLog(error)}`
+            );
+          }
+          controller.error(error);
+        }
+      },
+      cancel() {
+        reader.cancel();
+      }
+    });
+  }
+  parseSSEBuffer(buffer) {
+    const parts = [];
+    const lines = buffer.split("\n");
+    for (const line of lines) {
+      const candidate = line.startsWith("data: ") ? line.slice(6) : line.trim();
+      if (!candidate || candidate === "[DONE]") continue;
+      try {
+        const parsedParts = this.parseSSEData(candidate);
+        parts.push(...parsedParts);
+      } catch {
+      }
+    }
+    return parts;
+  }
+  parseSSEData(data) {
+    const parts = [];
+    const parsed = JSON.parse(data);
+    const parsedType = typeof parsed.type === "string" ? parsed.type : void 0;
+    if (!parsedType && typeof parsed.error === "string") {
+      return [
+        {
+          type: "error",
+          error: new Error(parsed.error)
+        }
+      ];
+    }
+    switch (parsedType) {
+      case "start": {
+        break;
+      }
+      // Backward-compatible NDJSON chunk from daemon tests/mock runners.
+      case "text": {
+        const text = typeof parsed.text === "string" ? parsed.text : "";
+        if (text.length > 0) {
+          const id = `legacy-text-${++this.legacyTextPartCounter}`;
+          parts.push(
+            {
+              type: "text-start",
+              id,
+              providerMetadata: {
+                "bunny-agent": {
+                  sessionId: this.sessionId
+                }
+              }
+            },
+            { type: "text-delta", id, delta: text },
+            { type: "text-end", id }
+          );
+        }
+        break;
+      }
+      case "message-metadata": {
+        const metadata = parsed.messageMetadata;
+        if (metadata?.sessionId && typeof metadata.sessionId === "string") {
+          this.sessionId = metadata.sessionId;
+          this.logger.debug(
+            `[bunny-agent] Session ID extracted: ${this.sessionId}`
+          );
+          parts.push({
+            type: "raw",
+            rawValue: this.sessionId
+          });
+        }
+        break;
+      }
+      case "text-start": {
+        parts.push({
+          type: "text-start",
+          id: parsed.id,
+          providerMetadata: {
+            "bunny-agent": {
+              sessionId: this.sessionId
+            }
+          }
+        });
+        break;
+      }
+      case "text-delta": {
+        parts.push({
+          type: "text-delta",
+          id: parsed.id,
+          delta: parsed.delta
+        });
+        break;
+      }
+      case "text-end": {
+        parts.push({
+          type: "text-end",
+          id: parsed.id
+        });
+        break;
+      }
+      case "tool-input-start": {
+        parts.push({
+          type: "tool-input-start",
+          id: parsed.toolCallId,
+          toolName: parsed.toolName,
+          dynamic: parsed.dynamic,
+          providerExecuted: parsed.providerExecuted
+        });
+        break;
+      }
+      case "tool-input-delta": {
+        parts.push({
+          type: "tool-input-delta",
+          id: parsed.toolCallId,
+          delta: parsed.inputTextDelta
+        });
+        break;
+      }
+      case "tool-input-available": {
+        const toolCallId = parsed.toolCallId;
+        const toolName = parsed.toolName;
+        const input = parsed.input;
+        this.toolNameMap.set(toolCallId, toolName);
+        parts.push({
+          type: "tool-call",
+          toolCallId,
+          toolName,
+          input: JSON.stringify(input),
+          dynamic: parsed.dynamic,
+          providerExecuted: parsed.providerExecuted
+        });
+        break;
+      }
+      case "tool-output-available": {
+        const toolName = this.toolNameMap.get(parsed.toolCallId);
+        parts.push({
+          type: "tool-result",
+          toolCallId: parsed.toolCallId,
+          toolName: toolName ?? "",
+          result: parsed.output,
+          isError: parsed.isError,
+          dynamic: parsed.dynamic
+        });
+        break;
+      }
+      case "error": {
+        parts.push({
+          type: "error",
+          error: new Error(
+            parsed.errorText || parsed.error || "Unknown stream error"
+          )
+        });
+        break;
+      }
+      case "finish": {
+        const rawFinishReason = parsed.finishReason;
+        let finishReason;
+        if (typeof rawFinishReason === "object" && rawFinishReason !== null && "unified" in rawFinishReason) {
+          finishReason = rawFinishReason;
+        } else {
+          finishReason = this.mapFinishReason(rawFinishReason);
+        }
+        const messageMetadata = parsed.messageMetadata;
+        const rawUsage = messageMetadata?.usage;
+        const usage = this.convertUsage(rawUsage);
+        parts.push({
+          type: "finish",
+          finishReason,
+          usage,
+          providerMetadata: {
+            "bunny-agent": {
+              ...parsed.messageMetadata ?? {},
+              sessionId: this.sessionId
+            }
+          }
+        });
+        break;
+      }
+    }
+    return parts;
+  }
+  convertPromptToMessages(prompt) {
+    const messages = [];
+    for (const message of prompt) {
+      switch (message.role) {
+        case "system": {
+          messages.push({
+            role: "system",
+            content: message.content
+          });
+          break;
+        }
+        case "user": {
+          const parts = message.content.map((part) => {
+            if (part.type === "text") {
+              return { type: "text", text: part.text };
+            }
+            if (part.type === "file") {
+              let dataStr = "";
+              if (part.data instanceof Uint8Array) {
+                dataStr = `data:${part.mediaType};base64,${Buffer.from(part.data).toString("base64")}`;
+              } else if (part.data instanceof URL) {
+                dataStr = part.data.toString();
+              } else if (typeof part.data === "string") {
+                dataStr = part.data;
+              }
+              return {
+                type: "image",
+                mimeType: part.mediaType || "image/png",
+                data: dataStr
+              };
+            }
+            return null;
+          }).filter(
+            (p) => p !== null
+          );
+          if (parts.length > 0) {
+            const isAllText = parts.every((p) => p.type === "text");
+            messages.push({
+              role: "user",
+              content: isAllText ? parts.map((p) => p.text).join("\n") : parts
+            });
+          }
+          break;
+        }
+        case "assistant": {
+          const textParts = message.content.filter(
+            (part) => part.type === "text"
+          ).map((part) => part.text);
+          if (textParts.length > 0) {
+            messages.push({
+              role: "assistant",
+              content: textParts.join("\n")
+            });
+          }
+          break;
+        }
+        case "tool": {
+          break;
+        }
+      }
+    }
+    return messages;
+  }
+  mapFinishReason(reason) {
+    switch (reason) {
+      case "stop":
+        return { unified: "stop", raw: reason };
+      case "length":
+        return { unified: "length", raw: reason };
+      case "tool_calls":
+      case "tool-calls":
+        return { unified: "tool-calls", raw: reason };
+      case "content_filter":
+      case "content-filter":
+        return { unified: "content-filter", raw: reason };
+      case "error":
+        return { unified: "error", raw: reason };
+      default:
+        return { unified: "other", raw: reason ?? "unknown" };
+    }
+  }
+  convertUsage(data) {
+    if (!data) {
+      return createEmptyUsage();
+    }
+    if ("inputTokens" in data && "outputTokens" in data) {
+      const inputTokens = data.inputTokens;
+      const outputTokens = data.outputTokens;
+      const rawData = "raw" in data ? data.raw : data;
+      return {
+        inputTokens: {
+          total: inputTokens.total ?? 0,
+          noCache: inputTokens.noCache ?? 0,
+          cacheRead: inputTokens.cacheRead ?? 0,
+          cacheWrite: inputTokens.cacheWrite ?? 0
+        },
+        outputTokens: {
+          total: outputTokens.total ?? 0,
+          text: outputTokens.text ?? outputTokens.textTokens ?? void 0,
+          reasoning: outputTokens.reasoning ?? outputTokens.reasoningTokens ?? void 0
+        },
+        raw: rawData
+      };
+    }
+    const usage = data.usage ?? data;
+    if ("input_tokens" in usage || "output_tokens" in usage) {
+      const inputTokens = usage.input_tokens ?? 0;
+      const outputTokens = usage.output_tokens ?? 0;
+      const cacheWrite = usage.cache_creation_input_tokens ?? 0;
+      const cacheRead = usage.cache_read_input_tokens ?? 0;
+      const textTokens = usage.text_tokens ?? void 0;
+      const reasoningTokens = usage.reasoning_tokens ?? void 0;
+      return {
+        inputTokens: {
+          total: inputTokens + cacheWrite + cacheRead,
+          noCache: inputTokens,
+          cacheRead,
+          cacheWrite
+        },
+        outputTokens: {
+          total: outputTokens,
+          text: textTokens,
+          reasoning: reasoningTokens
+        },
+        raw: usage
+      };
+    }
+    return createEmptyUsage();
+  }
+};
+
+// src/provider/bunny-agent-provider.ts
+import { NoSuchModelError } from "@ai-sdk/provider";
+function createBunnyAgent(defaultOptions) {
+  const logger = getProviderLogger(defaultOptions);
+  if (!defaultOptions.sandbox) {
+    throw new Error(
+      "Provide a `sandbox` adapter (e.g. E2BSandbox, LocalSandbox). Optional `daemonUrl` uses in-sandbox HTTP to bunny-agent-daemon (no automatic `/healthz` probe). Use `isBunnyAgentDaemonHealthy` from `@bunny-agent/sdk` if you want to probe and omit `daemonUrl` for CLI fallback. Omit `daemonUrl` to always use CLI."
+    );
+  }
+  const createModel = (modelId, options = {}) => {
+    const mergedSkillPaths = options.skillPaths !== void 0 ? options.skillPaths : defaultOptions.skillPaths;
+    const mergedAllowedTools = options.allowedTools !== void 0 ? options.allowedTools : defaultOptions.allowedTools;
+    const runner = {
+      model: modelId,
+      runnerType: options.runnerType ?? defaultOptions.runnerType,
+      outputFormat: "stream",
+      maxTurns: options.maxTurns ?? defaultOptions.maxTurns,
+      ...options.systemPrompt ?? defaultOptions.systemPrompt ? { systemPrompt: options.systemPrompt ?? defaultOptions.systemPrompt } : {},
+      ...mergedSkillPaths && mergedSkillPaths.length > 0 ? { skillPaths: mergedSkillPaths } : {},
+      ...mergedAllowedTools !== void 0 ? { allowedTools: mergedAllowedTools } : {}
+    };
+    const mergedOptions = {
+      ...defaultOptions,
+      ...options,
+      runner,
+      env: {
+        ...defaultOptions.env,
+        ...options.env
+      },
+      artifactProcessors: [
+        ...defaultOptions.artifactProcessors ?? [],
+        ...options.artifactProcessors ?? []
+      ]
+    };
+    logger.debug(
+      `[bunny-agent] Creating model: ${modelId}${runner.runnerType ? ` (runnerType: ${runner.runnerType})` : ""}${runner.skillPaths?.length ? ` skillPaths=${runner.skillPaths.length}` : ""}`
+    );
+    return new BunnyAgentLanguageModel({
+      id: modelId,
+      options: mergedOptions
+    });
+  };
+  const provider = function(modelId, options) {
+    if (new.target) {
+      throw new Error(
+        "The BunnyAgent model function cannot be called with the new keyword."
+      );
+    }
+    return createModel(modelId, options);
+  };
+  provider.languageModel = createModel;
+  provider.chat = createModel;
+  provider.specificationVersion = "v3";
+  provider.embeddingModel = (modelId) => {
+    throw new NoSuchModelError({
+      modelId,
+      modelType: "embeddingModel"
+    });
+  };
+  provider.textEmbeddingModel = (modelId) => {
+    throw new NoSuchModelError({
+      modelId,
+      modelType: "embeddingModel"
+    });
+  };
+  provider.imageModel = (modelId) => {
+    throw new NoSuchModelError({
+      modelId,
+      modelType: "imageModel"
+    });
+  };
+  return provider;
+}
+
+// src/provider/question-processor.ts
+async function submitAnswer(sandbox, params, options) {
+  const { toolCallId, questions, answers } = params;
+  const basePath = options?.basePath ?? ".bunny-agent/approvals";
+  const allAnswered = questions.every(
+    (q) => answers[q.question] !== void 0 && answers[q.question] !== ""
+  );
+  const answerData = {
+    questions,
+    answers,
+    status: allAnswered ? "completed" : "pending",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const filename = `${toolCallId}.json`;
+  const handle = sandbox.getHandle() ?? await sandbox.attach();
+  const workdir = handle.getWorkdir();
+  const targetDir = workdir ? `${workdir.replace(/\/$/, "")}/${basePath}` : basePath;
+  await handle.upload(
+    [{ path: filename, content: JSON.stringify(answerData, null, 2) }],
+    targetDir
+  );
+  console.log(
+    `[submitAnswer] Answer submitted: ${targetDir}/${filename} (status: ${answerData.status}, workdir: ${workdir ?? "(none)"})`
+  );
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+export {
+  BunnyAgentLanguageModel,
+  DEFAULT_BUNNY_AGENT_DAEMON_URL,
+  LocalSandbox,
+  VERSION,
+  buildRunnerEnv,
+  createBunnyAgent,
+  isBunnyAgentDaemonHealthy,
+  submitAnswer
+};
+//# sourceMappingURL=index.js.map