Agent Wrapper

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

// Simplest: just-bash virtual sandbox (no Docker needed)
const sandbox = await createBashTool();

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

// Docker with skills: pick the backend, then layer the bash tool.
const backend = await createDockerSandbox({
  installers: [pkg(['curl', 'jq'])],
});
const sandbox = await createBashTool({
  sandbox: backend,
  skills: [{ host: './skills', sandbox: '/workspace/skills' }],
});
// 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_DEFAULT_DESTINATION,
  createBashTool,
  createDaytonaSandbox,
} from '@deepagents/context';

// Daytona reads DAYTONA_* env vars; mkdir the workspace before wiring the bash tool.
const backend = await createDaytonaSandbox();
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 {
  agent,
  ContextEngine,
  SqliteContextStore,
  createBashTool,
  role,
} from '@deepagents/context';
import { groq } from '@ai-sdk/groq';

const sandbox = await createBashTool();
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 { structuredOutput, ContextEngine, SqliteContextStore, role, user } from '@deepagents/context';
import { groq } from '@ai-sdk/groq';
import z from 'zod';

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()