@sandagent/sdk 0.8.3 → 0.8.5

package/README.md

@@ -170,7 +170,7 @@ import { SandockSandbox } from "@sandagent/sandbox-sandock";
 
 const sandbox = new SandockSandbox({
   apiKey: process.env.SANDOCK_API_KEY,   // Get yours at https://sandock.ai
-  image: "vikadata/sandagent:0.1.0",     // Pre-built image (fast startup)
+  image: "ghcr.io/vikadata/sandagent:latest",     // Pre-built image (fast startup)
   skipBootstrap: true,
   workdir: "/workspace",
   env: { ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY! },
@@ -186,7 +186,7 @@ const sandagent = createSandAgent({ sandbox, cwd: sandbox.getWorkdir() });
 | Sandock Option | Description |
 |----------------|-------------|
 | `apiKey` | Your Sandock API key ([sandock.ai](https://sandock.ai)) |
-| `image` | Docker image — use `vikadata/sandagent:0.1.0` for pre-built, or `sandockai/sandock-code:latest` |
+| `image` | Docker image — use `ghcr.io/vikadata/sandagent:latest` for pre-built, or `sandockai/sandock-code:latest` |
 | `skipBootstrap` | `true` when using pre-built image (skips npm install inside sandbox) |
 | `volumes` | Named volumes for persistent workspace & session storage |
 | `keep` | `true` (default) keeps sandbox alive ~30 min after execution |
@@ -253,6 +253,8 @@ import {
 
 ### Provider
 
+#### `createSandAgent` — sandbox transport (cloud / local filesystem)
+
 ```typescript
 import { createSandAgent, LocalSandbox } from "@sandagent/sdk";
 
@@ -265,18 +267,32 @@ const sandagent = createSandAgent({
   verbose?: boolean,             // Debug logging
 });
 
-// Use as AI SDK model
-const model = sandagent("sonnet");           // Claude Sonnet (latest)
-const model = sandagent("opus");             // Claude Opus
-const model = sandagent("haiku");            // Claude Haiku
-const model = sandagent("claude-sonnet-4-20250514"); // Specific version
+const model = sandagent("claude-sonnet-4-20250514");
+```
+
+#### `createSandAgentDaemon` — daemon HTTP transport (local dev / buda embed)
+
+Use this when `sandagent-daemon` is running — either as a standalone process in a container, or embedded in a Next.js app via `createNextHandler`.
+
+```typescript
+import { createSandAgentDaemon } from "@sandagent/sdk";
+
+const sandagent = createSandAgentDaemon({
+  daemonUrl: "http://localhost:3080",  // or /api/daemon when embedded in Next.js
+  runner: "claude",                    // claude · pi · gemini · codex · opencode
+  cwd: "/workspace",
+});
+
+const model = sandagent("claude-sonnet-4-20250514");
 ```
 
+Both return the same `LanguageModelV3` interface — swap transports without changing any other code.
+
 ### Exports
 
 | Entry Point | Exports |
 |-------------|---------|
-| `@sandagent/sdk` | `createSandAgent`, `LocalSandbox`, `SandAgentLanguageModel`, `submitAnswer` |
+| `@sandagent/sdk` | `createSandAgent`, `createSandAgentDaemon`, `LocalSandbox`, `SandAgentLanguageModel`, `submitAnswer` |
 | `@sandagent/sdk/react` | `useSandAgentChat`, `useArtifacts`, `useWriteTool`, `useAskUserQuestion` |
 
 ---

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { LanguageModelV3StreamPart, ProviderV3, LanguageModelV3, EmbeddingModelV3, ImageModelV3, LanguageModelV3CallOptions, LanguageModelV3GenerateResult, LanguageModelV3StreamResult } from '@ai-sdk/provider';
-export { LanguageModelV3StreamPart } from '@ai-sdk/provider';
-import { SandAgentOptions, RunnerSpec, SandboxAdapter } from '@sandagent/manager';
+import { SandAgentOptions, SandboxAdapter, RunnerSpec } from '@sandagent/manager';
 export { LocalSandbox, LocalSandboxOptions, Message, RunnerEnvParams, RunnerType, SandboxAdapter, SandboxHandle, TranscriptEntry, buildRunnerEnv } from '@sandagent/manager';
+import { LanguageModelV3StreamPart, LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3GenerateResult, LanguageModelV3StreamResult, ProviderV3, EmbeddingModelV3, ImageModelV3 } from '@ai-sdk/provider';
+export { LanguageModelV3StreamPart } from '@ai-sdk/provider';
 
 /**
  * Artifact Processor result
@@ -101,39 +101,31 @@ interface SandAgentProviderSettings extends Omit<SandAgentOptions, "runner" | "s
 type SandAgentModelId = string;
 
 /**
- * SandAgent provider interface that extends the AI SDK's ProviderV3.
+ * Options for submitAnswer
  */
-interface SandAgentProvider extends ProviderV3 {
-    (modelId: SandAgentModelId, options?: Partial<SandAgentProviderSettings>): LanguageModelV3;
-    languageModel(modelId: SandAgentModelId, options?: Partial<SandAgentProviderSettings>): LanguageModelV3;
-    chat(modelId: SandAgentModelId, options?: Partial<SandAgentProviderSettings>): LanguageModelV3;
-    embeddingModel(modelId: string): EmbeddingModelV3;
-    textEmbeddingModel(modelId: string): EmbeddingModelV3;
-    imageModel(modelId: string): ImageModelV3;
+interface SubmitAnswerOptions {
+    /**
+     * Optional base path prefix for approval files
+     * @default ".sandagent/approvals"
+     */
+    basePath?: string;
 }
 /**
- * Creates a SandAgent provider instance with the specified configuration.
+ * Submit user's answer for an AskUserQuestion tool call.
+ * Writes the answer file to `.sandagent/approvals/{toolCallId}.json` in the sandbox workdir.
  *
  * @example
  * ```typescript
- * import { createSandAgent } from '@sandagent/sdk';
- * import { E2BSandbox } from '@sandagent/sandbox-e2b';
- * import { generateText } from 'ai';
- *
- * const sandagent = createSandAgent({
- *   sandbox: new E2BSandbox({ apiKey: process.env.E2B_API_KEY! }),
- *   env: {
- *     ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY!,
- *   },
- * });
+ * import { submitAnswer } from "@sandagent/sdk";
  *
- * const { text } = await generateText({
- *   model: sandagent('sonnet'),
- *   prompt: 'Create a hello world program',
+ * await submitAnswer(sandbox, {
+ *   toolCallId: "tool-456",
+ *   questions: [...],
+ *   answers: { "Question 1": "Answer 1" },
  * });
  * ```
  */
-declare function createSandAgent(defaultOptions: SandAgentProviderSettings): SandAgentProvider;
+declare function submitAnswer(sandbox: SandboxAdapter, params: SubmitAnswerParams, options?: SubmitAnswerOptions): Promise<void>;
 
 /**
  * Options for creating a SandAgent language model instance.
@@ -167,31 +159,86 @@ declare class SandAgentLanguageModel implements LanguageModelV3 {
 }
 
 /**
- * Options for submitAnswer
+ * SandAgent provider interface that extends the AI SDK's ProviderV3.
  */
-interface SubmitAnswerOptions {
-    /**
-     * Optional base path prefix for approval files
-     * @default ".sandagent/approvals"
-     */
-    basePath?: string;
+interface SandAgentProvider extends ProviderV3 {
+    (modelId: SandAgentModelId, options?: Partial<SandAgentProviderSettings>): LanguageModelV3;
+    languageModel(modelId: SandAgentModelId, options?: Partial<SandAgentProviderSettings>): LanguageModelV3;
+    chat(modelId: SandAgentModelId, options?: Partial<SandAgentProviderSettings>): LanguageModelV3;
+    embeddingModel(modelId: string): EmbeddingModelV3;
+    textEmbeddingModel(modelId: string): EmbeddingModelV3;
+    imageModel(modelId: string): ImageModelV3;
 }
 /**
- * Submit user's answer for an AskUserQuestion tool call.
- * Writes the answer file to `.sandagent/approvals/{toolCallId}.json` in the sandbox workdir.
+ * Creates a SandAgent provider instance with the specified configuration.
  *
  * @example
  * ```typescript
- * import { submitAnswer } from "@sandagent/sdk";
+ * import { createSandAgent } from '@sandagent/sdk';
+ * import { E2BSandbox } from '@sandagent/sandbox-e2b';
+ * import { generateText } from 'ai';
  *
- * await submitAnswer(sandbox, {
- *   toolCallId: "tool-456",
- *   questions: [...],
- *   answers: { "Question 1": "Answer 1" },
+ * const sandagent = createSandAgent({
+ *   sandbox: new E2BSandbox({ apiKey: process.env.E2B_API_KEY! }),
+ *   env: {
+ *     ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY!,
+ *   },
+ * });
+ *
+ * const { text } = await generateText({
+ *   model: sandagent('sonnet'),
+ *   prompt: 'Create a hello world program',
  * });
  * ```
  */
-declare function submitAnswer(sandbox: SandboxAdapter, params: SubmitAnswerParams, options?: SubmitAnswerOptions): Promise<void>;
+declare function createSandAgent(defaultOptions: SandAgentProviderSettings): SandAgentProvider;
+
+interface DaemonProviderSettings {
+    /** Base URL of the sandagent-daemon, e.g. "http://localhost:3080" */
+    daemonUrl: string;
+    /** Runner to use: claude, pi, gemini, codex, opencode (default: claude) */
+    runner?: string;
+    /** Working directory inside the sandbox (default: SANDAGENT_ROOT) */
+    cwd?: string;
+    /** Resume session ID */
+    resume?: string;
+    /** Override system prompt */
+    systemPrompt?: string;
+    /** Max agent turns */
+    maxTurns?: number;
+    /** Allowed tools */
+    allowedTools?: string[];
+    /** Extra skill paths (pi runner) */
+    skillPaths?: string[];
+}
+/**
+ * Create a SandAgent provider that uses sandagent-daemon as transport.
+ * Use this for local dev (Next.js embed) or when daemon is running in a container.
+ *
+ * @example
+ * ```ts
+ * import { createSandAgentDaemon } from "@sandagent/sdk";
+ *
+ * const sandagent = createSandAgentDaemon({
+ *   daemonUrl: "http://localhost:3080",
+ *   runner: "claude",
+ * });
+ *
+ * const { text } = await generateText({
+ *   model: sandagent("claude-sonnet-4-20250514"),
+ *   prompt: "Build a REST API",
+ * });
+ * ```
+ */
+declare function createSandAgentDaemon(settings: DaemonProviderSettings): {
+    (modelId: SandAgentModelId, overrides?: Partial<DaemonProviderSettings>): LanguageModelV3;
+    languageModel: (modelId: SandAgentModelId, overrides?: Partial<DaemonProviderSettings>) => LanguageModelV3;
+    chat: (modelId: SandAgentModelId, overrides?: Partial<DaemonProviderSettings>) => LanguageModelV3;
+    specificationVersion: "v3";
+    embeddingModel(): never;
+    textEmbeddingModel(): never;
+    imageModel(): never;
+};
 
 /**
  * @sandagent/sdk
@@ -216,4 +263,4 @@ declare function submitAnswer(sandbox: SandboxAdapter, params: SubmitAnswerParam
 
 declare const VERSION = "0.1.0";
 
-export { type ArtifactProcessor, type ArtifactResult, type Logger, type Question, SandAgentLanguageModel, type SandAgentLanguageModelOptions, type SandAgentModelId, type SandAgentProvider, type SandAgentProviderSettings, type StreamWriter, type SubmitAnswerOptions, type SubmitAnswerParams, VERSION, createSandAgent, submitAnswer };
+export { type ArtifactProcessor, type ArtifactResult, type DaemonProviderSettings, type Logger, type Question, SandAgentLanguageModel, type SandAgentLanguageModelOptions, type SandAgentModelId, type SandAgentProvider, type SandAgentProviderSettings, type StreamWriter, type SubmitAnswerOptions, type SubmitAnswerParams, VERSION, createSandAgent, createSandAgentDaemon, submitAnswer };

package/dist/index.js

@@ -1,5 +1,31 @@
-// src/provider/sandagent-provider.ts
-import { NoSuchModelError } from "@ai-sdk/provider";
+// src/index.ts
+import { buildRunnerEnv, LocalSandbox } from "@sandagent/manager";
+
+// src/provider/question-processor.ts
+async function submitAnswer(sandbox, params, options) {
+  const { toolCallId, questions, answers } = params;
+  const basePath = options?.basePath ?? ".sandagent/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/provider/sandagent-language-model.ts
 import { SandAgent } from "@sandagent/manager";
@@ -547,6 +573,9 @@ var SandAgentLanguageModel = class {
   }
 };
 
+// src/provider/sandagent-provider.ts
+import { NoSuchModelError } from "@ai-sdk/provider";
+
 // src/provider/types.ts
 function getRunnerKindForModel(_modelId) {
   return "claude-agent-sdk";
@@ -648,35 +677,157 @@ function createSandAgent(defaultOptions) {
   return provider;
 }
 
-// src/provider/question-processor.ts
-async function submitAnswer(sandbox, params, options) {
-  const { toolCallId, questions, answers } = params;
-  const basePath = options?.basePath ?? ".sandagent/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()
+// src/provider/sandagent-daemon-provider.ts
+var emptyUsage = {
+  inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
+  outputTokens: { total: 0, text: void 0, reasoning: void 0 }
+};
+var DaemonLanguageModel = class {
+  constructor(modelId, settings) {
+    this.settings = settings;
+    this.modelId = modelId;
+  }
+  specificationVersion = "v3";
+  provider = "sandagent-daemon";
+  modelId;
+  supportedUrls = {};
+  async doGenerate(options) {
+    const { stream, request } = await this.doStream(options);
+    const reader = stream.getReader();
+    const parts = [];
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        parts.push(value);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    const textMap = /* @__PURE__ */ new Map();
+    for (const part of parts) {
+      if (part.type === "text-start") textMap.set(part.id, "");
+      if (part.type === "text-delta") {
+        textMap.set(part.id, (textMap.get(part.id) ?? "") + part.delta);
+      }
+    }
+    const content = [...textMap.entries()].map(([, text]) => ({
+      type: "text",
+      text
+    }));
+    const finish = parts.find((p) => p.type === "finish");
+    return {
+      content,
+      finishReason: finish?.type === "finish" ? finish.finishReason : { unified: "other", raw: void 0 },
+      usage: finish?.type === "finish" ? finish.usage : emptyUsage,
+      warnings: [],
+      request
+    };
+  }
+  async doStream(options) {
+    const { prompt, abortSignal } = options;
+    const lastUser = [...prompt].reverse().find((m) => m.role === "user");
+    const userInput = lastUser?.content.filter((p) => p.type === "text").map((p) => p.text).join("\n") ?? "";
+    const body = {
+      runner: this.settings.runner ?? "claude",
+      model: this.modelId,
+      userInput,
+      cwd: this.settings.cwd,
+      resume: this.settings.resume,
+      systemPrompt: this.settings.systemPrompt,
+      maxTurns: this.settings.maxTurns,
+      allowedTools: this.settings.allowedTools,
+      skillPaths: this.settings.skillPaths
+    };
+    const response = await fetch(`${this.settings.daemonUrl}/api/coding/run`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: abortSignal
+    });
+    if (!response.ok || !response.body) {
+      throw new Error(
+        `daemon error: ${response.status} ${response.statusText}`
+      );
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    const stream = new ReadableStream({
+      async start(controller) {
+        let buffer = "";
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              controller.close();
+              break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+              if (!line.trim()) continue;
+              try {
+                const msg = JSON.parse(line);
+                if (msg.type === "text-delta") {
+                  controller.enqueue({
+                    type: "text-delta",
+                    id: msg.id,
+                    delta: msg.delta
+                  });
+                } else if (msg.type === "text-start") {
+                  controller.enqueue({
+                    type: "text-start",
+                    id: msg.id
+                  });
+                } else if (msg.type === "text-end") {
+                  controller.enqueue({
+                    type: "text-end",
+                    id: msg.id
+                  });
+                } else if (msg.type === "finish") {
+                  controller.enqueue({
+                    type: "finish",
+                    finishReason: { unified: "stop", raw: "stop" },
+                    usage: emptyUsage
+                  });
+                }
+              } catch {
+              }
+            }
+          }
+        } catch (err) {
+          controller.error(err);
+        }
+      },
+      cancel() {
+        reader.cancel();
+      }
+    });
+    return { stream, request: { body: JSON.stringify(body) } };
+  }
+};
+function createSandAgentDaemon(settings) {
+  const createModel = (modelId, overrides = {}) => {
+    return new DaemonLanguageModel(modelId, { ...settings, ...overrides });
   };
-  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)"})`
-  );
+  const provider = (modelId, overrides) => createModel(modelId, overrides);
+  provider.languageModel = createModel;
+  provider.chat = createModel;
+  provider.specificationVersion = "v3";
+  provider.embeddingModel = () => {
+    throw new Error("not supported");
+  };
+  provider.textEmbeddingModel = () => {
+    throw new Error("not supported");
+  };
+  provider.imageModel = () => {
+    throw new Error("not supported");
+  };
+  return provider;
 }
 
 // src/index.ts
-import { LocalSandbox } from "@sandagent/manager";
-import { buildRunnerEnv } from "@sandagent/manager";
 var VERSION = "0.1.0";
 export {
   LocalSandbox,
@@ -684,6 +835,7 @@ export {
   VERSION,
   buildRunnerEnv,
   createSandAgent,
+  createSandAgentDaemon,
   submitAnswer
 };
 //# sourceMappingURL=index.js.map