@sandagent/sdk 0.2.0-beta.5

package/dist/index.js

@@ -0,0 +1,631 @@
+// src/provider/sandagent-provider.ts
+import { NoSuchModelError } from "@ai-sdk/provider";
+
+// src/provider/sandagent-language-model.ts
+import { SandAgent } from "@sandagent/manager";
+
+// src/provider/types.ts
+function resolveModelId(modelId) {
+  switch (modelId) {
+    case "sonnet":
+      return "claude-sonnet-4-20250514";
+    case "opus":
+      return "claude-opus-4-20250514";
+    case "haiku":
+      return "claude-3-5-haiku-20241022";
+    default:
+      return modelId;
+  }
+}
+function getRunnerKindForModel(modelId) {
+  const resolvedId = resolveModelId(modelId);
+  if (resolvedId.startsWith("claude") || resolvedId.includes("anthropic") || resolvedId.startsWith("us.anthropic")) {
+    return "claude-agent-sdk";
+  }
+  return "claude-agent-sdk";
+}
+
+// src/provider/sandagent-language-model.ts
+function getLogger(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)
+  };
+}
+function createEmptyUsage() {
+  return {
+    inputTokens: {
+      total: 0,
+      noCache: 0,
+      cacheRead: 0,
+      cacheWrite: 0
+    },
+    outputTokens: {
+      total: 0,
+      text: void 0,
+      reasoning: void 0
+    }
+  };
+}
+var SandAgentLanguageModel = class {
+  specificationVersion = "v3";
+  provider = "sandagent";
+  modelId;
+  supportedUrls = {
+    "image/*": [/.*/]
+  };
+  options;
+  logger;
+  sessionId;
+  toolNameMap = /* @__PURE__ */ new Map();
+  constructor(modelOptions) {
+    this.modelId = resolveModelId(modelOptions.id);
+    this.options = modelOptions.options;
+    this.logger = getLogger(modelOptions.options);
+  }
+  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 "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.logger.debug(
+      `[sandagent] Starting stream with ${messages.length} messages`
+    );
+    const sandbox = this.options.sandbox;
+    const sandboxEnv = sandbox.getEnv?.() ?? {};
+    const sandboxWorkdir = this.options.cwd ?? sandbox.getWorkdir?.() ?? "/workspace";
+    const agent = new SandAgent({
+      sandbox: this.options.sandbox,
+      runner: this.options.runner,
+      env: { ...sandboxEnv, ...this.options.env }
+    });
+    try {
+      const stream = await agent.stream({
+        messages,
+        workspace: {
+          path: sandboxWorkdir
+        },
+        resume: this.options.resume,
+        signal: abortSignal
+      });
+      const self = this;
+      const reader = stream.getReader();
+      if (!reader) {
+        throw new Error("Response body is not readable");
+      }
+      const outputStream = 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) {
+                if (line.startsWith("data: ")) {
+                  const data = line.slice(6);
+                  if (data === "[DONE]") {
+                    foundDone = true;
+                    continue;
+                  }
+                  try {
+                    const parts = self.parseSSEData(data);
+                    for (const part of parts) {
+                      controller.enqueue(part);
+                      if (self.options.artifactProcessors?.length && self.sessionId) {
+                        const sessionId = self.sessionId;
+                        for (const processor of self.options.artifactProcessors) {
+                          Promise.resolve().then(() => processor.onChange(part, sessionId)).catch((e) => {
+                            self.logger.error(
+                              `[sandagent] Artifact processor error: ${e}`
+                            );
+                          });
+                        }
+                      }
+                    }
+                  } catch (e) {
+                    self.logger.error(
+                      `[sandagent] Failed to parse SSE data: ${e}`
+                    );
+                  }
+                }
+              }
+              if (foundDone) {
+                controller.close();
+                return;
+              }
+            }
+          } catch (error) {
+            if (error instanceof Error && error.name === "AbortError") {
+              self.logger.info("[sandagent] Stream aborted by user");
+            } else {
+              self.logger.error(`[sandagent] Stream error: ${error}`);
+            }
+            controller.error(error);
+          }
+        },
+        cancel() {
+          reader.cancel();
+        }
+      });
+      return {
+        stream: outputStream,
+        request: {
+          body: JSON.stringify({ messages })
+        }
+      };
+    } catch (error) {
+      await agent.destroy().catch(() => {
+      });
+      throw error;
+    }
+  }
+  parseSSEBuffer(buffer) {
+    const parts = [];
+    const lines = buffer.split("\n");
+    for (const line of lines) {
+      if (line.startsWith("data: ")) {
+        const data = line.slice(6);
+        if (data === "[DONE]") {
+          continue;
+        }
+        try {
+          const parsedParts = this.parseSSEData(data);
+          parts.push(...parsedParts);
+        } catch (e) {
+          this.logger.error(`[sandagent] Failed to parse SSE data: ${e}`);
+        }
+      }
+    }
+    return parts;
+  }
+  parseSSEData(data) {
+    const parts = [];
+    const parsed = JSON.parse(data);
+    switch (parsed.type) {
+      case "start": {
+        break;
+      }
+      case "message-metadata": {
+        const metadata = parsed.messageMetadata;
+        if (metadata?.sessionId && typeof metadata.sessionId === "string") {
+          this.sessionId = metadata.sessionId;
+          this.logger.debug(
+            `[sandagent] 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: {
+            "claude-code": {
+              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)
+        });
+        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 rawUsage = parsed.usage ?? parsed.messageMetadata;
+        const usage = this.convertUsage(
+          rawUsage
+        );
+        parts.push({
+          type: "finish",
+          finishReason,
+          usage,
+          providerMetadata: {
+            sandagent: parsed.messageMetadata
+          }
+        });
+        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 textParts = message.content.filter(
+            (part) => part.type === "text"
+          ).map((part) => part.text);
+          if (textParts.length > 0) {
+            messages.push({
+              role: "user",
+              content: textParts.join("\n")
+            });
+          }
+          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;
+      return {
+        inputTokens: {
+          total: inputTokens.total ?? 0,
+          noCache: inputTokens.noCache ?? 0,
+          cacheRead: inputTokens.cacheRead ?? 0,
+          cacheWrite: inputTokens.cacheWrite ?? 0
+        },
+        outputTokens: {
+          total: outputTokens.total ?? 0,
+          text: void 0,
+          reasoning: void 0
+        }
+      };
+    }
+    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;
+      return {
+        inputTokens: {
+          total: inputTokens + cacheWrite + cacheRead,
+          noCache: inputTokens,
+          cacheRead,
+          cacheWrite
+        },
+        outputTokens: {
+          total: outputTokens,
+          text: void 0,
+          reasoning: void 0
+        }
+      };
+    }
+    return createEmptyUsage();
+  }
+};
+
+// src/provider/sandagent-provider.ts
+function getLogger2(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)
+  };
+}
+function createSandAgent(defaultOptions) {
+  const logger = getLogger2(defaultOptions);
+  if (!defaultOptions.sandbox) {
+    throw new Error(
+      "SandAgent provider requires a sandbox adapter. Please provide one, e.g.: new E2BSandbox({ apiKey: 'xxx' })"
+    );
+  }
+  const createModel = (modelId, options = {}) => {
+    const runnerKind = getRunnerKindForModel(modelId);
+    const resolvedModelId = resolveModelId(modelId);
+    const runner = {
+      kind: runnerKind,
+      model: resolvedModelId,
+      outputFormat: "stream"
+    };
+    const mergedOptions = {
+      ...defaultOptions,
+      ...options,
+      runner,
+      env: {
+        ...defaultOptions.env,
+        ...options.env
+      },
+      artifactProcessors: [
+        ...defaultOptions.artifactProcessors ?? [],
+        ...options.artifactProcessors ?? []
+      ]
+    };
+    logger.debug(
+      `[sandagent] Creating model: ${modelId} with runner: ${runner.kind}`
+    );
+    return new SandAgentLanguageModel({
+      id: modelId,
+      options: mergedOptions
+    });
+  };
+  const provider = function(modelId, options) {
+    if (new.target) {
+      throw new Error(
+        "The SandAgent 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/index.ts
+import { LocalSandbox } from "@sandagent/manager";
+var VERSION = "0.1.0";
+export {
+  LocalSandbox,
+  SandAgentLanguageModel,
+  VERSION,
+  createSandAgent,
+  resolveModelId
+};
+//# sourceMappingURL=index.js.map