Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
seclab-taskflow-agent — Framework multi-agents compatible MCP pour des workflows agentiques déclaratifs pilotés par YAML, utilisé pour l'audit de code assisté par IA, le triage des vulnérabilités et la recherche en sécurité avec intégration CodeQL. | Kitploit
Outils/GitHubGitHub/githubsecuritylab/seclab-taskflow-agent
Analyse StatiqueScanners de VulnérabilitésAnalyse Statique de Code (SAST)Analyse des VulnérabilitésAnalyse de CodeScripting et AutomatisationTests d'IntrusionUtilitaires et Frameworks
Apprentissage Automatique
Apprentissage et Éducation
Rétro-Ingénierie Assistée par IA
Sécurité de l'IA
GitHubgithubsecuritylab/seclab-taskflow-agent

seclab-taskflow-agent

Framework multi-agents compatible MCP pour des workflows agentiques déclaratifs pilotés par YAML, utilisé pour l'audit de code assisté par IA, le triage des vulnérabilités et la recherche en sécurité avec intégration CodeQL.

Voir le dépôt
28742125il y a 11 joursVérifié par Kitploit
Partager

Agent Taskflow du GitHub Security Lab

L'Agent Taskflow du Security Lab est un framework multi-agents compatible MCP pour des workflows agentiques déclaratifs pilotés par YAML.

Construit au-dessus du SDK OpenAI Agents, il utilise Pydantic pour la validation de la grammaire et Jinja2 pour le rendu des modèles.

Concepts fondamentaux

L'Agent Taskflow s'appuie sur une grammaire YAML inspirée des GitHub Workflows pour exécuter une série de tâches à l'aide d'un ensemble d'Agents.

Sa principale proposition de valeur est d'être un outil CLI permettant aux utilisateurs de définir et de scripter rapidement des workflows agentiques sans avoir à écrire de code.

Les Agents sont définis via des personnalités, qui reçoivent une tâche à accomplir, avec un ensemble d'outils.

Les Agents peuvent coopérer pour accomplir des séquences de tâches via ce que l'on appelle des taskflows.

Vous trouverez un aperçu détaillé de la grammaire des taskflows ici et des exemples de taskflows ici.

Architecture

┌─────────────────────────────────────────────────────┐
│                   CLI (cli.py)                      │
│  Typer-based entry point: -p, -t, -l, -g, -m, --resume, --lint│
└─────────────────────┬───────────────────────────────┘
                      │
┌─────────────────────▼───────────────────────────────┐
│              Runner (runner.py)                     │
│  Taskflow execution loop, model resolution,         │
│  template rendering, session checkpointing          │
└─────────────────────┬───────────────────────────────┘
                      │
┌─────────────────────▼───────────────────────────────┐
│          MCP Lifecycle (mcp_lifecycle.py)           │
│  Server connection, cleanup, process management     │
└─────────────────────┬───────────────────────────────┘
                      │
┌─────────────────────▼───────────────────────────────┐
│            Agent (agent.py)                         │
│  TaskAgent wrapper, hooks, OpenAI Agents SDK bridge │
└─────────────────────────────────────────────────────┘

Supporting modules:
  models.py          — Pydantic v2 grammar models (validation)
  session.py         — Task-level checkpoint / resume
  available_tools.py — YAML resource loader with caching
  template_utils.py  — Jinja2 template environment
  mcp_utils.py       — MCP client parameter resolution
  mcp_transport.py   — MCP transport implementations (stdio, streamable)
  mcp_prompt.py      — System prompt construction
  prompt_parser.py   — Legacy prompt argument parser
  capi.py            — AI API endpoint and token management
  path_utils.py      — Platform-aware data/log directories

Types d'API

L'agent prend en charge à la fois les API OpenAI Chat Completions et Responses. Le type d'API peut être configuré globalement ou par modèle dans un fichier model_config :

seclab-taskflow-agent:
  version: "1.0"
  filetype: model_config
api_type: chat_completions        # default for all models
models:
  gpt_default: gpt-4.1
  gpt_responses: gpt-5.1
model_settings:
  gpt_responses:
    api_type: responses           # override for this model
    endpoint: https://api.githubcopilot.com
    token: CAPI_TOKEN             # env var name containing the API key

Les model_settings par modèle peuvent inclure :

  • api_type — "chat_completions" (par défaut) ou "responses"
  • endpoint — remplacement de l'URL de base de l'API pour ce modèle
  • token — nom d'une variable d'environnement contenant la clé API

Backends

Le runner peut piloter trois SDK derrière une interface commune :

  • openai_agents (par défaut) — le SDK Python OpenAI Agents. Prend en charge les transferts multi-personnalités, à la fois chat_completions et responses pour api_type, temperature, parallel_tool_calls, exclude_from_context, et MCP via stdio, SSE et HTTP streamable.
  • copilot_sdk — le SDK Python GitHub Copilot. Prend en charge le streaming, reasoning_effort, MCP via stdio/SSE/HTTP, et le contrôle des permissions par outil. Le SDK sélectionne son propre protocole de communication par modèle, donc le champ api_type du YAML n'est pas pris en compte ; les transferts multi-personnalités, temperature et parallel_tool_calls ne sont pas non plus disponibles. Les taskflows qui utilisent des champs non pris en charge échouent au chargement avec une BackendCapabilityError nommant le champ en cause.
  • anthropic_sdk — le SDK Python Anthropic, pilotant l'API native Messages (/v1/messages). Prend en charge le streaming, l'appel d'outils via MCP, et la réflexion adaptative avec reasoning.effort configurable (low, medium, high, max). Les transferts ne sont pas pris en charge. Conçu pour être utilisé avec le point de terminaison Anthropic de CAPI ; l'authentification utilise Authorization: Bearer (et non x-api-key).

Ordre de priorité de sélection (du plus haut au plus bas) :

  1. backend: par tâche dans le bloc model_settings propre à la tâche (remplace la valeur au niveau du modèle pour cette tâche ; voir _resolve_task_model()).
  2. backend: par modèle dans le model_settings de la configuration du modèle (permet des backends mixtes dans un même taskflow).
  3. Champ backend: au niveau supérieur du document de configuration du modèle (valeur par défaut globale).
  4. Variable d'environnement SECLAB_TASKFLOW_BACKEND.
  5. openai_agents.
seclab-taskflow-agent:
  version: "1.0"
  filetype: model_config
models:
  code_analysis: claude-opus-4.7
  general_tasks: gpt-5.4-mini
model_settings:
  code_analysis:
    api_type: messages
    backend: anthropic_sdk
    reasoning:
      effort: high
  general_tasks:
    api_type: responses
    backend: openai_agents

Traduction des erreurs et nouvelle tentative

Chaque adaptateur de backend traduit ses exceptions natives du SDK vers la hiérarchie neutre dans sdk/errors.py, afin que le runner applique la politique de nouvelle tentative sans importer aucun SDK. Ajouter un backend implique également de traduire ses erreurs ; test_every_backend_adapter_translates_transport_failures le vérifie à travers le registre.

Les défaillances de transport nécessitent une gestion explicite et sont faciles à manquer. Les SDK des fournisseurs n'enveloppent httpx qu'autour de l'appel qui envoie la requête, et avec le streaming, celui-ci retourne dès que les en-têtes de réponse arrivent tandis que le corps est itéré ensuite. Une connexion qui meurt en cours de corps se manifeste donc comme une erreur httpx brute, ni dans la hiérarchie propre du SDK ni dans celle des builtins. sdk/_transport.py énumère celles qui sont réessayables, et chaque adaptateur les mappe vers BackendTransportError. L'ensemble est énuméré plutôt que de capturer httpx.TransportError en bloc, car LocalProtocolError signifie que la requête était malformée et UnsupportedProtocol est déterministe.

Télécharger l’outil

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    524
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    478
  • 3

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    357
  • 4

    redforge

    cybersecurity91/redforge

    Boîte à outils red team côté navigateur avec 102 outils hors ligne pour la reconnaissance, la génération de payloads, les attaques par identifiants, la cryptographie, l'encodage et le reporting d'engagement.

    317
  • 5

    estorides

    grisuno/estorides

    Agrège plus de 99 sources OSINT gratuites en parallèle, résout les entités dans un graphe de connaissances et exporte en STIX 2.1, MISP ou GraphML avec une analyse assistée par LLM.

    305
  • 6

    opencti

    opencti-platform/opencti

    Plateforme ouverte de renseignement sur les cybermenaces

    275

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →