✨ feat(runtime): concluir execucao isolada de tools na fase 7
parent
de455b8566
commit
7e380a9c65
@ -0,0 +1,444 @@
|
||||
"""Serviço isolado de geração de tools via LLM para o runtime administrativo.
|
||||
|
||||
Este módulo é a única camada do admin_app que conversa com o Vertex AI para fins
|
||||
de geração de código. Ele é completamente separado do LLMService do product
|
||||
(app.services.ai.llm_service) e usa configurações próprias do AdminSettings.
|
||||
|
||||
Separação arquitetural garantida por:
|
||||
- shared.contracts.model_runtime_separation.ModelRuntimeTarget.TOOL_GENERATION
|
||||
- config keys: admin_tool_generation_model / admin_tool_generation_fallback_model
|
||||
- Nenhuma importação de app.* é permitida neste módulo.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
import re
|
||||
from time import perf_counter
|
||||
from typing import Any
|
||||
|
||||
import vertexai
|
||||
from google.api_core.exceptions import GoogleAPIError, NotFound
|
||||
from vertexai.generative_models import GenerationConfig, GenerativeModel
|
||||
|
||||
from admin_app.core.settings import AdminSettings
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# ---- Constantes de geração ---------------------------------------------------
|
||||
|
||||
_PYTHON_BLOCK_RE = re.compile(
|
||||
r"```python\s*\n(.*?)```",
|
||||
re.DOTALL | re.IGNORECASE,
|
||||
)
|
||||
|
||||
# Padrões que o código gerado não pode conter.
|
||||
# Aplicados antes das validações automáticas existentes no ToolManagementService.
|
||||
_DANGEROUS_PATTERNS: tuple[tuple[str, str], ...] = (
|
||||
(r"\bexec\s*\(", "uso de exec() proibido em tools geradas"),
|
||||
(r"\beval\s*\(", "uso de eval() proibido em tools geradas"),
|
||||
(r"\b__import__\s*\(", "uso de __import__() proibido em tools geradas"),
|
||||
(r"os\.system\s*\(", "chamada a os.system() proibida em tools geradas"),
|
||||
(r"os\.popen\s*\(", "chamada a os.popen() proibida em tools geradas"),
|
||||
(r"\bsubprocess\b", "uso de subprocess proibido em tools geradas"),
|
||||
(r"from\s+app\.", "importação de app.* proibida em tools geradas"),
|
||||
(r"from\s+admin_app\.", "importação de admin_app.* proibida em tools geradas"),
|
||||
(r"import\s+app\b", "importação direta de app proibida em tools geradas"),
|
||||
(r"import\s+admin_app\b", "importação direta de admin_app proibida em tools geradas"),
|
||||
(r"\bopen\s*\(", "acesso a sistema de arquivos via open() proibido em tools geradas"),
|
||||
(r"__builtins__", "acesso a __builtins__ proibido em tools geradas"),
|
||||
)
|
||||
|
||||
# Mapeamento de tipo de parâmetro para anotação Python legível
|
||||
_TYPE_ANNOTATION_MAP: dict[str, str] = {
|
||||
"string": "str",
|
||||
"integer": "int",
|
||||
"number": "float",
|
||||
"boolean": "bool",
|
||||
"object": "dict",
|
||||
"array": "list",
|
||||
}
|
||||
|
||||
# Cache de modelos Vertex AI instanciados (por nome de modelo)
|
||||
_MODEL_CACHE: dict[str, GenerativeModel] = {}
|
||||
|
||||
# Flag de controle de inicialização do SDK (evita reinit por instância)
|
||||
_VERTEX_INITIALIZED: bool = False
|
||||
|
||||
|
||||
class ToolGenerationService:
|
||||
"""Gera implementações de tools via Vertex AI no contexto administrativo.
|
||||
|
||||
Responsabilidades:
|
||||
- Construir prompt estruturado a partir dos metadados da tool
|
||||
- Chamar o modelo LLM de geração (separado do modelo de atendimento)
|
||||
- Extrair o bloco de código Python da resposta
|
||||
- Aplicar linting de segurança antes de devolver o código
|
||||
- Retornar resultado estruturado para o ToolManagementService
|
||||
|
||||
Não faz:
|
||||
- Não persiste artefatos (responsabilidade do ToolManagementService)
|
||||
- Não valida contrato nem assinatura (responsabilidade do ToolManagementService)
|
||||
- Não executa o código gerado
|
||||
"""
|
||||
|
||||
def __init__(self, settings: AdminSettings) -> None:
|
||||
self.settings = settings
|
||||
self._ensure_vertex_initialized()
|
||||
|
||||
def _ensure_vertex_initialized(self) -> None:
|
||||
global _VERTEX_INITIALIZED
|
||||
if _VERTEX_INITIALIZED:
|
||||
return
|
||||
# Reutiliza as credenciais do projeto Google já configuradas nas settings
|
||||
# do admin (que leem do .env, idêntico ao product). O isolamento é nos
|
||||
# parâmetros de modelo e temperatura — não na conta GCP.
|
||||
try:
|
||||
import os
|
||||
project_id = os.environ.get("GOOGLE_PROJECT_ID", "")
|
||||
location = os.environ.get("GOOGLE_LOCATION", "us-central1")
|
||||
vertexai.init(project=project_id, location=location)
|
||||
_VERTEX_INITIALIZED = True
|
||||
logger.info(
|
||||
"tool_generation_service_event=vertex_initialized project=%s location=%s",
|
||||
project_id,
|
||||
location,
|
||||
)
|
||||
except Exception as exc:
|
||||
logger.warning(
|
||||
"tool_generation_service_event=vertex_init_warning error=%s",
|
||||
exc,
|
||||
)
|
||||
|
||||
def _get_model(self, model_name: str) -> GenerativeModel:
|
||||
model = _MODEL_CACHE.get(model_name)
|
||||
if model is None:
|
||||
model = GenerativeModel(model_name)
|
||||
_MODEL_CACHE[model_name] = model
|
||||
return model
|
||||
|
||||
def _build_model_sequence(self, preferred_model: str | None) -> list[str]:
|
||||
"""Constrói a sequência de modelos a tentar, respeitando o preferred e o fallback."""
|
||||
sequence: list[str] = []
|
||||
candidates = [
|
||||
preferred_model,
|
||||
self.settings.admin_tool_generation_model,
|
||||
self.settings.admin_tool_generation_fallback_model,
|
||||
]
|
||||
for candidate in candidates:
|
||||
normalized = str(candidate or "").strip()
|
||||
if normalized and normalized not in sequence:
|
||||
sequence.append(normalized)
|
||||
return sequence
|
||||
|
||||
def _build_generation_prompt(
|
||||
self,
|
||||
*,
|
||||
tool_name: str,
|
||||
display_name: str,
|
||||
domain: str,
|
||||
description: str,
|
||||
business_goal: str,
|
||||
parameters: list[dict],
|
||||
) -> str:
|
||||
"""Monta o prompt estruturado de geração enviado ao modelo.
|
||||
|
||||
O prompt descreve o contrato esperado, os restrições de importação,
|
||||
os parâmetros e o objetivo operacional da tool.
|
||||
"""
|
||||
signature_parts: list[str] = []
|
||||
parameter_lines: list[str] = []
|
||||
|
||||
for param in parameters:
|
||||
name = str(param.get("name") or "").strip().lower()
|
||||
if not name:
|
||||
continue
|
||||
param_type = str(param.get("parameter_type") or "string").strip().lower()
|
||||
description_param = str(param.get("description") or "").strip()
|
||||
required = bool(param.get("required", True))
|
||||
annotation = _TYPE_ANNOTATION_MAP.get(param_type, "str")
|
||||
|
||||
if required:
|
||||
signature_parts.append(f"{name}: {annotation}")
|
||||
else:
|
||||
signature_parts.append(f"{name}: {annotation} | None = None")
|
||||
|
||||
required_label = "obrigatório" if required else "opcional"
|
||||
parameter_lines.append(
|
||||
f" - {name} ({annotation}, {required_label}): {description_param}"
|
||||
)
|
||||
|
||||
signature = ", ".join(signature_parts)
|
||||
if signature:
|
||||
full_signature = f"async def run(*, {signature}) -> dict:"
|
||||
else:
|
||||
full_signature = "async def run() -> dict:"
|
||||
|
||||
parameters_block = (
|
||||
"\n".join(parameter_lines)
|
||||
if parameter_lines
|
||||
else " (nenhum parâmetro — a tool não recebe entrada contextual)"
|
||||
)
|
||||
|
||||
domain_context_map = {
|
||||
"vendas": (
|
||||
"O bot atua em um sistema de atendimento para concessionária automotiva. "
|
||||
"A tool opera no domínio de vendas: estoque de veículos, negociações, pedidos e cancelamentos."
|
||||
),
|
||||
"revisao": (
|
||||
"O bot atua em um sistema de atendimento de oficina automotiva. "
|
||||
"A tool opera no domínio de revisão: agendamentos, remarcações, listagem de serviços."
|
||||
),
|
||||
"locacao": (
|
||||
"O bot atua em um sistema de atendimento de locadora de veículos. "
|
||||
"A tool opera no domínio de locação: frota, contratos, pagamentos e devoluções."
|
||||
),
|
||||
"orquestracao": (
|
||||
"O bot atua em um sistema de orquestração conversacional. "
|
||||
"A tool opera no domínio de orquestração: controla fluxo, contexto e estado da conversa."
|
||||
),
|
||||
}
|
||||
domain_context = domain_context_map.get(
|
||||
str(domain or "").strip().lower(),
|
||||
"O bot atua em um sistema de atendimento automatizado.",
|
||||
)
|
||||
|
||||
return (
|
||||
"Você é um especialista em Python que gera implementações realistas de tools "
|
||||
"para um bot de atendimento.\n\n"
|
||||
f"CONTEXTO DO DOMÍNIO:\n{domain_context}\n\n"
|
||||
"CONTRATO OBRIGATÓRIO:\n"
|
||||
"- A função deve ser assíncrona: async def run(...)\n"
|
||||
"- Todos os parâmetros devem ser keyword-only (após *)\n"
|
||||
"- O tipo de retorno deve ser dict (JSON-serializável)\n"
|
||||
"- O módulo pode importar apenas stdlib (datetime, json, re, math, uuid, etc.)\n"
|
||||
"- Proibido importar: app.*, admin_app.*, subprocess, os.system, os.popen\n"
|
||||
"- Proibido usar: exec(), eval(), __import__(), open()\n\n"
|
||||
"TOOL A IMPLEMENTAR:\n"
|
||||
f"- Nome técnico: {tool_name}\n"
|
||||
f"- Nome de exibição: {display_name}\n"
|
||||
f"- Domínio: {domain}\n"
|
||||
f"- Descrição funcional: {description}\n"
|
||||
f"- Objetivo de negócio: {business_goal}\n\n"
|
||||
f"PARÂMETROS DA TOOL:\n{parameters_block}\n\n"
|
||||
f"ASSINATURA ESPERADA:\n{full_signature}\n\n"
|
||||
"INSTRUÇÕES DE GERAÇÃO:\n"
|
||||
"- Gere uma implementação realista que simule o comportamento esperado da tool.\n"
|
||||
"- O retorno deve incluir os campos relevantes ao domínio (não apenas echo dos argumentos).\n"
|
||||
"- Use dados fictícios mas verossímeis para simular a resposta operacional.\n"
|
||||
"- Nenhuma explicação ou comentário fora do código. Retorne apenas o bloco Python.\n"
|
||||
"- O módulo deve começar com um docstring descritivo.\n"
|
||||
"- Envolva o código em ```python ... ```.\n"
|
||||
)
|
||||
|
||||
def _extract_python_block(self, raw_response: str) -> str | None:
|
||||
"""Extrai o primeiro bloco ```python ... ``` da resposta do modelo."""
|
||||
normalized = str(raw_response or "").strip()
|
||||
match = _PYTHON_BLOCK_RE.search(normalized)
|
||||
if match:
|
||||
return match.group(1).strip()
|
||||
# Fallback: se não há marcador de código mas o conteúdo parece Python
|
||||
if normalized.startswith("async def run") or normalized.startswith('"""'):
|
||||
return normalized
|
||||
return None
|
||||
|
||||
def _apply_safety_linting(self, source_code: str) -> list[str]:
|
||||
"""Verifica padrões perigosos no código gerado antes da validação formal.
|
||||
|
||||
Retorna lista de issues. Lista vazia = linting passou.
|
||||
"""
|
||||
issues: list[str] = []
|
||||
for pattern, description in _DANGEROUS_PATTERNS:
|
||||
if re.search(pattern, source_code, re.MULTILINE):
|
||||
issues.append(f"linting: {description}.")
|
||||
return issues
|
||||
|
||||
async def generate_tool_source(
|
||||
self,
|
||||
*,
|
||||
tool_name: str,
|
||||
display_name: str,
|
||||
domain: str,
|
||||
description: str,
|
||||
business_goal: str,
|
||||
parameters: list[dict],
|
||||
preferred_model: str | None = None,
|
||||
) -> dict[str, Any]:
|
||||
"""Gera o código Python da tool a partir dos metadados do draft.
|
||||
|
||||
Retorna um dicionário com:
|
||||
- passed (bool): True se o código foi gerado e passou no linting
|
||||
- generated_source_code (str | None): código Python gerado
|
||||
- generation_model_used (str | None): modelo que gerou o código
|
||||
- prompt_rendered (str): prompt enviado ao modelo (para auditoria)
|
||||
- issues (list[str]): problemas encontrados (geração ou linting)
|
||||
- elapsed_ms (float): tempo total de geração em milissegundos
|
||||
"""
|
||||
prompt = self._build_generation_prompt(
|
||||
tool_name=tool_name,
|
||||
display_name=display_name,
|
||||
domain=domain,
|
||||
description=description,
|
||||
business_goal=business_goal,
|
||||
parameters=parameters,
|
||||
)
|
||||
|
||||
model_sequence = self._build_model_sequence(preferred_model)
|
||||
generation_config = GenerationConfig(
|
||||
temperature=self.settings.admin_tool_generation_temperature,
|
||||
max_output_tokens=self.settings.admin_tool_generation_max_output_tokens,
|
||||
)
|
||||
|
||||
raw_response: str | None = None
|
||||
generation_model_used: str | None = None
|
||||
last_error: Exception | None = None
|
||||
started_at = perf_counter()
|
||||
|
||||
import asyncio
|
||||
|
||||
for model_name in model_sequence:
|
||||
try:
|
||||
model = self._get_model(model_name)
|
||||
response = await asyncio.wait_for(
|
||||
asyncio.to_thread(
|
||||
model.generate_content,
|
||||
prompt,
|
||||
generation_config=generation_config,
|
||||
),
|
||||
timeout=float(self.settings.admin_tool_generation_timeout_seconds),
|
||||
)
|
||||
candidate = (
|
||||
response.candidates[0]
|
||||
if getattr(response, "candidates", None)
|
||||
else None
|
||||
)
|
||||
content = getattr(candidate, "content", None)
|
||||
parts = list(getattr(content, "parts", None) or [])
|
||||
text_parts = [
|
||||
getattr(part, "text", None)
|
||||
for part in parts
|
||||
if isinstance(getattr(part, "text", None), str)
|
||||
]
|
||||
raw_response = "\n".join(
|
||||
t for t in text_parts if t and t.strip()
|
||||
).strip() or None
|
||||
|
||||
if raw_response is None:
|
||||
# Fallback para o atributo .text raiz
|
||||
try:
|
||||
raw_response = str(response.text or "").strip() or None
|
||||
except (AttributeError, ValueError):
|
||||
raw_response = None
|
||||
|
||||
generation_model_used = model_name
|
||||
break
|
||||
|
||||
except asyncio.TimeoutError:
|
||||
last_error = TimeoutError(
|
||||
f"modelo '{model_name}' excedeu o timeout de "
|
||||
f"{self.settings.admin_tool_generation_timeout_seconds}s para geração de tools."
|
||||
)
|
||||
logger.warning(
|
||||
"tool_generation_service_event=timeout model=%s timeout_seconds=%s",
|
||||
model_name,
|
||||
self.settings.admin_tool_generation_timeout_seconds,
|
||||
)
|
||||
continue
|
||||
|
||||
except NotFound as exc:
|
||||
last_error = exc
|
||||
_MODEL_CACHE.pop(model_name, None)
|
||||
logger.warning(
|
||||
"tool_generation_service_event=model_not_found model=%s error=%s",
|
||||
model_name,
|
||||
exc,
|
||||
)
|
||||
continue
|
||||
|
||||
except GoogleAPIError as exc:
|
||||
last_error = exc
|
||||
logger.warning(
|
||||
"tool_generation_service_event=api_error model=%s error=%s",
|
||||
model_name,
|
||||
exc,
|
||||
)
|
||||
continue
|
||||
|
||||
except Exception as exc:
|
||||
last_error = exc
|
||||
logger.warning(
|
||||
"tool_generation_service_event=unexpected_error model=%s error=%s class=%s",
|
||||
model_name,
|
||||
exc,
|
||||
exc.__class__.__name__,
|
||||
)
|
||||
continue
|
||||
|
||||
elapsed_ms = round((perf_counter() - started_at) * 1000, 2)
|
||||
|
||||
if raw_response is None or generation_model_used is None:
|
||||
error_detail = str(last_error) if last_error else "nenhum modelo disponivel respondeu"
|
||||
logger.error(
|
||||
"tool_generation_service_event=generation_failed tool_name=%s elapsed_ms=%s error=%s",
|
||||
tool_name,
|
||||
elapsed_ms,
|
||||
error_detail,
|
||||
)
|
||||
return {
|
||||
"passed": False,
|
||||
"generated_source_code": None,
|
||||
"generation_model_used": None,
|
||||
"prompt_rendered": prompt,
|
||||
"issues": [f"falha na geração via LLM: {error_detail}"],
|
||||
"elapsed_ms": elapsed_ms,
|
||||
}
|
||||
|
||||
generated_source_code = self._extract_python_block(raw_response)
|
||||
if generated_source_code is None:
|
||||
logger.warning(
|
||||
"tool_generation_service_event=no_code_block tool_name=%s model=%s elapsed_ms=%s",
|
||||
tool_name,
|
||||
generation_model_used,
|
||||
elapsed_ms,
|
||||
)
|
||||
return {
|
||||
"passed": False,
|
||||
"generated_source_code": None,
|
||||
"generation_model_used": generation_model_used,
|
||||
"prompt_rendered": prompt,
|
||||
"issues": ["o modelo não retornou um bloco de código Python identificável."],
|
||||
"elapsed_ms": elapsed_ms,
|
||||
}
|
||||
|
||||
linting_issues = self._apply_safety_linting(generated_source_code)
|
||||
if linting_issues:
|
||||
logger.warning(
|
||||
"tool_generation_service_event=linting_failed tool_name=%s model=%s issues=%s elapsed_ms=%s",
|
||||
tool_name,
|
||||
generation_model_used,
|
||||
linting_issues,
|
||||
elapsed_ms,
|
||||
)
|
||||
return {
|
||||
"passed": False,
|
||||
"generated_source_code": generated_source_code,
|
||||
"generation_model_used": generation_model_used,
|
||||
"prompt_rendered": prompt,
|
||||
"issues": linting_issues,
|
||||
"elapsed_ms": elapsed_ms,
|
||||
}
|
||||
|
||||
logger.info(
|
||||
"tool_generation_service_event=generation_succeeded tool_name=%s model=%s elapsed_ms=%s",
|
||||
tool_name,
|
||||
generation_model_used,
|
||||
elapsed_ms,
|
||||
)
|
||||
return {
|
||||
"passed": True,
|
||||
"generated_source_code": generated_source_code,
|
||||
"generation_model_used": generation_model_used,
|
||||
"prompt_rendered": prompt,
|
||||
"issues": [],
|
||||
"elapsed_ms": elapsed_ms,
|
||||
}
|
||||
@ -0,0 +1,266 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import threading
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from datetime import UTC, datetime
|
||||
from time import perf_counter
|
||||
from typing import Any
|
||||
|
||||
from admin_app.core.settings import AdminSettings
|
||||
from admin_app.db.database import AdminSessionLocal
|
||||
from admin_app.repositories import (
|
||||
ToolArtifactRepository,
|
||||
ToolDraftRepository,
|
||||
ToolMetadataRepository,
|
||||
ToolVersionRepository,
|
||||
)
|
||||
from admin_app.services.tool_generation_service import ToolGenerationService
|
||||
|
||||
|
||||
class ToolGenerationWorkerService:
|
||||
"""Executa a pipeline de geracao em um worker dedicado do runtime admin.
|
||||
|
||||
O worker abre a propria sessao administrativa e cria uma instancia isolada do
|
||||
ToolManagementService dentro da thread dedicada. Assim, a geracao e as
|
||||
validacoes nao compartilham a sessao SQLAlchemy da request web nem o pool de
|
||||
threads padrao usado pelas rotas sync do FastAPI.
|
||||
"""
|
||||
|
||||
_THREAD_NAME_PREFIX = "admin-tool-generation-worker"
|
||||
_DEFAULT_POLL_AFTER_MS = 1200
|
||||
|
||||
def __init__(self, settings: AdminSettings) -> None:
|
||||
self.settings = settings
|
||||
self.max_workers = max(1, int(settings.admin_tool_generation_worker_max_workers))
|
||||
self._executor = ThreadPoolExecutor(
|
||||
max_workers=self.max_workers,
|
||||
thread_name_prefix=self._THREAD_NAME_PREFIX,
|
||||
)
|
||||
self._lock = threading.Lock()
|
||||
self._pending_jobs = 0
|
||||
self._jobs: dict[str, dict[str, Any]] = {}
|
||||
|
||||
def shutdown(self, *, wait: bool = False) -> None:
|
||||
self._executor.shutdown(wait=wait, cancel_futures=True)
|
||||
|
||||
def execute_generation_pipeline(
|
||||
self,
|
||||
*,
|
||||
version_id: str,
|
||||
runner_staff_account_id: int,
|
||||
runner_name: str,
|
||||
runner_role,
|
||||
) -> dict[str, Any]:
|
||||
submitted_at = datetime.now(UTC).isoformat()
|
||||
with self._lock:
|
||||
self._pending_jobs += 1
|
||||
queued_jobs_before_submit = max(self._pending_jobs - 1, 0)
|
||||
|
||||
started_at = perf_counter()
|
||||
future = self._executor.submit(
|
||||
self._run_generation_pipeline_job,
|
||||
version_id,
|
||||
runner_staff_account_id,
|
||||
runner_name,
|
||||
runner_role,
|
||||
)
|
||||
try:
|
||||
payload = future.result()
|
||||
finally:
|
||||
with self._lock:
|
||||
self._pending_jobs = max(self._pending_jobs - 1, 0)
|
||||
pending_jobs_after_completion = self._pending_jobs
|
||||
|
||||
execution = {
|
||||
"mode": "dedicated_generation_worker",
|
||||
"target": "admin_tool_generation_worker",
|
||||
"dispatch_state": "completed",
|
||||
"worker_max_workers": self.max_workers,
|
||||
"worker_pending_jobs": pending_jobs_after_completion,
|
||||
"queued_jobs_before_submit": queued_jobs_before_submit,
|
||||
"submitted_at": submitted_at,
|
||||
"started_at": submitted_at,
|
||||
"completed_at": datetime.now(UTC).isoformat(),
|
||||
"elapsed_ms": round((perf_counter() - started_at) * 1000, 2),
|
||||
"worker_thread_name": str(payload.pop("_worker_thread_name", "")) or None,
|
||||
"poll_after_ms": None,
|
||||
"last_error": None,
|
||||
}
|
||||
enriched_payload = dict(payload)
|
||||
enriched_payload["execution"] = execution
|
||||
return enriched_payload
|
||||
|
||||
def dispatch_generation_pipeline(
|
||||
self,
|
||||
*,
|
||||
version_id: str,
|
||||
runner_staff_account_id: int,
|
||||
runner_name: str,
|
||||
runner_role,
|
||||
) -> dict[str, Any]:
|
||||
normalized_version_id = str(version_id or "").strip().lower()
|
||||
if not normalized_version_id:
|
||||
raise ValueError("Versao administrativa invalida para o worker de geracao.")
|
||||
|
||||
with self._lock:
|
||||
existing_job = self._jobs.get(normalized_version_id)
|
||||
if existing_job is not None and existing_job.get("dispatch_state") in {"queued", "running"}:
|
||||
return self._build_dispatch_snapshot_locked(existing_job)
|
||||
|
||||
self._pending_jobs += 1
|
||||
queued_jobs_before_submit = max(self._pending_jobs - 1, 0)
|
||||
job = {
|
||||
"version_id": normalized_version_id,
|
||||
"dispatch_state": "queued",
|
||||
"queued_jobs_before_submit": queued_jobs_before_submit,
|
||||
"submitted_at": datetime.now(UTC).isoformat(),
|
||||
"started_at": None,
|
||||
"completed_at": None,
|
||||
"elapsed_ms": None,
|
||||
"worker_thread_name": None,
|
||||
"last_error": None,
|
||||
"result_payload": None,
|
||||
}
|
||||
self._jobs[normalized_version_id] = job
|
||||
self._executor.submit(
|
||||
self._run_generation_pipeline_job_async,
|
||||
normalized_version_id,
|
||||
runner_staff_account_id,
|
||||
runner_name,
|
||||
runner_role,
|
||||
)
|
||||
return self._build_dispatch_snapshot_locked(job)
|
||||
|
||||
def get_generation_pipeline_dispatch(self, version_id: str) -> dict[str, Any] | None:
|
||||
normalized_version_id = str(version_id or "").strip().lower()
|
||||
if not normalized_version_id:
|
||||
return None
|
||||
with self._lock:
|
||||
job = self._jobs.get(normalized_version_id)
|
||||
if job is None:
|
||||
return None
|
||||
return self._build_dispatch_snapshot_locked(job)
|
||||
|
||||
def _run_generation_pipeline_job_async(
|
||||
self,
|
||||
version_id: str,
|
||||
runner_staff_account_id: int,
|
||||
runner_name: str,
|
||||
runner_role,
|
||||
) -> None:
|
||||
self._mark_job_running(version_id)
|
||||
try:
|
||||
payload = self._run_generation_pipeline_job(
|
||||
version_id,
|
||||
runner_staff_account_id,
|
||||
runner_name,
|
||||
runner_role,
|
||||
)
|
||||
except Exception as exc:
|
||||
self._mark_job_failed(version_id, exc)
|
||||
return
|
||||
self._mark_job_completed(version_id, payload)
|
||||
|
||||
def _mark_job_running(self, version_id: str) -> None:
|
||||
with self._lock:
|
||||
job = self._jobs.get(version_id)
|
||||
if job is None:
|
||||
return
|
||||
job["dispatch_state"] = "running"
|
||||
job["started_at"] = datetime.now(UTC).isoformat()
|
||||
job["worker_thread_name"] = threading.current_thread().name
|
||||
|
||||
def _mark_job_completed(self, version_id: str, payload: dict[str, Any]) -> None:
|
||||
with self._lock:
|
||||
job = self._jobs.get(version_id)
|
||||
if job is None:
|
||||
return
|
||||
completed_at = datetime.now(UTC).isoformat()
|
||||
started_reference = self._parse_job_timestamp(job.get("started_at")) or self._parse_job_timestamp(job.get("submitted_at"))
|
||||
elapsed_ms = None
|
||||
if started_reference is not None:
|
||||
elapsed_ms = round((datetime.now(UTC) - started_reference).total_seconds() * 1000, 2)
|
||||
job["dispatch_state"] = "completed"
|
||||
job["completed_at"] = completed_at
|
||||
job["elapsed_ms"] = elapsed_ms
|
||||
job["result_payload"] = dict(payload)
|
||||
job["last_error"] = None
|
||||
self._pending_jobs = max(self._pending_jobs - 1, 0)
|
||||
|
||||
def _mark_job_failed(self, version_id: str, exc: Exception) -> None:
|
||||
with self._lock:
|
||||
job = self._jobs.get(version_id)
|
||||
if job is None:
|
||||
return
|
||||
completed_at = datetime.now(UTC).isoformat()
|
||||
started_reference = self._parse_job_timestamp(job.get("started_at")) or self._parse_job_timestamp(job.get("submitted_at"))
|
||||
elapsed_ms = None
|
||||
if started_reference is not None:
|
||||
elapsed_ms = round((datetime.now(UTC) - started_reference).total_seconds() * 1000, 2)
|
||||
job["dispatch_state"] = "failed"
|
||||
job["completed_at"] = completed_at
|
||||
job["elapsed_ms"] = elapsed_ms
|
||||
job["last_error"] = f"{type(exc).__name__}: {exc}"
|
||||
self._pending_jobs = max(self._pending_jobs - 1, 0)
|
||||
|
||||
def _build_dispatch_snapshot_locked(self, job: dict[str, Any]) -> dict[str, Any]:
|
||||
dispatch_state = str(job.get("dispatch_state") or "queued")
|
||||
snapshot = {
|
||||
"mode": "dedicated_generation_worker_async",
|
||||
"target": "admin_tool_generation_worker",
|
||||
"dispatch_state": dispatch_state,
|
||||
"worker_max_workers": self.max_workers,
|
||||
"worker_pending_jobs": self._pending_jobs,
|
||||
"queued_jobs_before_submit": job.get("queued_jobs_before_submit", 0),
|
||||
"submitted_at": job.get("submitted_at"),
|
||||
"started_at": job.get("started_at"),
|
||||
"completed_at": job.get("completed_at"),
|
||||
"elapsed_ms": job.get("elapsed_ms"),
|
||||
"worker_thread_name": job.get("worker_thread_name"),
|
||||
"poll_after_ms": self._DEFAULT_POLL_AFTER_MS if dispatch_state in {"queued", "running"} else None,
|
||||
"last_error": job.get("last_error"),
|
||||
}
|
||||
result_payload = job.get("result_payload")
|
||||
if isinstance(result_payload, dict):
|
||||
snapshot["result_payload"] = dict(result_payload)
|
||||
return snapshot
|
||||
|
||||
@staticmethod
|
||||
def _parse_job_timestamp(value: Any) -> datetime | None:
|
||||
if not isinstance(value, str) or not value.strip():
|
||||
return None
|
||||
try:
|
||||
return datetime.fromisoformat(value)
|
||||
except ValueError:
|
||||
return None
|
||||
|
||||
def _run_generation_pipeline_job(
|
||||
self,
|
||||
version_id: str,
|
||||
runner_staff_account_id: int,
|
||||
runner_name: str,
|
||||
runner_role,
|
||||
) -> dict[str, Any]:
|
||||
from admin_app.services.tool_management_service import ToolManagementService
|
||||
|
||||
db = AdminSessionLocal()
|
||||
try:
|
||||
service = ToolManagementService(
|
||||
settings=self.settings,
|
||||
draft_repository=ToolDraftRepository(db),
|
||||
version_repository=ToolVersionRepository(db),
|
||||
metadata_repository=ToolMetadataRepository(db),
|
||||
artifact_repository=ToolArtifactRepository(db),
|
||||
tool_generation_service=ToolGenerationService(self.settings),
|
||||
)
|
||||
payload = service.run_generation_pipeline(
|
||||
version_id,
|
||||
runner_staff_account_id=runner_staff_account_id,
|
||||
runner_name=runner_name,
|
||||
runner_role=runner_role,
|
||||
)
|
||||
payload = dict(payload)
|
||||
payload["_worker_thread_name"] = threading.current_thread().name
|
||||
return payload
|
||||
finally:
|
||||
db.close()
|
||||
@ -0,0 +1,180 @@
|
||||
import threading
|
||||
import unittest
|
||||
from types import SimpleNamespace
|
||||
from unittest.mock import Mock, patch
|
||||
|
||||
from admin_app.core import AdminSettings
|
||||
from admin_app.services.tool_generation_worker_service import ToolGenerationWorkerService
|
||||
from admin_app.services.tool_management_service import ToolManagementService
|
||||
from shared.contracts import StaffRole, ToolLifecycleStatus
|
||||
|
||||
|
||||
class ToolGenerationWorkerServiceTests(unittest.TestCase):
|
||||
def test_execute_generation_pipeline_uses_dedicated_worker_metadata(self):
|
||||
worker = ToolGenerationWorkerService(AdminSettings())
|
||||
main_thread_name = threading.current_thread().name
|
||||
|
||||
def fake_job(version_id, runner_staff_account_id, runner_name, runner_role):
|
||||
self.assertNotEqual(threading.current_thread().name, main_thread_name)
|
||||
self.assertEqual(version_id, 'tool_version::resumo::v1')
|
||||
self.assertEqual(runner_staff_account_id, 7)
|
||||
self.assertEqual(runner_name, 'Diretoria')
|
||||
self.assertEqual(runner_role, StaffRole.DIRETOR)
|
||||
return {
|
||||
'service': 'admin_tool_governance',
|
||||
'version_id': version_id,
|
||||
'status': 'generated',
|
||||
'_worker_thread_name': threading.current_thread().name,
|
||||
}
|
||||
|
||||
try:
|
||||
with patch.object(worker, '_run_generation_pipeline_job', side_effect=fake_job):
|
||||
payload = worker.execute_generation_pipeline(
|
||||
version_id='tool_version::resumo::v1',
|
||||
runner_staff_account_id=7,
|
||||
runner_name='Diretoria',
|
||||
runner_role=StaffRole.DIRETOR,
|
||||
)
|
||||
finally:
|
||||
worker.shutdown(wait=True)
|
||||
|
||||
execution = payload['execution']
|
||||
self.assertEqual(execution['mode'], 'dedicated_generation_worker')
|
||||
self.assertEqual(execution['target'], 'admin_tool_generation_worker')
|
||||
self.assertEqual(execution['dispatch_state'], 'completed')
|
||||
self.assertEqual(execution['worker_max_workers'], 1)
|
||||
self.assertEqual(execution['queued_jobs_before_submit'], 0)
|
||||
self.assertEqual(execution['worker_pending_jobs'], 0)
|
||||
self.assertIsNotNone(execution['submitted_at'])
|
||||
self.assertGreaterEqual(execution['elapsed_ms'], 0)
|
||||
self.assertTrue(execution['worker_thread_name'].startswith('admin-tool-generation-worker'))
|
||||
self.assertEqual(payload['version_id'], 'tool_version::resumo::v1')
|
||||
self.assertEqual(payload['status'], 'generated')
|
||||
|
||||
def test_dispatch_generation_pipeline_returns_queued_snapshot_without_waiting_completion(self):
|
||||
worker = ToolGenerationWorkerService(AdminSettings())
|
||||
job_started = threading.Event()
|
||||
release_job = threading.Event()
|
||||
|
||||
def fake_job(version_id, runner_staff_account_id, runner_name, runner_role):
|
||||
job_started.set()
|
||||
release_job.wait(timeout=2)
|
||||
return {
|
||||
'service': 'admin_tool_governance',
|
||||
'version_id': version_id,
|
||||
'status': 'generated',
|
||||
'_worker_thread_name': threading.current_thread().name,
|
||||
}
|
||||
|
||||
try:
|
||||
with patch.object(worker, '_run_generation_pipeline_job', side_effect=fake_job):
|
||||
dispatch = worker.dispatch_generation_pipeline(
|
||||
version_id='tool_version::assinc::v1',
|
||||
runner_staff_account_id=9,
|
||||
runner_name='Diretoria',
|
||||
runner_role=StaffRole.DIRETOR,
|
||||
)
|
||||
self.assertEqual(dispatch['mode'], 'dedicated_generation_worker_async')
|
||||
self.assertIn(dispatch['dispatch_state'], {'queued', 'running'})
|
||||
self.assertEqual(dispatch['target'], 'admin_tool_generation_worker')
|
||||
self.assertEqual(dispatch['queued_jobs_before_submit'], 0)
|
||||
self.assertGreaterEqual(dispatch['poll_after_ms'], 1)
|
||||
job_started.wait(timeout=2)
|
||||
running_snapshot = worker.get_generation_pipeline_dispatch('tool_version::assinc::v1')
|
||||
self.assertIsNotNone(running_snapshot)
|
||||
self.assertIn(running_snapshot['dispatch_state'], {'running', 'completed'})
|
||||
release_job.set()
|
||||
release_job.wait(timeout=2)
|
||||
finally:
|
||||
worker.shutdown(wait=True)
|
||||
|
||||
|
||||
class ToolManagementServiceWorkerFallbackTests(unittest.TestCase):
|
||||
def test_run_generation_pipeline_in_worker_falls_back_to_inline_execution_metadata(self):
|
||||
service = ToolManagementService(settings=AdminSettings())
|
||||
|
||||
with patch.object(
|
||||
service,
|
||||
'run_generation_pipeline',
|
||||
return_value={
|
||||
'service': 'admin_tool_governance',
|
||||
'message': 'ok',
|
||||
'version_id': 'tool_version::inline::v1',
|
||||
'status': 'generated',
|
||||
},
|
||||
) as run_generation_pipeline:
|
||||
payload = service.run_generation_pipeline_in_worker(
|
||||
'tool_version::inline::v1',
|
||||
runner_staff_account_id=4,
|
||||
runner_name='Colaborador',
|
||||
runner_role=StaffRole.COLABORADOR,
|
||||
)
|
||||
|
||||
run_generation_pipeline.assert_called_once_with(
|
||||
'tool_version::inline::v1',
|
||||
runner_staff_account_id=4,
|
||||
runner_name='Colaborador',
|
||||
runner_role=StaffRole.COLABORADOR,
|
||||
)
|
||||
self.assertEqual(payload['execution']['mode'], 'inline_admin_service')
|
||||
self.assertEqual(payload['execution']['target'], 'admin_inline_generation_pipeline')
|
||||
self.assertEqual(payload['execution']['dispatch_state'], 'completed')
|
||||
self.assertEqual(payload['execution']['queued_jobs_before_submit'], 0)
|
||||
self.assertIsNone(payload['execution']['worker_max_workers'])
|
||||
self.assertEqual(payload['version_id'], 'tool_version::inline::v1')
|
||||
|
||||
def test_run_generation_pipeline_in_worker_returns_queued_snapshot_when_dedicated_worker_accepts_job(self):
|
||||
version = SimpleNamespace(
|
||||
id=11,
|
||||
version_id='tool_version::fila::v1',
|
||||
tool_name='emitir_resumo_locacao',
|
||||
version_number=1,
|
||||
status=ToolLifecycleStatus.DRAFT,
|
||||
summary='Resumo governado em fila.',
|
||||
owner_display_name='Diretoria',
|
||||
updated_at=None,
|
||||
created_at=None,
|
||||
)
|
||||
draft_repository = Mock()
|
||||
draft_repository.get_by_tool_name.return_value = SimpleNamespace(id=3)
|
||||
version_repository = Mock()
|
||||
version_repository.get_by_version_id.return_value = version
|
||||
version_repository.list_versions.return_value = [version]
|
||||
metadata_repository = Mock()
|
||||
metadata_repository.get_by_tool_version_id.return_value = SimpleNamespace(display_name='Emitir resumo locacao')
|
||||
worker = Mock()
|
||||
worker.dispatch_generation_pipeline.return_value = {
|
||||
'mode': 'dedicated_generation_worker_async',
|
||||
'target': 'admin_tool_generation_worker',
|
||||
'dispatch_state': 'queued',
|
||||
'worker_max_workers': 1,
|
||||
'worker_pending_jobs': 1,
|
||||
'queued_jobs_before_submit': 0,
|
||||
'submitted_at': '2026-04-02T10:00:00+00:00',
|
||||
'started_at': None,
|
||||
'completed_at': None,
|
||||
'elapsed_ms': None,
|
||||
'worker_thread_name': None,
|
||||
'poll_after_ms': 1200,
|
||||
'last_error': None,
|
||||
}
|
||||
service = ToolManagementService(
|
||||
settings=AdminSettings(),
|
||||
draft_repository=draft_repository,
|
||||
version_repository=version_repository,
|
||||
metadata_repository=metadata_repository,
|
||||
tool_generation_worker_service=worker,
|
||||
)
|
||||
|
||||
payload = service.run_generation_pipeline_in_worker(
|
||||
'tool_version::fila::v1',
|
||||
runner_staff_account_id=1,
|
||||
runner_name='Diretoria',
|
||||
runner_role=StaffRole.DIRETOR,
|
||||
)
|
||||
|
||||
self.assertEqual(payload['status'], ToolLifecycleStatus.DRAFT)
|
||||
self.assertEqual(payload['execution']['dispatch_state'], 'queued')
|
||||
self.assertEqual(payload['queue_entry']['gate'], 'generation_pipeline_queued')
|
||||
self.assertEqual(payload['queue_entry']['automated_validation_status'], 'pending')
|
||||
self.assertIn('request foi liberada', payload['message'])
|
||||
Loading…
Reference in New Issue