withAgent()

1
withAgent<T>(
2
  options: {
3
    name: string;
4
    version?: number;
5
    associationProperties?: Record<string, any>;
6
  },
7
  fn: () => Promise<T>
8
): Promise<T>

1
import { RespanTelemetry } from '@respan/tracing';
2
3
const respanAi = new RespanTelemetry({
4
    apiKey: process.env.RESPAN_API_KEY,
5
    appName: 'my-app'
6
});
7
8
await respanAi.initialize();
9
10
const result = await respanAi.withAgent(
11
    { 
12
        name: 'research_assistant',
13
        associationProperties: {
14
            'agent_type': 'research',
15
            'model': 'gpt-4'
16
        }
17
    },
18
    async () => {
19
        // Agent logic here
20
        const analysis = await analyzeQuery();
21
        const response = await generateResponse(analysis);
22
        return response;
23
    }
24
);

1
const customerAgent = async (query: string) => {
2
    return await respanAi.withAgent(
3
        { 
4
            name: 'customer_support_agent',
5
            associationProperties: {
6
                'query_type': 'support',
7
                'customer_id': 'cust-123'
8
            }
9
        },
10
        async () => {
11
            // Tool 1: Search knowledge base
12
            const kbResults = await respanAi.withTool(
13
                { name: 'search_knowledge_base' },
14
                async () => {
15
                    return await searchKB(query);
16
                }
17
            );
18
            
19
            // Tool 2: Query CRM
20
            const customerData = await respanAi.withTool(
21
                { name: 'query_crm' },
22
                async () => {
23
                    return await getCRMData('cust-123');
24
                }
25
            );
26
            
27
            // Final response generation
28
            return await generateSupportResponse(kbResults, customerData);
29
        }
30
    );
31
};

1
await respanAi.withWorkflow(
2
    { name: 'multi_agent_system' },
3
    async () => {
4
        // Agent 1: Planning
5
        const plan = await respanAi.withAgent(
6
            { name: 'planner_agent' },
7
            async () => {
8
                return await createPlan();
9
            }
10
        );
11
        
12
        // Agent 2: Execution
13
        const result = await respanAi.withAgent(
14
            { name: 'executor_agent' },
15
            async () => {
16
                return await executePlan(plan);
17
            }
18
        );
19
        
20
        // Agent 3: Verification
21
        const verified = await respanAi.withAgent(
22
            { name: 'verifier_agent' },
23
            async () => {
24
                return await verifyResult(result);
25
            }
26
        );
27
        
28
        return verified;
29
    }
30
);

1
import OpenAI from 'openai';
2
3
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
4
5
await respanAi.withAgent(
6
    { name: 'ai_assistant' },
7
    async () => {
8
        // Tool calls are automatically traced
9
        const completion = await openai.chat.completions.create({
10
            model: 'gpt-4',
11
            messages: [
12
                { role: 'system', content: 'You are a helpful assistant.' },
13
                { role: 'user', content: 'Explain quantum computing.' }
14
            ],
15
        });
16
        
17
        return completion.choices[0].message.content;
18
    }
19
);