User Context Fragments

function identity(input: {
  name?: string;
  role?: string;
}): ContextFragment

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

// Full identity
identity({ name: 'John', role: 'VP of Sales' });

// Role only
identity({ role: 'Data analyst in the marketing team' });

// Name only
identity({ name: 'Sarah' });

// Detailed role
identity({ role: 'Finance manager focused on cost optimization' });

import { XmlRenderer, identity, term } from '@deepagents/context';

const fragments = [
  identity({ name: 'Alex', role: 'Sales Manager' }),
  term('ARR', 'Annual Recurring Revenue'),
  term('CAC', 'Customer Acquisition Cost'),
];

const renderer = new XmlRenderer();
console.log(renderer.render(fragments));

<identity>
  <name>Alex</name>
  <role>Sales Manager</role>
</identity>
<term>
  <name>ARR</name>
  <definition>Annual Recurring Revenue</definition>
</term>
<term>
  <name>CAC</name>
  <definition>Customer Acquisition Cost</definition>
</term>

function persona(input: {
  name: string;
  role?: string;
  objective?: string;
  tone?: string;
}): ContextFragment

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

// Basic persona
persona({
  name: 'DataBot',
  role: 'SQL Expert',
});

// With objective
persona({
  name: 'QueryMaster',
  role: 'Database Analyst',
  objective: 'Generate accurate SQL queries from natural language',
});

// Full persona with tone
persona({
  name: 'Freya',
  role: 'Data Assistant',
  objective: 'Help users explore and understand their data',
  tone: 'friendly and professional',
});

import { XmlRenderer, persona, identity } from '@deepagents/context';

const fragments = [
  identity({ name: 'Sarah', role: 'Product Manager' }),
  persona({
    name: 'AnalyticsAI',
    role: 'Product Analytics Assistant',
    objective: 'Provide insights on user behavior and product metrics',
    tone: 'concise and data-driven',
  }),
];

const renderer = new XmlRenderer();
console.log(renderer.render(fragments));

<identity>
  <name>Sarah</name>
  <role>Product Manager</role>
</identity>
<persona>
  <name>AnalyticsAI</name>
  <role>Product Analytics Assistant</role>
  <objective>Provide insights on user behavior and product metrics</objective>
  <tone>concise and data-driven</tone>
</persona>

function alias(term: string, meaning: string): ContextFragment

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

// Disambiguate terms
alias('revenue', 'gross revenue before deductions, not net');

// Map user language to data
alias('active users', 'users who logged in within the last 30 days');

// Table nicknames
alias('the big table', 'the orders table');

// Fiscal periods
alias('Q4', 'October through December, not fiscal Q4');

import { alias, term } from '@deepagents/context';

const fragments = [
  // Standard domain term
  term('MRR', 'Monthly Recurring Revenue'),
  
  // User's personal interpretation
  alias('revenue', 'MRR excluding one-time fees'),
  
  // User's table nickname
  alias('customer data', 'the customers_v2 view'),
];

function preference(aspect: string, value: string): ContextFragment

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

// Date formatting
preference('date format', 'YYYY-MM-DD');

// Output style
preference('output style', 'tables over charts unless showing trends');

// Verbosity
preference('detail level', 'always show the SQL query in responses');

// Default limits
preference('row limit', 'default to 50 rows unless I ask for more');

// Explanation style
preference('explanation style', 'brief and to the point');

import { XmlRenderer, preference, identity } from '@deepagents/context';

const fragments = [
  identity({ name: 'Jordan', role: 'Data Engineer' }),
  preference('output format', 'always include SQL with results'),
  preference('date format', 'ISO 8601 (YYYY-MM-DD)'),
  preference('timezone', 'UTC for all timestamps'),
  preference('decimal precision', '2 places for currency, 4 for percentages'),
];

const renderer = new XmlRenderer({ groupFragments: true });
console.log(renderer.render(fragments));

<identity>
  <name>Jordan</name>
  <role>Data Engineer</role>
</identity>
<preferences>
  <preference>
    <aspect>output format</aspect>
    <value>always include SQL with results</value>
  </preference>
  <preference>
    <aspect>date format</aspect>
    <value>ISO 8601 (YYYY-MM-DD)</value>
  </preference>
  <preference>
    <aspect>timezone</aspect>
    <value>UTC for all timestamps</value>
  </preference>
  <preference>
    <aspect>decimal precision</aspect>
    <value>2 places for currency, 4 for percentages</value>
  </preference>
</preferences>

function userContext(description: string): ContextFragment

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

// Current project
userContext('Preparing Q4 board presentation');

// Investigation
userContext('Investigating drop in signups last week');

// Regional focus
userContext('Working on EMEA regional analysis for strategy meeting');

// Debugging
userContext('Debugging discrepancy in revenue numbers');

import { userContext, preference } from '@deepagents/context';

const fragments = [
  userContext('Preparing monthly executive dashboard for CEO'),
  preference('aggregation', 'monthly summaries, not daily details'),
  preference('focus metrics', 'revenue, user growth, and churn'),
];

function correction(
  subject: string,
  clarification: string
): ContextFragment

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

// Data type correction
correction(
  'status column',
  '1 = active, 0 = inactive, not boolean true/false'
);

// Table correction
correction(
  'orders table',
  'Use orders_v2, not the deprecated legacy_orders table'
);

// Field meaning correction
correction(
  'date field',
  'order_date is when order was placed, ship_date is when shipped'
);

// Calculation correction
correction(
  'revenue calculation',
  'Must exclude refunds and chargebacks'
);

import { XmlRenderer, correction, userContext } from '@deepagents/context';

const fragments = [
  userContext('Analyzing user retention metrics'),
  correction(
    'active users',
    'Active = logged in within 30 days, not just signed up'
  ),
  correction(
    'retention calculation',
    'Compare cohorts month-over-month, not cumulative'
  ),
];

const renderer = new XmlRenderer({ groupFragments: true });
console.log(renderer.render(fragments));

<userContext>Analyzing user retention metrics</userContext>
<corrections>
  <correction>
    <subject>active users</subject>
    <clarification>Active = logged in within 30 days, not just signed up</clarification>
  </correction>
  <correction>
    <subject>retention calculation</subject>
    <clarification>Compare cohorts month-over-month, not cumulative</clarification>
  </correction>
</corrections>

import {
  identity,
  persona,
  preference,
  userContext,
  alias,
  correction,
} from '@deepagents/context';

const userProfile = [
  // Who is the user?
  identity({
    name: 'Morgan',
    role: 'Head of Revenue Operations',
  }),
  
  // What are they working on?
  userContext('Building automated revenue forecasting model'),
  
  // How do they prefer results?
  preference('date format', 'YYYY-MM-DD'),
  preference('output', 'always show confidence intervals'),
  preference('aggregation', 'weekly rolling averages'),
  
  // Their vocabulary
  alias('bookings', 'closed-won deals with signed contracts'),
  alias('pipeline', 'opportunities in stages 3-6'),
  
  // Past corrections
  correction(
    'revenue recognition',
    'Use booking_date, not payment_date for revenue timing'
  ),
];