AI Agents

import { Tenzro } from '@tenzro/cloud';

const client = new Tenzro({ apiKey: 'your-api-key' });

// Create an agent
const agent = await client.agents.create({
  projectId: 'project-id',
  agentName: 'customer-support',
  agentDescription: 'AI customer support agent',
  aiModel: 'gemini-2.5-flash',
  systemPrompt: `You are a helpful customer support agent.
  Be polite, concise, and helpful in resolving customer issues.`,
  orchestrationPattern: 'SINGLE',
});

// Activate the agent
await client.agents.activate(agent.agent_id);

// Chat with the agent
const response = await client.agents.chat(agent.agent_id, {
  message: 'I need help with my order',
  conversationId: 'conv-123',  // Optional: for conversation continuity
});

console.log(response.response);  // Agent's response
console.log(response.toolCalls); // Any tools the agent used

const agent = await client.agents.create({
  projectId: string,
  agentName: string,
  agentDescription?: string,
  aiProvider?: 'google' | 'openai' | 'anthropic',  // Default: 'google'
  aiModel?: string,      // Default: 'gemini-2.5-flash'
  systemPrompt?: string,
  orchestrationPattern?: 'SINGLE' | 'SEQUENTIAL' | 'PARALLEL' | 'HIERARCHICAL',
  mcpServerIds?: string[],   // Connected MCP servers
  subagentIds?: string[],    // Sub-agents for orchestration
  customTools?: Tool[],      // Custom tool definitions
});

const response = await client.agents.chat(agentId, {
  message: string,           // User message
  conversationId?: string,   // For conversation continuity
  context?: Record<string, any>,  // Additional context
});

// Response type:
interface ChatResponse {
  success: boolean;
  response: string;          // Agent's text response
  conversationId: string;    // Use for follow-up messages
  executionId: string;
  usage: {
    inputTokens: number;
    outputTokens: number;
    thinkingTokens: number;
    totalTokens: number;
  };
  toolCalls?: ToolCall[];
  latencyMs: number;
}

const response = await client.agents.query(agentId, {
  query: string,
  context?: Record<string, any>,
});

// Response includes structured data if available
interface QueryResponse {
  success: boolean;
  result: string;
  data?: any;  // Structured output if agent returns JSON
  executionId: string;
  toolCalls?: ToolCall[];
  usage: TokenUsage;
  latencyMs: number;
}

const execution = await client.agents.execute(agentId, {
  message: string,
  context?: Record<string, any>,
  conversationId?: string,
  messageHistory?: Message[],  // Provide custom history
  stream?: boolean,            // Enable streaming
});

// Activate agent (make it executable)
await client.agents.activate(agentId);

// Pause agent (disable execution)
await client.agents.pause(agentId);

// Update agent configuration
await client.agents.update(agentId, {
  systemPrompt: 'Updated system prompt',
  aiModel: 'gemini-2.5-pro',
});

// Delete agent
await client.agents.delete(agentId);

const { tools, customToolCount, mcpToolCount, mcpServers } =
  await client.agents.getTools(agentId);

// tools: Array of available tools with schemas

// Get all executions
const { executions } = await client.agents.getExecutions(agentId, {
  limit: 50,
  offset: 0,
});

// Get specific execution details
const execution = await client.agents.getExecution(agentId, executionId);

import { Tenzro, tool } from '@tenzro/cloud';

const client = new Tenzro({ apiKey: 'your-api-key' });

// Define tools using the helper
const checkInventory = tool({
  name: 'check_inventory',
  description: 'Check product inventory levels',
  parameters: {
    productId: { type: 'string', description: 'Product ID to check' },
  },
});

const createOrder = tool({
  name: 'create_order',
  description: 'Create a new order for a customer',
  parameters: {
    customerId: { type: 'string' },
    products: {
      type: 'array',
      items: {
        type: 'object',
        properties: {
          productId: { type: 'string' },
          quantity: { type: 'number' },
        },
      },
    },
  },
});

const agent = await client.agents.create({
  projectId: 'project-id',
  agentName: 'sales-agent',
  aiModel: 'gemini-2.5-flash',
  customTools: [checkInventory, createOrder],
});

// Create specialist agents
const researchAgent = await client.agents.create({
  projectId: 'project-id',
  agentName: 'researcher',
  systemPrompt: 'You are a research specialist. Find relevant information.',
  orchestrationPattern: 'SINGLE',
});

const writerAgent = await client.agents.create({
  projectId: 'project-id',
  agentName: 'writer',
  systemPrompt: 'You are a content writer. Create engaging content.',
  orchestrationPattern: 'SINGLE',
});

// Create manager agent with sub-agents
const managerAgent = await client.agents.create({
  projectId: 'project-id',
  agentName: 'content-manager',
  systemPrompt: `You are a content manager. Delegate research to the researcher
  and writing to the writer. Coordinate their work to produce final content.`,
  orchestrationPattern: 'HIERARCHICAL',
  subagentIds: [researchAgent.agent_id, writerAgent.agent_id],
});

await client.agents.activate(managerAgent.agent_id);

// The manager will automatically delegate to sub-agents
const result = await client.agents.chat(managerAgent.agent_id, {
  message: 'Write a blog post about AI trends in 2025',
});

// First, deploy an MCP server
const server = await client.server.create({
  projectId: 'project-id',
  deploymentName: 'database-tools',
  aiModel: 'gemini-2.5-flash',
  dataSourceType: 'data',
  dataSourceId: 'your-database-id',
});

// Connect to the agent
await client.agents.update(agentId, {
  mcpServerIds: [server.deployment_id],
});

// Now the agent can use database tools
const response = await client.agents.chat(agentId, {
  message: 'How many users signed up last week?',
});
// Agent will query the database via MCP server