Tâche

Exécution structurée des tâches avec suivi du statut et intégration d'outils Découvrez les schémas de configuration, les API et les exemples pratiques...

Exécution structurée des tâches avec suivi du statut et intégration d'outils

Vue d'ensemble

Les Tasks offrent un moyen d'organiser et d'exécuter des opérations complexes avec vos agents. Elles prennent en charge le suivi du statut, l'utilisation d'outils, et peuvent être composées en workflows plus larges. Chaque tâche peut avoir des dépendances, exécuter des actions spécifiques, et maintenir son propre état tout au long de son exécution.

Créer des tâches

Les tâches sont créées via les agents en utilisant une approche simple basée sur des invites :

import { Agent } from '@astreus-ai/astreus';

const agent = await Agent.create({
  name: 'TaskAgent',
  model: 'gpt-4o'
});

// Create a task
const task = await agent.createTask({
  prompt: 'Analyze the TypeScript code and suggest performance improvements'
});

// Execute the task
const result = await agent.executeTask(task.id);
console.log(result.response);

Attributs des tâches

Les tâches peuvent être configurées avec les attributs suivants :

interface TaskRequest {
  prompt: string;              // The task instruction or query
  graphId?: string;            // UUID - Graph this task belongs to
  graphNodeId?: string;        // UUID - Graph node creating this task
  useTools?: boolean;          // Enable/disable tool usage (default: true)
  mcpServers?: MCPServerDefinition[]; // Task-level MCP servers
  plugins?: Array<{            // Task-level plugins
    plugin: Plugin;
    config?: PluginConfig;
  }>;
  attachments?: Array<{        // Files to attach to the task
    type: 'image' | 'pdf' | 'text' | 'markdown' | 'code' | 'json' | 'file';
    path: string;              // File path
    name?: string;             // Display name
    language?: string;         // Programming language (for code files)
  }>;
  schedule?: string;           // Simple schedule string (e.g., 'daily@07:00', 'weekly@monday@09:00')
  metadata?: MetadataObject;   // Custom metadata for tracking
  executionContext?: Record<string, unknown>; // Additional execution metadata
  useSubAgents?: boolean;                        // Enable sub-agent delegation for this task
  subAgentDelegation?: 'auto' | 'manual' | 'sequential'; // Delegation strategy
  subAgentCoordination?: 'parallel' | 'sequential';      // How sub-agents coordinate
  taskAssignment?: Record<string, string>;               // Manual task assignment (agentId UUID -> task)
}

Détails des attributs

prompt : l'instruction ou la requête principale de la tâche. C'est le seul champ requis.
graphId : UUID du graphe auquel appartient cette tâche. Utilisé lorsque les tâches font partie d'un workflow Graph.
graphNodeId : UUID du nœud Graph qui a créé cette tâche. Utilisé pour suivre l'origine de la tâche dans les workflows Graph.
useTools : contrôle si la tâche peut utiliser des outils/plugins. Par défaut true (hérite de l'agent si non spécifié).
mcpServers : serveurs MCP (Model Context Protocol) spécifiques à la tâche à activer pour celle-ci.
plugins : plugins spécifiques à la tâche à enregistrer pour cette exécution.
attachments : tableau de fichiers à joindre à la tâche. Prend en charge les images, PDF, fichiers texte, fichiers de code, et plus encore.
schedule : chaîne de planification simple pour une exécution basée sur le temps (par ex. 'daily@07:00', 'weekly@monday@09:00'). Champ optionnel qui active la planification automatique lorsqu'il est utilisé avec des graphes.
metadata : paires clé-valeur personnalisées pour organiser et suivre les tâches (par ex. catégorie, priorité, tags).
executionContext : métadonnées d'exécution supplémentaires sous forme d'enregistrement de paires clé-valeur. Utile pour transmettre des informations de contexte à l'exécution.

Intégration des Sub-Agents

useSubAgents : active la délégation aux sous-agents pour cette tâche spécifique. Lorsque défini sur true, l'agent principal délègue intelligemment des portions de la tâche à ses sous-agents enregistrés.
subAgentDelegation : stratégie de délégation des tâches :
- 'auto' : distribution intelligente des tâches pilotée par l'IA en fonction des capacités des sous-agents
- 'manual' : assignation explicite des tâches via le mapping taskAssignment
- 'sequential' : les sous-agents travaillent en séquence, en s'appuyant sur les résultats précédents
subAgentCoordination : modèle de coordination pour l'exécution des sous-agents :
- 'parallel' : les sous-agents travaillent simultanément pour une efficacité maximale
- 'sequential' : les sous-agents travaillent dans l'ordre avec transmission du contexte entre eux
taskAssignment : mapping d'assignation manuelle des tâches (utilisé uniquement avec subAgentDelegation: 'manual'). Associe les ID d'agents à des instructions de tâche spécifiques.

Cycle de vie d'une tâche

Les tâches traversent plusieurs états durant leur exécution :

type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed';

Pending

La tâche est créée mais pas encore démarrée. En attente d'exécution ou de dépendances.

In Progress

La tâche est activement exécutée par l'agent. Des outils peuvent être utilisés pendant cette phase.

Completed

La tâche s'est terminée avec succès, avec des résultats disponibles.

Failed

La tâche a rencontré une erreur pendant l'exécution. Les détails de l'erreur sont disponibles.

Exemple avec pièces jointes et outils

Voici un exemple complet montrant des tâches avec des pièces jointes et une intégration d'outils :

import { Agent } from '@astreus-ai/astreus';

// Create an agent
const agent = await Agent.create({
  name: 'CodeReviewAssistant',
  model: 'gpt-4o',
  vision: true // Enable vision for screenshots
});

// Code review task with multiple file types
const codeReviewTask = await agent.createTask({
  prompt: `Please perform a comprehensive code review:
    1. Check for security vulnerabilities
    2. Identify performance issues
    3. Suggest improvements for code quality
    4. Review the UI mockup for usability issues`,
  attachments: [
    { 
      type: 'code', 
      path: './src/auth/login.ts', 
      name: 'Login Controller',
      language: 'typescript' 
    },
    { 
      type: 'code', 
      path: './src/middleware/security.js', 
      name: 'Security Middleware',
      language: 'javascript' 
    },
    { 
      type: 'json', 
      path: './package.json', 
      name: 'Package Dependencies' 
    },
    { 
      type: 'image', 
      path: './designs/login-mockup.png', 
      name: 'Login UI Mockup' 
    },
    { 
      type: 'markdown', 
      path: './docs/security-requirements.md', 
      name: 'Security Requirements' 
    }
  ],
  metadata: {
    type: 'code-review',
    priority: 'high',
    reviewer: 'ai-assistant'
  }
});

// Execute task with streaming
const result = await agent.executeTask(codeReviewTask.id, {
  model: 'gpt-4o',  // Override model for this task
  stream: true      // Enable streaming response
});

console.log('Code review completed:', result.response);

// Documentation task with text files
const docTask = await agent.createTask({
  prompt: 'Update the API documentation based on the latest code changes',
  attachments: [
    { type: 'text', path: '/api/routes.txt', name: 'API Routes' },
    { type: 'markdown', path: '/README.md', name: 'Current Documentation' }
  ]
});

// List tasks with attachments
const tasksWithFiles = await agent.listTasks({
  orderBy: 'createdAt',
  order: 'desc'
});

tasksWithFiles.forEach(task => {
  console.log(`Task ${task.id}: ${task.status}`);
  if (task.metadata?.attachments) {
    console.log(`  - Has attachments`);
  }
  if (task.completedAt) {
    console.log(`  - Completed: ${task.completedAt.toISOString()}`);
  }
});

Délégation de tâches vers les Sub-Agents

Les tâches prennent désormais en charge la délégation vers des sous-agents directement via la création et l'exécution de tâches :

import { Agent } from '@astreus-ai/astreus';

// Create specialized sub-agents
const researcher = await Agent.create({
  name: 'ResearchBot',
  systemPrompt: 'You are an expert researcher who gathers comprehensive information.'
});

const writer = await Agent.create({
  name: 'WriterBot', 
  systemPrompt: 'You create engaging, well-structured content.'
});

const mainAgent = await Agent.create({
  name: 'ContentCoordinator',
  subAgents: [researcher, writer]
});

// Create task with automatic sub-agent delegation
const autoTask = await mainAgent.createTask({
  prompt: 'Research renewable energy trends and write a comprehensive report',
  useSubAgents: true,
  subAgentDelegation: 'auto',
  subAgentCoordination: 'sequential',
  metadata: { type: 'research-report', priority: 'high' }
});

// Create task with manual sub-agent assignment
const manualTask = await mainAgent.createTask({
  prompt: 'Create market analysis presentation',
  useSubAgents: true,
  subAgentDelegation: 'manual',
  subAgentCoordination: 'parallel',
  taskAssignment: {
    [researcher.id]: 'Research market data and competitor analysis',
    [writer.id]: 'Create presentation slides and executive summary'
  },
  metadata: { type: 'presentation', deadline: '2024-12-01' }
});

// Execute tasks - sub-agent coordination happens automatically
const autoResult = await mainAgent.executeTask(autoTask.id);
const manualResult = await mainAgent.executeTask(manualTask.id);

console.log('Auto-delegated result:', autoResult.response);
console.log('Manually-assigned result:', manualResult.response);

Alternative : méthodes d'agent pour l'exécution avec Sub-Agents

Vous pouvez également exploiter les sous-agents via les méthodes de l'agent pour une exécution immédiate :

// Direct execution with sub-agent delegation via agent.ask()
const result = await mainAgent.ask('Research renewable energy trends and write report', {
  useSubAgents: true,
  delegation: 'auto',
  coordination: 'sequential'
});

// Manual delegation with specific task assignments
const manualResult = await mainAgent.ask('Create market analysis presentation', {
  useSubAgents: true,
  delegation: 'manual',
  coordination: 'parallel',
  taskAssignment: {
    [researcher.id]: 'Research market data and competitor analysis',
    [writer.id]: 'Create presentation slides and executive summary'
  }
});

Avantages de la délégation vers les Sub-Agents au niveau des tâches

Configuration persistante : les paramètres de sous-agents sont stockés avec la tâche et persistent entre les sessions
Workflows reproductibles : les définitions de tâches peuvent être réutilisées avec un comportement cohérent des sous-agents
Exécution flexible : les tâches peuvent être exécutées immédiatement ou planifiées ultérieurement avec la même coordination de sous-agents
Piste d'audit : les métadonnées de la tâche incluent l'historique de délégation des sous-agents pour le suivi et le débogage

Gérer les tâches

Les tâches peuvent être gérées et suivies tout au long de leur cycle de vie :

// Update task with additional metadata
await agent.updateTask(task.id, {
  metadata: {
    ...task.metadata,
    progress: 50,
    estimatedCompletion: new Date()
  }
});

// Delete a specific task
await agent.deleteTask(task.id);

// Clear all tasks for an agent
const deletedCount = await agent.clearTasks();
console.log(`Deleted ${deletedCount} tasks`);

// Search tasks with filters
const pendingTasks = await agent.listTasks({
  status: 'pending',
  limit: 5
});

const recentTasks = await agent.listTasks({
  orderBy: 'completedAt',
  order: 'desc',
  limit: 10
});

// Filter tasks by graph
const graphTasks = await agent.listTasks({
  graphId: 'graph-uuid-123',
  orderBy: 'createdAt',
  order: 'asc'
});

Types de réponse

Comprendre les réponses des tâches vous aide à gérer les résultats d'exécution et à suivre le cycle de vie des tâches.

Réponse Task Object

Créer ou récupérer une tâche retourne un objet Task complet :

const task = await agent.createTask({
  prompt: "Analyze this data",
  useTools: true,
  metadata: { priority: "high" }
});

// Response structure (Task interface):
{
  id: "550e8400-e29b-41d4-a716-446655440000",  // UUID string
  agentId: "agent-uuid-123",                    // UUID string
  graphId?: "graph-uuid-456",                   // UUID string if part of a graph
  graphNodeId?: "node-uuid-789",                // UUID string if created by graph node
  prompt: "Analyze this data",
  response?: "Analysis result...",              // Filled after execution
  status: "pending",                            // 'pending' | 'in_progress' | 'completed' | 'failed'
  metadata?: {
    priority: "high"
  },
  executionContext?: {},                        // Additional execution metadata
  createdAt: Date('2024-01-15T10:30:00Z'),
  updatedAt: Date('2024-01-15T10:30:00Z'),
  completedAt?: Date('2024-01-15T10:35:00Z')   // Filled after completion
}

Réponse Task Execution

Exécuter une tâche retourne un TaskResponse avec les détails d'exécution :

const result = await agent.executeTask("task-uuid-123", {
  model: "gpt-4",
  stream: false
});

// Response structure (TaskResponse interface):
{
  task: {
    id: "task-uuid-123",
    agentId: "agent-uuid",
    graphId?: "graph-uuid",           // If part of a graph
    graphNodeId?: "node-uuid",        // If created by graph node
    prompt: "Analyze this data",
    response: "Analysis complete: The data shows a 15% increase...",
    status: "completed",
    metadata?: { priority: "high" },
    executionContext?: {},            // Additional execution metadata
    createdAt: Date('2024-01-15T10:30:00Z'),
    updatedAt: Date('2024-01-15T10:35:00Z'),
    completedAt: Date('2024-01-15T10:35:00Z')
  },
  response: "Analysis complete: The data shows a 15% increase in user engagement...",
  model?: "gpt-4",
  usage?: {
    promptTokens: 150,
    completionTokens: 300,
    totalTokens: 450
  }
}

Réponse Task List

Lister les tâches retourne un tableau d'objets Task :

const tasks = await agent.listTasks({
  status: 'completed',
  orderBy: 'completedAt',
  order: 'desc',
  limit: 10,
  offset: 0,           // Pagination offset
  graphId: 'optional'  // Filter by graph ID (UUID)
});

// Response structure (Task[] array):
[
  {
    id: "task-uuid-1",
    agentId: "agent-uuid",
    graphId?: "graph-uuid",        // If part of a graph
    graphNodeId?: "node-uuid",     // If created by graph node
    prompt: "First task",
    response?: "First task completed",
    status: "completed",
    metadata?: {},
    executionContext?: {},
    createdAt: Date(...),
    updatedAt: Date(...),
    completedAt?: Date(...)
  },
  {
    id: "task-uuid-2",
    agentId: "agent-uuid",
    graphId?: "graph-uuid",
    graphNodeId?: "node-uuid",
    prompt: "Second task",
    response?: "Second task completed",
    status: "completed",
    metadata?: {},
    executionContext?: {},
    createdAt: Date(...),
    updatedAt: Date(...),
    completedAt?: Date(...)
  }
]

Réponse Update Task

Mettre à jour une tâche retourne l'objet Task mis à jour ou null si non trouvé :

const updated = await agent.updateTask("task-uuid", {
  metadata: { progress: 50, estimatedCompletion: new Date() }
});

// Response: Task object with updated fields or null
{
  id: "task-uuid",
  agentId: "agent-uuid",
  prompt: "Original prompt",
  status: "in_progress",
  metadata: {
    priority: "high",
    progress: 50,
    estimatedCompletion: Date('2024-01-15T12:00:00Z')
  },
  updatedAt: Date('2024-01-15T10:40:00Z'),
  ...
}

Réponse Get Task

Récupérer une tâche spécifique retourne l'objet Task ou null :

const task = await agent.getTask("task-uuid");

// Returns: Task object or null if not found

Réponse Delete Task

Supprimer une tâche retourne un booléen indiquant le succès :

const deleted = await agent.deleteTask("task-uuid");
// Returns: true or false

Réponse Clear Tasks

Effacer toutes les tâches retourne le nombre de tâches supprimées :

const deletedCount = await agent.clearTasks();
// Returns: 25 (number of tasks deleted)

Dernière mise à jour : 6 juillet 2026

Dans cette section

Introduction

Framework d'agent IA open-source pour construire des systèmes autonomes qui résolvent efficacement des tâches concrètes.

Installation

Installez Astreus avec npm, yarn ou pnpm, vérifiez la version requise de Node.js, et préparez un projet local pour créer des agents IA avec le framework.

Démarrage rapide

Créez votre premier agent IA avec Astreus en moins de 2 minutes Découvrez les schémas de configuration, les API et les exemples pratiques nécessaires pour...

Agent

Entité IA centrale avec des capacités modulaires et une composition basée sur des décorateurs

Contexte

Graphe