background-agents 0.1.1

package/README.md

@@ -0,0 +1,402 @@
+# Coding Agents SDK
+
+A unified TypeScript interface for AI coding agents—Claude, Codex, Gemini, and OpenCode. Commands run in secure [Daytona](https://daytona.io) sandboxes by default, with real-time PTY streaming.
+
+```typescript
+import { Daytona } from "@daytonaio/sdk"
+import { createSession } from "background-agents"
+
+const daytona = new Daytona({ apiKey: process.env.DAYTONA_API_KEY })
+const sandbox = await daytona.create({ envVars: { ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY } })
+const session = await createSession("claude", { sandbox })
+
+for await (const event of session.run("Hello!")) {
+  if (event.type === "token") process.stdout.write(event.text)
+  if (event.type === "end") break
+}
+
+await sandbox.delete()
+```
+
+Same pattern for any provider: create a sandbox, create a session, stream events, then tear down. Swap the provider name and env keys as needed.
+
+---
+
+## Features
+
+- **Secure by default** — Execution runs in isolated Daytona sandboxes
+- **Real-time streaming** — PTY-based streaming for live token output
+- **Unified API** — One interface for [Claude](https://docs.anthropic.com/en/docs/claude-code), [Codex](https://developers.openai.com/codex/cli), [Gemini](https://geminicli.com/docs/), and [OpenCode](https://opencode.ai/docs/)
+- **Zero-friction setup** — Provider CLI is installed when you create a session (`skipInstall: true` to skip). Env and Codex login run on every `run()`.
+- **Session persistence** — Resume conversations across runs
+
+---
+
+## Provider support
+
+| Provider | Status | Auth |
+|----------|--------|------|
+| [Claude](https://docs.anthropic.com/en/docs/claude-code) | ✅ | `ANTHROPIC_API_KEY` |
+| [Codex](https://developers.openai.com/codex/cli) | ✅ | `OPENAI_API_KEY` |
+| [OpenCode](https://opencode.ai/docs/) | ✅ | Provider-specific (e.g. `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `GOOGLE_API_KEY`) |
+| [Gemini](https://geminicli.com/docs/) | 🚧 | `GOOGLE_API_KEY` |
+
+---
+
+## Prerequisites
+
+A [Daytona](https://daytona.io) API key (or [run locally](#local-mode-dangerous) without a sandbox).
+
+```bash
+export DAYTONA_API_KEY=dtn_your_api_key
+```
+
+---
+
+## Installation
+
+```bash
+npm install background-agents
+```
+
+For sandboxed execution, also install the Daytona SDK:
+
+```bash
+npm install @daytonaio/sdk
+```
+
+**Next.js:** Merge the SDK's Next config so native deps (e.g. `ssh2` / `cpu-features`) are not bundled:
+
+```js
+// next.config.js or next.config.mjs
+import codeagentsdk from 'background-agents/next.config'
+export default { ...codeagentsdk, ...yourConfig }
+```
+
+---
+
+## Quick start
+
+**1. Create a sandbox** — Pass provider API keys via the sandbox; the SDK does not read your host env.
+
+```typescript
+import { Daytona } from "@daytonaio/sdk"
+import { createSession } from "background-agents"
+
+const daytona = new Daytona({ apiKey: process.env.DAYTONA_API_KEY })
+const sandbox = await daytona.create({
+  envVars: { ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY },
+})
+```
+
+**2. Create a session** — The provider CLI is installed in the sandbox (unless `skipInstall: true`).
+
+```typescript
+const session = await createSession("claude", {
+  sandbox,
+  model: "sonnet",
+  timeout: 120,
+  systemPrompt: "You are a helpful coding assistant.",
+})
+```
+
+**3. Stream responses**
+
+```typescript
+for await (const event of session.run("Hello!")) {
+  if (event.type === "token") process.stdout.write(event.text)
+  if (event.type === "tool_start") console.log(`\n[Tool: ${event.name}]`)
+  if (event.type === "end") break
+}
+```
+
+**4. Cleanup**
+
+```typescript
+await sandbox.delete()
+```
+
+**Optional: Git workflow** — Use the [Daytona Git SDK](https://www.daytona.io/docs/en/typescript-sdk/git/) to clone before and push after:
+
+```typescript
+const repoPath = "workspace/repo"
+await sandbox.git.clone("https://github.com/user/repo.git", repoPath)
+// ... run session ...
+await sandbox.git.push(repoPath)
+```
+
+---
+
+## Full example
+
+End-to-end example with event handling and cleanup:
+
+```typescript
+import { Daytona } from "@daytonaio/sdk"
+import { createSession } from "background-agents"
+
+async function main() {
+  const daytona = new Daytona({ apiKey: process.env.DAYTONA_API_KEY })
+  const sandbox = await daytona.create({
+    envVars: { ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY },
+  })
+
+  try {
+    const session = await createSession("claude", { sandbox })
+
+    for await (const event of session.run("List /tmp then write /tmp/out.txt with 'done'")) {
+      switch (event.type) {
+        case "token":
+          process.stdout.write(event.text)
+          break
+        case "tool_start":
+          console.log("\n🛠️", event.name, event.input ?? "")
+          break
+        case "end":
+          console.log("\nDone.")
+          break
+      }
+    }
+  } finally {
+    await sandbox.delete()
+  }
+}
+
+main()
+```
+
+### CLI commands (reference)
+
+Each provider is invoked via its CLI. Optional flags in brackets.
+
+| Provider | Command |
+|----------|---------|
+| **Claude** | `claude -p --output-format stream-json --verbose --dangerously-skip-permissions` `[--model <m>] [--resume <id>]` `<prompt>` |
+| **Codex** | `codex exec --json --skip-git-repo-check --yolo` `[--model <m>] [resume <id>]` `<prompt>` |
+| **OpenCode** | `opencode run --format json --variant medium -m <model>` `[-s <id>]` `<prompt>` (via `bash -lc "…"`) |
+| **Gemini** | `gemini -p --output-format stream-json --yolo` `[--model <m>] [--resume <id>]` `<prompt>` |
+
+---
+
+## API reference
+
+### `createSession(provider, options)`
+
+Creates a session with the given provider and options (e.g. `sandbox`, `model`, `timeout`). Installs the provider CLI in the sandbox before returning unless `skipInstall: true`. Codex login runs automatically on each `run()` when needed.
+
+```typescript
+const session = await createSession("claude", {
+  sandbox,
+  model: "sonnet",
+  timeout: 120,
+})
+```
+
+### `session.run(prompt)`
+
+Returns an async iterable of events. Stream and handle them uniformly across providers.
+
+```typescript
+for await (const event of session.run("Hello")) {
+  // event.type: "session" | "token" | "tool_start" | "tool_delta" | "tool_end" | "end" | "agent_crashed"
+}
+```
+
+### Event stream
+
+| Event | Description | Fields |
+|-------|-------------|--------|
+| `session` | Session started (for resumption) | `id: string` |
+| `token` | Streamed assistant text | `text: string` |
+| `tool_start` | Tool invoked | `name: string`, `input?: unknown` |
+| `tool_delta` | Streaming tool input | `text: string` |
+| `tool_end` | Tool finished | `output?: string` |
+| `end` | Turn complete | — |
+| `agent_crashed` | Process exited without completing (crash/kill) | `message?: string`, `output?: string` (raw tail of stdout/stderr; often not JSONL) |
+
+```typescript
+type Event =
+  | { type: "session"; id: string }
+  | { type: "token"; text: string }
+  | { type: "tool_start"; name: string; input?: unknown }
+  | { type: "tool_delta"; text: string }
+  | { type: "tool_end"; output?: string }
+  | { type: "end" }
+  | { type: "agent_crashed"; message?: string; output?: string }
+```
+
+### Normalized tool names
+
+Tool names are normalized across providers. Each has a defined `tool_start` input and `tool_end` output.
+
+| Tool | `tool_start` input | Claude | Codex | OpenCode |
+|------|--------------------|:------:|:-----:|:--------:|
+| **write** | `{ file_path, content?, kind }` | ✅ | ✅ | ✅ |
+| **read** | `{ file_path }` | ✅ | — | ✅ |
+| **edit** | `{ file_path, ... }` | ✅ | — | ✅ |
+| **glob** | `{ pattern }` | ✅ | — | ✅ |
+| **grep** | `{ pattern, path? }` | ✅ | — | ✅ |
+| **shell** | `{ command, description? }` | ✅ | ✅ | ✅ |
+
+---
+
+## Model selection
+
+Set `model` when creating the session.
+
+| Provider | Example | Docs |
+|----------|---------|------|
+| **Claude** | `model: "sonnet"` or `"opus"`, `"haiku"` | [Claude Code models](https://code.claude.com/docs/en/model-config) |
+| **Codex** | `model: "gpt-4o"` or `"o1"`, `"o3"` | [Codex CLI models](https://developers.openai.com/codex/models) |
+| **OpenCode** | `model: "openai/gpt-4o"` (provider/model) | [OpenCode models](https://opencode.ai/docs/models/) |
+| **Gemini** | `model: "gemini-2.0-flash"` or `"gemini-1.5-pro"` | [Gemini CLI model](https://geminicli.com/docs/cli/model) |
+
+---
+
+## Sandboxed background sessions
+
+For long-running or restart-tolerant flows: start the agent in the sandbox, write the event stream to log files there, and poll with **getEvents**. All state except the session ID lives in the sandbox.
+
+- **Session ID** — One UUID per background session; host stores only this.
+- **start()** — Returns immediately with `{ executionId, pid, outputFile }`; the agent runs in the background.
+- **isRunning()** — True while the turn is in progress, false after.
+- **Crash detection** — If the process exits without completing, **getEvents** returns an `agent_crashed` event. You can treat it like `end` to stop polling and show a warning.
+
+**Example:** start, persist `sandboxId` and `backgroundSessionId`, then reattach after a restart.
+
+```typescript
+import { Daytona } from "@daytonaio/sdk"
+import { createBackgroundSession, getBackgroundSession } from "background-agents"
+
+const daytona = new Daytona({ apiKey: process.env.DAYTONA_API_KEY! })
+const sandbox = await daytona.create({
+  envVars: { ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY! },
+})
+
+const bgSession = await createBackgroundSession("claude", {
+  sandbox,
+  model: "sonnet",
+  // Optional: per-session system prompt (applied once, persisted across turns).
+  systemPrompt: "You are a helpful coding assistant.",
+})
+await bgSession.start("Do a long-running refactor...")
+// Persist sandbox.id and bgSession.id, then exit.
+
+// --- After restart ---
+const sandboxAgain = await daytona.get(sandboxId)
+const bgAgain = await getBackgroundSession({
+  sandbox: sandboxAgain,
+  backgroundSessionId,
+  // Re-apply session options so the provider is recreated with the same model
+  // and system prompt when reattaching.
+  model: "sonnet",
+  systemPrompt: "You are a helpful coding assistant.",
+})
+
+async function poll() {
+  const { events } = await bgAgain.getEvents()
+  for (const e of events) {
+    if (e.type === "token") process.stdout.write(e.text)
+    else if (e.type === "tool_start") console.log("[Tool]", e.name)
+  }
+  if (!(await bgAgain.isRunning())) return
+  setTimeout(poll, 2000)
+}
+poll()
+
+await bgAgain.cancel() // kill agent in sandbox (no-op if stopped)
+```
+
+---
+
+## Local mode (dangerous)
+
+Runs the provider CLI on your machine instead of a sandbox. Only use when you fully trust the code.
+
+```typescript
+const session = await createSession("claude", { dangerouslyAllowLocalExecution: true })
+for await (const event of session.run("Hello")) {
+  if (event.type === "token") process.stdout.write(event.text)
+}
+```
+
+---
+
+## Interactive REPL
+
+```bash
+# Claude (default)
+DAYTONA_API_KEY=... ANTHROPIC_API_KEY=... npx tsx scripts/repl.ts
+
+# Other providers
+npx tsx scripts/repl.ts --provider codex   # OPENAI_API_KEY
+npx tsx scripts/repl.ts --provider opencode
+npx tsx scripts/repl.ts --provider gemini  # GEMINI_API_KEY (or GOOGLE_API_KEY)
+
+# Polling-based (background session)
+DAYTONA_API_KEY=... ANTHROPIC_API_KEY=... npx tsx scripts/repl-polling.ts
+```
+
+```bash
+npx tsx scripts/repl.ts -h   # help; providers: claude, codex, opencode, gemini
+```
+
+---
+
+## How it works
+
+1. **Sandbox** — You create a Daytona sandbox and pass it to `createSession`.
+2. **CLI** — Provider CLI is installed in the sandbox at session creation (unless `skipInstall: true`). Each `run()` sets env and, for Codex, runs `codex login --with-api-key`.
+3. **PTY** — Commands run in a PTY for real-time streaming.
+4. **Events** — JSON from the CLI is parsed into typed events.
+5. **Cleanup** — You call `sandbox.delete()` when done.
+
+```
+┌─────────────┐     ┌──────────────────────────────────────┐
+│   Your App  │────▶│          Daytona Sandbox             │
+│             │◀────│  ┌─────────────┐    ┌─────────────┐  │
+│             │     │  │  PTY Stream │◀──▶│  Agent CLI  │  │
+│             │     │  └─────────────┘    └─────────────┘  │
+└─────────────┘     └──────────────────────────────────────┘
+```
+
+---
+
+## Debug mode
+
+Set `CODING_AGENTS_DEBUG=1` (or any non-empty value) to log debugging information to stderr:
+
+- **Agent lifecycle** — when sessions and background sessions are created, when runs start and end
+- **Background agents** — when a turn starts (session dir, turn number, output file), when the background process is started (pid), and each time events are polled (cursor, event count)
+- **Unparsed output** — any CLI line that didn’t parse as an event (helps spot hangs where the agent prints something the SDK doesn’t recognize)
+
+```bash
+CODING_AGENTS_DEBUG=1 npx tsx scripts/repl-polling.ts
+```
+
+---
+
+## Development
+
+```bash
+npm install
+npm run build
+npm test                    # unit tests (integration/sandbox-background skipped without keys)
+DAYTONA_API_KEY=... ANTHROPIC_API_KEY=... npm run test -- tests/integration/sandbox-background.test.ts   # real sandbox background test
+DAYTONA_API_KEY=... ANTHROPIC_API_KEY=... npx tsx scripts/test-sdk-full.ts   # integration
+DAYTONA_API_KEY=... ANTHROPIC_API_KEY=... npx tsx scripts/repl.ts            # REPL
+```
+
+---
+
+## Resources
+
+**Sandbox** — [Daytona Docs](https://www.daytona.io/docs/) · [Daytona GitHub](https://github.com/daytonaio/daytona)
+
+**Agents** — [Claude Code](https://docs.anthropic.com/en/docs/claude-code) · [Codex CLI](https://developers.openai.com/codex/cli) · [Gemini CLI](https://geminicli.com/docs/) · [OpenCode](https://opencode.ai/docs/)
+
+---
+
+## License
+
+MIT

package/dist/debug.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Debug logging for the SDK. Enable with env CODING_AGENTS_DEBUG=1 (or non-empty).
+ * Logs agent lifecycle (start/stop), background runs, and any lines that fail to parse.
+ */
+export declare function isDebugEnabled(): boolean;
+export declare function debugLog(message: string, sessionId?: string | null, ...args: unknown[]): void;
+//# sourceMappingURL=debug.d.ts.map

package/dist/debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../src/debug.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,wBAAgB,cAAc,IAAI,OAAO,CAExC;AAID,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAK7F"}

package/dist/debug.js

@@ -0,0 +1,19 @@
+/**
+ * Debug logging for the SDK. Enable with env CODING_AGENTS_DEBUG=1 (or non-empty).
+ * Logs agent lifecycle (start/stop), background runs, and any lines that fail to parse.
+ */
+const DEBUG_ENABLED = typeof process !== "undefined" &&
+    process.env &&
+    String(process.env.CODING_AGENTS_DEBUG ?? "").trim() !== "";
+export function isDebugEnabled() {
+    return DEBUG_ENABLED;
+}
+const PREFIX = "[background-agents]";
+export function debugLog(message, sessionId, ...args) {
+    if (!DEBUG_ENABLED)
+        return;
+    const sessionTag = sessionId != null && sessionId !== "" ? ` sessionId=${sessionId}` : "";
+    const line = args.length ? `${message} ${args.map(a => (typeof a === "object" ? JSON.stringify(a) : String(a))).join(" ")}` : message;
+    process.stderr.write(`${PREFIX}${sessionTag} ${line}\n`);
+}
+//# sourceMappingURL=debug.js.map

package/dist/debug.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.js","sourceRoot":"","sources":["../src/debug.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,aAAa,GACjB,OAAO,OAAO,KAAK,WAAW;IAC9B,OAAO,CAAC,GAAG;IACX,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,mBAAmB,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,CAAA;AAE7D,MAAM,UAAU,cAAc;IAC5B,OAAO,aAAa,CAAA;AACtB,CAAC;AAED,MAAM,MAAM,GAAG,qBAAqB,CAAA;AAEpC,MAAM,UAAU,QAAQ,CAAC,OAAe,EAAE,SAAyB,EAAE,GAAG,IAAe;IACrF,IAAI,CAAC,aAAa;QAAE,OAAM;IAC1B,MAAM,UAAU,GAAG,SAAS,IAAI,IAAI,IAAI,SAAS,KAAK,EAAE,CAAC,CAAC,CAAC,cAAc,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAA;IACzF,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,OAAO,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAA;IACrI,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,GAAG,UAAU,IAAI,IAAI,IAAI,CAAC,CAAA;AAC1D,CAAC"}

package/dist/factory.d.ts

@@ -0,0 +1,31 @@
+import type { ProviderName, ProviderOptions } from "./types/index.js";
+import { Provider } from "./providers/index.js";
+/**
+ * Create a provider instance by name
+ *
+ * @param name - The provider name ("claude", "codex", "opencode", "gemini")
+ * @param options - Provider options (sandbox or dangerouslyAllowLocalExecution)
+ * @returns A provider instance
+ * @throws Error if the provider name is unknown
+ *
+ * @example
+ * ```typescript
+ * import { Daytona } from "@daytonaio/sdk"
+ * const daytona = new Daytona({ apiKey: process.env.DAYTONA_API_KEY })
+ * const sandbox = await daytona.create({ envVars: { ... } })
+ * const provider = createProvider("claude", { sandbox })
+ *
+ * // Or with dangerous local execution:
+ * const provider = createProvider("claude", { dangerouslyAllowLocalExecution: true })
+ * ```
+ */
+export declare function createProvider(name: ProviderName | string, options: ProviderOptions): Provider;
+/**
+ * Get all available provider names
+ */
+export declare function getProviderNames(): ProviderName[];
+/**
+ * Check if a provider name is valid
+ */
+export declare function isValidProvider(name: string): name is ProviderName;
+//# sourceMappingURL=factory.d.ts.map

package/dist/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACrE,OAAO,EAAE,QAAQ,EAAmE,MAAM,sBAAsB,CAAA;AAEhH;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,QAAQ,CAa9F;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,YAAY,EAAE,CAEjD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,YAAY,CAElE"}

package/dist/factory.js

@@ -0,0 +1,47 @@
+import { ClaudeProvider, CodexProvider, OpenCodeProvider, GeminiProvider } from "./providers/index.js";
+/**
+ * Create a provider instance by name
+ *
+ * @param name - The provider name ("claude", "codex", "opencode", "gemini")
+ * @param options - Provider options (sandbox or dangerouslyAllowLocalExecution)
+ * @returns A provider instance
+ * @throws Error if the provider name is unknown
+ *
+ * @example
+ * ```typescript
+ * import { Daytona } from "@daytonaio/sdk"
+ * const daytona = new Daytona({ apiKey: process.env.DAYTONA_API_KEY })
+ * const sandbox = await daytona.create({ envVars: { ... } })
+ * const provider = createProvider("claude", { sandbox })
+ *
+ * // Or with dangerous local execution:
+ * const provider = createProvider("claude", { dangerouslyAllowLocalExecution: true })
+ * ```
+ */
+export function createProvider(name, options) {
+    switch (name) {
+        case "claude":
+            return new ClaudeProvider(options);
+        case "codex":
+            return new CodexProvider(options);
+        case "opencode":
+            return new OpenCodeProvider(options);
+        case "gemini":
+            return new GeminiProvider(options);
+        default:
+            throw new Error(`Unknown provider: ${name}. Valid providers are: claude, codex, opencode, gemini`);
+    }
+}
+/**
+ * Get all available provider names
+ */
+export function getProviderNames() {
+    return ["claude", "codex", "opencode", "gemini"];
+}
+/**
+ * Check if a provider name is valid
+ */
+export function isValidProvider(name) {
+    return getProviderNames().includes(name);
+}
+//# sourceMappingURL=factory.js.map

package/dist/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.js","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,cAAc,EAAE,aAAa,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAEhH;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,cAAc,CAAC,IAA2B,EAAE,OAAwB;IAClF,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,QAAQ;YACX,OAAO,IAAI,cAAc,CAAC,OAAO,CAAC,CAAA;QACpC,KAAK,OAAO;YACV,OAAO,IAAI,aAAa,CAAC,OAAO,CAAC,CAAA;QACnC,KAAK,UAAU;YACb,OAAO,IAAI,gBAAgB,CAAC,OAAO,CAAC,CAAA;QACtC,KAAK,QAAQ;YACX,OAAO,IAAI,cAAc,CAAC,OAAO,CAAC,CAAA;QACpC;YACE,MAAM,IAAI,KAAK,CAAC,qBAAqB,IAAI,wDAAwD,CAAC,CAAA;IACtG,CAAC;AACH,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,gBAAgB;IAC9B,OAAO,CAAC,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAA;AAClD,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,OAAO,gBAAgB,EAAE,CAAC,QAAQ,CAAC,IAAoB,CAAC,CAAA;AAC1D,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Coding Agents SDK
+ *
+ * A TypeScript SDK for interacting with various AI coding agents.
+ * Create a sandbox with @daytonaio/sdk and pass it to createSession.
+ *
+ * @example
+ * ```typescript
+ * import { Daytona } from "@daytonaio/sdk"
+ * import { createSession } from "background-agents"
+ *
+ * const daytona = new Daytona({ apiKey: process.env.DAYTONA_API_KEY })
+ * const sandbox = await daytona.create({ envVars: { ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY } })
+ * const session = await createSession("claude", { sandbox })
+ *
+ * for await (const event of session.run("Hello")) {
+ *   if (event.type === "token") process.stdout.write(event.text)
+ * }
+ *
+ * await sandbox.delete()
+ * ```
+ */
+export type { Event, SessionEvent, TokenEvent, ToolStartEvent, ToolDeltaEvent, ToolEndEvent, EndEvent, EventType, ToolName, WriteToolInput, ReadToolInput, EditToolInput, GlobToolInput, GrepToolInput, ShellToolInput, ToolInputMap, ProviderName, ProviderCommand, RunOptions, RunDefaults, ProviderOptions, EventHandler, IProvider, CodeAgentSandbox, ExecuteBackgroundOptions, AdaptSandboxOptions, } from "./types/index.js";
+export { adaptDaytonaSandbox } from "./sandbox/index.js";
+export { Provider, ClaudeProvider, CodexProvider, OpenCodeProvider, GeminiProvider, } from "./providers/index.js";
+export { createProvider, getProviderNames, isValidProvider, } from "./factory.js";
+export { createSession, type SessionOptions, createBackgroundSession, getBackgroundSession, type BackgroundSessionOptions, type BackgroundSession, } from "./session.js";
+export { safeJsonParse, loadSession, storeSession, clearSession, getDefaultSessionPath, isCliInstalled, installProvider, ensureCliInstalled, getPackageName, getInstallationStatus, } from "./utils/index.js";
+export { isDebugEnabled, debugLog } from "./debug.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH,YAAY,EACV,KAAK,EACL,YAAY,EACZ,UAAU,EACV,cAAc,EACd,cAAc,EACd,YAAY,EACZ,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,cAAc,EACd,aAAa,EACb,aAAa,EACb,aAAa,EACb,aAAa,EACb,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,UAAU,EACV,WAAW,EACX,eAAe,EACf,YAAY,EACZ,SAAS,EACT,gBAAgB,EAChB,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAGxD,OAAO,EACL,QAAQ,EACR,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,cAAc,GACf,MAAM,sBAAsB,CAAA;AAG7B,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,eAAe,GAChB,MAAM,cAAc,CAAA;AAGrB,OAAO,EACL,aAAa,EACb,KAAK,cAAc,EACnB,uBAAuB,EACvB,oBAAoB,EACpB,KAAK,wBAAwB,EAC7B,KAAK,iBAAiB,GACvB,MAAM,cAAc,CAAA;AAGrB,OAAO,EACL,aAAa,EACb,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,qBAAqB,EACrB,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,qBAAqB,GACtB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA"}

package/dist/index.js

@@ -0,0 +1,35 @@
+/**
+ * Coding Agents SDK
+ *
+ * A TypeScript SDK for interacting with various AI coding agents.
+ * Create a sandbox with @daytonaio/sdk and pass it to createSession.
+ *
+ * @example
+ * ```typescript
+ * import { Daytona } from "@daytonaio/sdk"
+ * import { createSession } from "background-agents"
+ *
+ * const daytona = new Daytona({ apiKey: process.env.DAYTONA_API_KEY })
+ * const sandbox = await daytona.create({ envVars: { ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY } })
+ * const session = await createSession("claude", { sandbox })
+ *
+ * for await (const event of session.run("Hello")) {
+ *   if (event.type === "token") process.stdout.write(event.text)
+ * }
+ *
+ * await sandbox.delete()
+ * ```
+ */
+// Sandbox adapter (wrap a Daytona sandbox from @daytonaio/sdk; uses SSH for background start when createSshAccess exists)
+export { adaptDaytonaSandbox } from "./sandbox/index.js";
+// Providers
+export { Provider, ClaudeProvider, CodexProvider, OpenCodeProvider, GeminiProvider, } from "./providers/index.js";
+// Factory
+export { createProvider, getProviderNames, isValidProvider, } from "./factory.js";
+// Session (provider with run defaults; recommended entry points)
+export { createSession, createBackgroundSession, getBackgroundSession, } from "./session.js";
+// Utilities
+export { safeJsonParse, loadSession, storeSession, clearSession, getDefaultSessionPath, isCliInstalled, installProvider, ensureCliInstalled, getPackageName, getInstallationStatus, } from "./utils/index.js";
+// Debug (enable with CODING_AGENTS_DEBUG=1)
+export { isDebugEnabled, debugLog } from "./debug.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAgCH,0HAA0H;AAC1H,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAExD,YAAY;AACZ,OAAO,EACL,QAAQ,EACR,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,cAAc,GACf,MAAM,sBAAsB,CAAA;AAE7B,UAAU;AACV,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,eAAe,GAChB,MAAM,cAAc,CAAA;AAErB,iEAAiE;AACjE,OAAO,EACL,aAAa,EAEb,uBAAuB,EACvB,oBAAoB,GAGrB,MAAM,cAAc,CAAA;AAErB,YAAY;AACZ,OAAO,EACL,aAAa,EACb,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,qBAAqB,EACrB,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,qBAAqB,GACtB,MAAM,kBAAkB,CAAA;AAEzB,4CAA4C;AAC5C,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA"}