Utility Functions

import { tool } from 'ai';
import { z } from 'zod';
import { toState } from '@deepagents/agent';

interface AppContext {
  userId: string;
  preferences: Record<string, string>;
}

const saveTool = tool({
  description: 'Save user preference',
  parameters: z.object({
    key: z.string(),
    value: z.string(),
  }),
  execute: async ({ key, value }, options) => {
    // Access context
    const ctx = toState<AppContext>(options);
    
    console.log('User:', ctx.userId);
    
    // Mutate context (changes persist)
    ctx.preferences[key] = value;
    
    return `Saved ${key}=${value}`;
  },
});

import { openai } from '@ai-sdk/openai';
import { agent, generate, execute, toOutput } from '@deepagents/agent';
import { z } from 'zod';

const dataSchema = z.object({
  temperature: z.number(),
  unit: z.string(),
});

const extractor = agent({
  name: 'extractor',
  model: openai('gpt-4o'),
  prompt: 'Extract temperature data.',
  output: dataSchema,
});

// With generate()
const result1 = await generate(extractor, 'It is 72 degrees', {});
const output1 = result1.output; // Direct access

// With execute() and toOutput()
const result2 = await execute(extractor, 'Temperature: 20C', {});
const output2 = await toOutput(result2);
console.log(output2); // { temperature: 20, unit: 'C' }

// Or inline
const output3 = await toOutput(generate(extractor, '98.6F', {}));
console.log(output3); // { temperature: 98.6, unit: 'F' }

import { agent, execute, user } from '@deepagents/agent';
import { openai } from '@ai-sdk/openai';

const assistant = agent({
  name: 'assistant',
  model: openai('gpt-4o'),
  prompt: 'You are helpful.',
});

// Single message
const stream1 = await execute(assistant, user('Hello!'), {});

// Multiple messages (conversation)
const messages = [
  user('What is TypeScript?'),
  // ... assistant response would go here
  user('Can you give me an example?'),
];

const stream2 = await execute(assistant, messages, {});

// String shorthand (automatically converted to user message)
const stream3 = await execute(assistant, 'Hello!', {});

import { agent, execute, last } from '@deepagents/agent';
import { openai } from '@ai-sdk/openai';

const assistant = agent({
  name: 'assistant',
  model: openai('gpt-4o'),
  prompt: 'You are helpful.',
});

const stream = await execute(assistant, 'Count to 5', {});

// Get last event from stream
const lastEvent = await last(stream.fullStream);
console.log('Last event:', lastEvent);

// Get second-to-last
const secondLast = await last(stream.fullStream, -2);

import { agent, execute, finished } from '@deepagents/agent';

const stream = await execute(assistant, 'Process this', {});

// Consume stream without processing
await finished(stream.fullStream);

console.log('Stream finished');

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

const userMessage = await input('Type your question');
console.log('You asked:', userMessage);

// With default value
const name = await input('John');
console.log('Name:', name);

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

const shouldContinue = await confirm('Continue?');
if (shouldContinue) {
  console.log('Continuing...');
} else {
  console.log('Cancelled');
}

// With default as false
const shouldDelete = await confirm('Delete all files?', false);
if (shouldDelete) {
  console.log('Deleting...');
}

import { agent, execute, printer } from '@deepagents/agent';
import { openai } from '@ai-sdk/openai';

const assistant = agent({
  name: 'assistant',
  model: openai('gpt-4o'),
  prompt: 'You are helpful.',
});

const stream = await execute(assistant, 'Tell me a story', {});

// Print with formatting
await printer.stdout(stream, {
  reasoning: false,  // Don't show reasoning
  text: true,        // Show text
  wrapInTags: false, // No XML tags
});

// Usage is also available
const usage = await stream.totalUsage;
console.log('\nTokens used:', usage.totalTokens);

import { openai } from '@ai-sdk/openai';
import { 
  agent, 
  execute, 
  generate,
  toState, 
  toOutput, 
  user,
  input,
  confirm,
  printer 
} from '@deepagents/agent';
import { tool } from 'ai';
import { z } from 'zod';

// Context interface
interface AppContext {
  userId: string;
  savedData: string[];
}

// Tool using toState()
const saveTool = tool({
  description: 'Save data',
  parameters: z.object({
    data: z.string(),
  }),
  execute: async ({ data }, options) => {
    const ctx = toState<AppContext>(options);
    ctx.savedData.push(data);
    return `Saved: ${data}`;
  },
});

// Agent with structured output
const analyzer = agent({
  name: 'analyzer',
  model: openai('gpt-4o'),
  prompt: 'Analyze and save data.',
  tools: { save: saveTool },
  output: z.object({
    analysis: z.string(),
    itemCount: z.number(),
  }),
});

// Interactive CLI workflow
async function main() {
  // Get user input
  const userInput = await input('Enter data to analyze');
  
  // Confirm action
  const proceed = await confirm('Proceed with analysis?');
  if (!proceed) {
    console.log('Cancelled');
    return;
  }
  
  // Prepare context
  const context: AppContext = {
    userId: 'user123',
    savedData: [],
  };
  
  // Execute with streaming
  const stream = await execute(analyzer, user(userInput), context);
  
  // Print to stdout
  await printer.stdout(stream);
  
  // Get structured output
  const output = await toOutput(stream);
  console.log('\nAnalysis:', output.analysis);
  console.log('Item count:', output.itemCount);
  console.log('Saved data:', context.savedData);
  
  // Check usage
  const usage = await stream.totalUsage;
  console.log('\nTokens used:', usage.totalTokens);
}

main();

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

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

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

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

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

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

import { memoryTools } from '@deepagents/agent';
import { agent } from '@deepagents/agent';
import { openai } from '@ai-sdk/openai';

const assistant = agent({
  name: 'assistant',
  model: openai('gpt-4o'),
  prompt: 'You are a helpful assistant with persistent memory.',
  tools: memoryTools,
});

import { agent, execute, memoryTools } from '@deepagents/agent';
import { openai } from '@ai-sdk/openai';

const assistant = agent({
  name: 'assistant',
  model: openai('gpt-4o'),
  prompt: `You are a helpful assistant with memory.
    - Use memoryLookup to recall past conversations
    - Use memoryWrite to save important information
    - Use memoryCorrect to fix inaccurate memories`,
  tools: memoryTools,
});

// First conversation
const stream1 = await execute(
  assistant,
  'My favorite color is blue and I live in Tokyo.',
  {}
);

for await (const chunk of stream1.textStream) {
  process.stdout.write(chunk);
}

// Later conversation - agent can recall
const stream2 = await execute(
  assistant,
  'What is my favorite color and where do I live?',
  {}
);

for await (const chunk of stream2.textStream) {
  process.stdout.write(chunk);
}
// Output: "Your favorite color is blue and you live in Tokyo."