Agent Wrapper

import { InMemoryFs } from 'just-bash';

import { createBashTool, createVirtualSandbox } from '@deepagents/context';

// Simplest: just-bash virtual sandbox (no Docker needed)
const sandbox = await createBashTool({
  sandbox: await createVirtualSandbox({ fs: new InMemoryFs() }),
});

import { createBashTool, createDockerSandbox, pkg } from '@deepagents/context';

// Pick the backend, then layer the bash tool.
const backend = await createDockerSandbox({
  installers: [pkg(['curl', 'jq'])],
});
const sandbox = await createBashTool({ sandbox: backend });
// Don't forget: await sandbox.sandbox.dispose() when done

import { bin, createBashTool, createDockerSandbox } from '@deepagents/context';

const backend = await createDockerSandbox({
  image: 'node:lts-alpine',
  installers: [bin('/workspace/packages/text2sql/dist/bin/sql.js')],
  volumes: [
    {
      type: 'bind',
      hostPath: process.cwd(),
      containerPath: '/workspace',
      readOnly: true,
    },
  ],
});
const sandbox = await createBashTool({ sandbox: backend });

// `sql` is now on PATH inside the container.
await sandbox.sandbox.executeCommand('sql --help');

bin('/opt/tools/cli.mjs', { name: 'tool' });
bin('/opt/tools/cli.mjs', { target: '/opt/bin/tool' });

import { Daytona } from '@daytona/sdk';

import {
  DAYTONA_DEFAULT_DESTINATION,
  createBashTool,
  createDaytonaSandbox,
} from '@deepagents/context';

const client = new Daytona({
  apiKey: process.env.DAYTONA_API_KEY!,
});

// Pass a caller-owned Daytona client plus either a stable `name`
// (get-or-create) or `sandboxId` (attach). Authentication, base URL, and
// other Daytona config live on `new Daytona(...)`, not on
// `createDaytonaSandbox(...)`. The sandbox lifecycle stays with that client.
const backend = await createDaytonaSandbox(client, {
  name: 'agent-backend',
  image: 'your-registry/agent-image:latest',
});
await backend.executeCommand(`mkdir -p ${DAYTONA_DEFAULT_DESTINATION}`);
const sandbox = await createBashTool({
  sandbox: backend,
  destination: DAYTONA_DEFAULT_DESTINATION,
});
// Don't forget: await sandbox.sandbox.dispose() when done

import { tool } from 'ai';
import { z } from 'zod';

import { agent } from '@deepagents/context';

const inspect = tool({
  description: 'Inspect a resource',
  inputSchema: z.object({ id: z.string() }),
  execute: async ({ id }) => ({
    status: 'ready',
    meta: {
      requestId: `request-${id}`,
      durationMs: 18,
    },
  }),
});

const assistant = agent({
  name: 'inspector',
  sandbox,
  context,
  model,
  tools: { inspect },
});

import { groq } from '@ai-sdk/groq';
import { InMemoryFs } from 'just-bash';

import {
  ContextEngine,
  SqliteContextStore,
  agent,
  createBashTool,
  createVirtualSandbox,
  role,
} from '@deepagents/context';

const sandbox = await createBashTool({
  sandbox: await createVirtualSandbox({ fs: new InMemoryFs() }),
});
const store = new SqliteContextStore('./chat.db');
const context = new ContextEngine({
  store,
  chatId: 'chat-001',
  userId: 'user-001',
}).set(role('You are a helpful coding assistant.'));

const assistant = agent({
  name: 'coding_assistant',
  sandbox,
  context,
  model: groq('gpt-oss-20b'),
});

import { user } from '@deepagents/context';

context.set(user('Explain closures in JavaScript'));
await context.save();

const result = await assistant.generate({});
console.log(result.text);

context.set(user('Write a Python quicksort'));
await context.save();

const stream = await assistant.stream({});

for await (const part of stream.toUIMessageStream()) {
  if (part.type === 'text-delta') {
    process.stdout.write(part.delta);
  }
}

const creativeAssistant = assistant.clone({
  name: 'creative_assistant',
  providerOptions: { temperature: 0.9 },
});

const result = await creativeAssistant.generate({});

const researcher = agent({
  name: 'researcher',
  sandbox,
  context,
  model: groq('gpt-oss-20b'),
});

const writer = agent({
  name: 'writer',
  sandbox,
  context,
  model: groq('gpt-oss-20b'),
  tools: {
    research: researcher.asTool({
      toolDescription: 'Research the topic and return a concise brief',
      outputExtractor: async (result) => result.text,
    }),
  },
});

const reviewer = agent({
  name: 'reviewer',
  sandbox,
  context,
  model: groq('gpt-oss-20b'),
});

const { tool: advisor, usage } = reviewer.asAdvisor({
  concise: true,
  maxConversationUses: 2,
});

const worker = agent({
  name: 'worker',
  sandbox,
  context,
  model: groq('gpt-oss-20b'),
  tools: { advisor },
});

console.log(usage());

import { agent, errorRecoveryGuardrail } from '@deepagents/context';

const guarded = agent({
  name: 'guarded_assistant',
  sandbox,
  context,
  model: groq('gpt-oss-20b'),
  guardrails: [errorRecoveryGuardrail],
  maxGuardrailRetries: 3,
});

import { groq } from '@ai-sdk/groq';
import z from 'zod';

import {
  ContextEngine,
  SqliteContextStore,
  role,
  structuredOutput,
  user,
} from '@deepagents/context';

const store = new SqliteContextStore('./chat.db');
const context = new ContextEngine({
  store,
  chatId: 'extract-001',
  userId: 'user-001',
}).set(role('Extract structured data from the user message.'));

const PersonSchema = z.object({
  name: z.string(),
  age: z.number(),
  occupation: z.string(),
});

const extractor = structuredOutput({
  context,
  model: groq('gpt-oss-20b'),
  schema: PersonSchema,
});

context.set(user('John is a 30-year-old software engineer.'));
await context.save();

const person = await extractor.generate({});
// { name: "John", age: 30, occupation: "software engineer" }

const stream = await extractor.stream({});

for await (const part of stream.toUIMessageStream()) {
  if (part.type === 'text-delta') {
    process.stdout.write(part.delta);
  }
}

agent.generate() / agent.stream()
  └─ context.resolve({ renderer: XmlRenderer })
       └─ { systemPrompt, messages }
            └─ generateText() / streamText()