@llm-dev-ops/agentics-cli 1.4.53 → 1.4.55

package/dist/bundled-agents/copilot-agents/functions/src/index.ts

@@ -0,0 +1,201 @@
+/**
+ * Cloud Function Entry Point: copilot-agents
+ *
+ * Unified HTTP handler for all 7 copilot agents.
+ * Deploy: gcloud functions deploy copilot-agents --runtime nodejs20 --trigger-http
+ *         --region us-central1 --project agentics-dev --entry-point handler
+ *         --memory 512MB --timeout 120s --no-allow-unauthenticated
+ *
+ * Routes:
+ *   POST /v1/copilot/planner       → Planner Agent
+ *   POST /v1/copilot/config        → Config Validation Agent
+ *   POST /v1/copilot/decomposer    → Decomposer Agent
+ *   POST /v1/copilot/clarifier     → Objective Clarifier Agent
+ *   POST /v1/copilot/intent        → Intent Classifier Agent
+ *   POST /v1/copilot/reflection    → Reflection Agent
+ *   POST /v1/copilot/meta-reasoner → Meta-Reasoner Agent
+ *   GET  /health                    → Health check
+ */
+
+import { IncomingMessage, ServerResponse } from 'http';
+import * as crypto from 'crypto';
+import { routeRequest } from './router';
+import { handleHealth } from './health';
+import { setCorsHeaders, handlePreflight } from './cors';
+import {
+  ExecutionMetadata,
+  LayerExecuted,
+  wrapResponse,
+  wrapAgentResult,
+  AgentExecutionMetadata,
+} from './envelope';
+
+export interface CfRequest extends IncomingMessage {
+  body?: unknown;
+  rawBody?: Buffer;
+}
+
+export interface CfResponse extends ServerResponse {
+  status?: (code: number) => CfResponse;
+  json?: (data: unknown) => void;
+  send?: (data: string | Buffer) => void;
+}
+
+/**
+ * Parse JSON body from request
+ */
+function parseBody(req: CfRequest): unknown {
+  // Cloud Functions automatically parse JSON bodies into req.body
+  if (req.body !== undefined) {
+    return req.body;
+  }
+  return undefined;
+}
+
+/**
+ * Send JSON response
+ */
+function sendJson(res: CfResponse, statusCode: number, data: unknown): void {
+  res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(data));
+}
+
+/**
+ * Main Cloud Function handler
+ *
+ * Entry point name: handler
+ */
+export async function handler(req: CfRequest, res: CfResponse): Promise<void> {
+  const startTime = Date.now();
+
+  // CORS headers on every response
+  setCorsHeaders(res);
+
+  // Handle CORS preflight
+  if (req.method === 'OPTIONS') {
+    handlePreflight(res);
+    return;
+  }
+
+  const url = new URL(req.url || '/', `https://${req.headers.host || 'localhost'}`);
+  const pathname = url.pathname;
+
+  // Build execution metadata
+  const traceId = (req.headers['x-correlation-id'] as string) || crypto.randomUUID();
+  const executionId = crypto.randomUUID();
+
+  const executionMetadata: ExecutionMetadata = {
+    trace_id: traceId,
+    timestamp: new Date().toISOString(),
+    service: 'copilot-agents',
+    execution_id: executionId,
+  };
+
+  // Health endpoint
+  if (pathname === '/health' && (req.method === 'GET' || req.method === 'HEAD')) {
+    const healthResult = handleHealth();
+    const layers: LayerExecuted[] = [
+      { layer: 'AGENT_ROUTING', status: 'completed' },
+      { layer: 'HEALTH_CHECK', status: 'completed', duration_ms: Date.now() - startTime },
+    ];
+    sendJson(res, 200, wrapResponse(healthResult, executionMetadata, layers));
+    return;
+  }
+
+  // Agent routes: POST /v1/copilot/{agent}
+  if (req.method === 'POST' && pathname.startsWith('/v1/copilot/')) {
+    // Require end-user Anthropic API key via header
+    const anthropicApiKey = req.headers['x-anthropic-api-key'] as string | undefined;
+    if (!anthropicApiKey) {
+      const layers: LayerExecuted[] = [
+        { layer: 'AGENT_ROUTING', status: 'error' },
+      ];
+      sendJson(res, 400, wrapResponse(
+        { error: 'Missing Anthropic API key. Set it via `agentics login` or the ANTHROPIC_API_KEY environment variable.' },
+        executionMetadata,
+        layers
+      ));
+      return;
+    }
+
+    const agentSlug = pathname.replace('/v1/copilot/', '').replace(/\/$/, '');
+    const body = parseBody(req);
+
+    if (!body || typeof body !== 'object') {
+      const layers: LayerExecuted[] = [
+        { layer: 'AGENT_ROUTING', status: 'completed' },
+      ];
+      sendJson(res, 400, wrapResponse(
+        { error: 'Request body must be a JSON object' },
+        executionMetadata,
+        layers
+      ));
+      return;
+    }
+
+    try {
+      const routingLayerStart = Date.now();
+      const routeResult = await routeRequest(agentSlug, body);
+      const routingDuration = Date.now() - routingLayerStart;
+
+      const agentName = agentSlug.toUpperCase().replace(/-/g, '_');
+      const layers: LayerExecuted[] = [
+        { layer: 'AGENT_ROUTING', status: 'completed' },
+        { layer: `COPILOT_${agentName}`, status: 'completed', duration_ms: routingDuration },
+      ];
+
+      // Build per-agent execution_metadata
+      const agentMeta: AgentExecutionMetadata = {
+        trace_id: traceId,
+        agent: agentSlug,
+        domain: 'copilot',
+        timestamp: new Date().toISOString(),
+      };
+      if (routeResult.pipelineContext) {
+        agentMeta.pipeline_context = routeResult.pipelineContext;
+      }
+
+      // Wrap the agent result with per-agent execution_metadata
+      const wrappedResult = wrapAgentResult(routeResult.agentResult, agentMeta);
+
+      const statusCode = routeResult.agentResult.status === 'success' ? 200 : 422;
+      sendJson(res, statusCode, wrapResponse(wrappedResult, executionMetadata, layers));
+      return;
+    } catch (err) {
+      const agentName = agentSlug.toUpperCase().replace(/-/g, '_');
+      const layers: LayerExecuted[] = [
+        { layer: 'AGENT_ROUTING', status: 'completed' },
+        { layer: `COPILOT_${agentName}`, status: 'error', duration_ms: Date.now() - startTime },
+      ];
+      const errorMessage = err instanceof Error ? err.message : 'Internal server error';
+      sendJson(res, 500, wrapResponse(
+        { error: errorMessage },
+        executionMetadata,
+        layers
+      ));
+      return;
+    }
+  }
+
+  // 404 for unmatched routes
+  const layers: LayerExecuted[] = [
+    { layer: 'AGENT_ROUTING', status: 'error' },
+  ];
+  sendJson(res, 404, wrapResponse(
+    {
+      error: 'Not found',
+      available_routes: [
+        'POST /v1/copilot/planner',
+        'POST /v1/copilot/config',
+        'POST /v1/copilot/decomposer',
+        'POST /v1/copilot/clarifier',
+        'POST /v1/copilot/intent',
+        'POST /v1/copilot/reflection',
+        'POST /v1/copilot/meta-reasoner',
+        'GET /health',
+      ],
+    },
+    executionMetadata,
+    layers
+  ));
+}

package/dist/bundled-agents/copilot-agents/functions/src/router.ts

@@ -0,0 +1,148 @@
+/**
+ * Agent Router
+ *
+ * Maps URL slugs to agent invocations.
+ * Does NOT create new agents or modify business logic.
+ * Instantiates existing agents with persistence/telemetry from env
+ * and routes HTTP bodies to agent.invoke().
+ *
+ * Routes:
+ *   planner       → PlannerAgent
+ *   config        → ConfigValidationAgent
+ *   decomposer    → DecomposerAgent
+ *   clarifier     → ObjectiveClarifierAgent
+ *   intent        → IntentClassifierAgent
+ *   reflection    → ReflectionAgent
+ *   meta-reasoner → MetaReasonerAgent
+ */
+
+import { v4 as uuidv4 } from 'uuid';
+import { AgentResult, PipelineContext, PipelineContextSchema } from '../../services/agents/contracts';
+
+// Agent imports
+import { PlannerAgent } from '../../services/agents/planner';
+import { ConfigValidationAgent } from '../../services/agents/config-validation';
+import { DecomposerAgent } from '../../services/agents/decomposer';
+import { ObjectiveClarifierAgent } from '../../services/agents/objective-clarifier';
+import { IntentClassifierAgent } from '../../services/agents/intent-classifier';
+import { ReflectionAgent } from '../../services/agents/reflection';
+import { MetaReasonerAgent } from '../../services/agents/meta-reasoner';
+
+// Each agent uses its own persistence/telemetry module (they have identical APIs
+// but TypeScript treats separate class declarations as distinct types)
+import { createRuvectorFromEnv as createPlannerPersistence } from '../../services/agents/planner/ruvector-persistence';
+import { createTelemetryFromEnv as createPlannerTelemetry } from '../../services/agents/planner/telemetry';
+import { createRuvectorFromEnv as createClarifierPersistence } from '../../services/agents/objective-clarifier/ruvector-persistence';
+import { createTelemetryFromEnv as createClarifierTelemetry } from '../../services/agents/objective-clarifier/telemetry';
+import { createRuvectorFromEnv as createReflectionPersistence } from '../../services/agents/reflection/ruvector-persistence';
+import { createTelemetryFromEnv as createReflectionTelemetry } from '../../services/agents/reflection/telemetry';
+
+/**
+ * Generic agent interface for routing purposes
+ */
+interface RoutableAgent {
+  validateInput(input: unknown): unknown;
+  invoke(input: any, executionRef: string): Promise<AgentResult>;
+}
+
+/**
+ * Agent factory: instantiate the correct agent for the given slug
+ */
+function createAgent(slug: string): RoutableAgent | null {
+  switch (slug) {
+    case 'planner': {
+      const p = createPlannerPersistence();
+      const t = createPlannerTelemetry();
+      return new PlannerAgent(p, t);
+    }
+    case 'config': {
+      const p = createPlannerPersistence();
+      const t = createPlannerTelemetry();
+      return new ConfigValidationAgent(p, t);
+    }
+    case 'decomposer': {
+      const p = createPlannerPersistence();
+      const t = createPlannerTelemetry();
+      return new DecomposerAgent(p, t);
+    }
+    case 'clarifier': {
+      const p = createClarifierPersistence();
+      const t = createClarifierTelemetry();
+      return new ObjectiveClarifierAgent(p, t);
+    }
+    case 'intent': {
+      // IntentClassifier imports from planner persistence/telemetry
+      const p = createPlannerPersistence();
+      const t = createPlannerTelemetry();
+      return new IntentClassifierAgent(p, t);
+    }
+    case 'reflection': {
+      const p = createReflectionPersistence();
+      const t = createReflectionTelemetry();
+      return new ReflectionAgent(p, t);
+    }
+    case 'meta-reasoner': {
+      // MetaReasoner imports from planner persistence/telemetry
+      const p = createPlannerPersistence();
+      const t = createPlannerTelemetry();
+      return new MetaReasonerAgent(p, t);
+    }
+    default:
+      return null;
+  }
+}
+
+/**
+ * Result of routing a request to an agent.
+ * Includes the AgentResult plus metadata needed for the response envelope.
+ */
+export interface RouteResult {
+  agentResult: AgentResult;
+  agentSlug: string;
+  pipelineContext?: PipelineContext;
+}
+
+/**
+ * Route a request to the appropriate agent
+ *
+ * @param slug - The agent slug from the URL path
+ * @param body - The parsed JSON request body
+ * @returns RouteResult with agent result and metadata
+ * @throws If the slug is unknown
+ */
+export async function routeRequest(slug: string, body: unknown): Promise<RouteResult> {
+  const agent = createAgent(slug);
+
+  if (!agent) {
+    throw new Error(
+      `Unknown agent: "${slug}". Valid agents: planner, config, decomposer, clarifier, intent, reflection, meta-reasoner`
+    );
+  }
+
+  // Extract execution_ref from body or generate one
+  const bodyObj = body as Record<string, unknown>;
+  const executionRef = (typeof bodyObj.execution_ref === 'string' && bodyObj.execution_ref)
+    ? bodyObj.execution_ref
+    : uuidv4();
+
+  // Extract pipeline_context if present (safe parse — don't fail if malformed)
+  let pipelineContext: PipelineContext | undefined;
+  if (bodyObj.pipeline_context !== undefined) {
+    const parsed = PipelineContextSchema.safeParse(bodyObj.pipeline_context);
+    if (parsed.success) {
+      pipelineContext = parsed.data;
+    }
+  }
+
+  // Validate input through the agent's schema
+  const validatedInput = agent.validateInput(body);
+
+  // Invoke the agent
+  const agentResult = await agent.invoke(validatedInput, executionRef);
+
+  return {
+    agentResult,
+    agentSlug: slug,
+    pipelineContext,
+  };
+}

package/dist/bundled-agents/copilot-agents/functions/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "declaration": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "..",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node",
+    "noImplicitAny": false
+  },
+  "include": [
+    "src/**/*.ts",
+    "../services/agents/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts",
+    "**/*.spec.ts",
+    "../services/agents/**/*.test.ts",
+    "../services/agents/**/cli.ts",
+    "../services/agents/intelligence-layer/**"
+  ]
+}