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

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

@@ -0,0 +1,40 @@
+{
+  "name": "copilot-agents",
+  "version": "1.0.0",
+  "description": "Cloud Function entry point for all 7 copilot agents",
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc",
+    "gcp-build": "",
+    "start": "functions-framework --target=handler --source=.",
+    "dev": "ts-node src/index.ts",
+    "test": "jest --config jest.config.js",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "predeploy": "npm run clean && npm run build"
+  },
+  "keywords": [
+    "agentics",
+    "cloud-function",
+    "copilot-agents"
+  ],
+  "author": "Agentics",
+  "license": "MIT",
+  "dependencies": {
+    "@google-cloud/functions-framework": "^5.0.2",
+    "uuid": "^9.0.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.0.0",
+    "@types/node": "^20.0.0",
+    "@types/uuid": "^9.0.0",
+    "jest": "^29.0.0",
+    "ts-jest": "^29.0.0",
+    "ts-node": "^10.9.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callClaude = callClaude;
+exports.extractJson = extractJson;
+
+const { execFileSync } = require("child_process");
+
+function findClaudeBinary() {
+  for (const name of ["claude", "claude-code"]) {
+    try {
+      const result = execFileSync("which", [name], { encoding: "utf-8", timeout: 5000 }).trim();
+      if (result) return result;
+    } catch {}
+  }
+  throw new Error("Claude Code binary not found. Install: npm i -g @anthropic-ai/claude-code");
+}
+
+let _binary = null;
+function getBinary() {
+  if (!_binary) _binary = findClaudeBinary();
+  return _binary;
+}
+
+async function callClaude(apiKey, systemPrompt, userMessage) {
+  const binary = getBinary();
+  const prompt = systemPrompt + "\n\n" + userMessage;
+  const env = Object.assign({}, process.env, { CI: "1" });
+  // Use short timeout when called from a child process (to avoid blocking the
+  // child's event loop for 120s). The parent will kill us anyway at timeoutMs.
+  const timeoutMs = process.env.AGENTICS_CHILD_PROCESS ? 8000 : 120000;
+  delete env.CLAUDECODE;
+  delete env.AGENTICS_DEV;
+
+  const raw = execFileSync(binary, [
+    "--print", "--output-format", "json", "--model", "claude-sonnet-4-20250514", prompt
+  ], {
+    encoding: "utf-8",
+    timeout: timeoutMs,
+    stdio: ["pipe", "pipe", "pipe"],
+    env: env,
+    maxBuffer: 10 * 1024 * 1024,
+  });
+
+  // Unwrap claude --output-format json envelope
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed.type === "result" && typeof parsed.result === "string") {
+      return parsed.result;
+    }
+    return raw;
+  } catch {
+    return raw;
+  }
+}
+
+function extractJson(text) {
+  const fenceMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (fenceMatch) return JSON.parse(fenceMatch[1].trim());
+  const startIdx = text.search(/[{[]/);
+  if (startIdx >= 0) {
+    const startChar = text[startIdx];
+    const endChar = startChar === "{" ? "}" : "]";
+    let depth = 0;
+    for (let i = startIdx; i < text.length; i++) {
+      if (text[i] === startChar) depth++;
+      else if (text[i] === endChar) depth--;
+      if (depth === 0) return JSON.parse(text.slice(startIdx, i + 1));
+    }
+  }
+  return JSON.parse(text.trim());
+}

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

@@ -0,0 +1,36 @@
+/**
+ * CORS Middleware for Cloud Functions
+ *
+ * Handles preflight requests and sets CORS headers on all responses.
+ */
+
+import { CfResponse } from './index';
+
+const ALLOWED_ORIGINS = [
+  'https://agentics.dev',
+  'https://console.agentics.dev',
+  'https://us-central1-agentics-dev.cloudfunctions.net',
+];
+
+const ALLOWED_METHODS = 'GET, POST, OPTIONS';
+const ALLOWED_HEADERS = 'Content-Type, Authorization, X-Correlation-Id, X-Request-Id';
+const MAX_AGE = '3600';
+
+/**
+ * Set CORS headers on the response
+ */
+export function setCorsHeaders(res: CfResponse): void {
+  // Allow any origin for now (can be restricted via ALLOWED_ORIGINS in production)
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', ALLOWED_METHODS);
+  res.setHeader('Access-Control-Allow-Headers', ALLOWED_HEADERS);
+  res.setHeader('Access-Control-Max-Age', MAX_AGE);
+}
+
+/**
+ * Handle CORS preflight (OPTIONS) request
+ */
+export function handlePreflight(res: CfResponse): void {
+  res.writeHead(204);
+  res.end();
+}

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

@@ -0,0 +1,77 @@
+/**
+ * Response Envelope
+ *
+ * Every response from copilot-agents MUST include:
+ * - execution_metadata (trace_id, timestamp, service, execution_id)
+ * - layers_executed (routing + agent layer with status and duration)
+ *
+ * Agent responses additionally include per-agent execution_metadata inside
+ * the `result` wrapper (trace_id, agent, domain, timestamp, pipeline_context).
+ */
+
+import { PipelineContext } from '../../services/agents/contracts';
+
+export interface ExecutionMetadata {
+  trace_id: string;
+  timestamp: string;
+  service: 'copilot-agents';
+  execution_id: string;
+}
+
+export interface LayerExecuted {
+  layer: string;
+  status: 'completed' | 'error';
+  duration_ms?: number;
+}
+
+/**
+ * Per-agent execution metadata included in the result wrapper
+ * when routing to an agent.
+ */
+export interface AgentExecutionMetadata {
+  trace_id: string;
+  agent: string;
+  domain: string;
+  timestamp: string;
+  pipeline_context?: PipelineContext;
+}
+
+export interface EnvelopedResponse {
+  data: unknown;
+  execution_metadata: ExecutionMetadata;
+  layers_executed: LayerExecuted[];
+}
+
+/**
+ * Wrap any response payload with execution_metadata and layers_executed
+ */
+export function wrapResponse(
+  data: unknown,
+  executionMetadata: ExecutionMetadata,
+  layersExecuted: LayerExecuted[]
+): EnvelopedResponse {
+  return {
+    data,
+    execution_metadata: executionMetadata,
+    layers_executed: layersExecuted,
+  };
+}
+
+/**
+ * Wrap an agent result with per-agent execution_metadata.
+ *
+ * Produces:
+ * {
+ *   result: <agentResult>,
+ *   execution_metadata: { trace_id, agent, domain, timestamp, pipeline_context? }
+ * }
+ */
+export function wrapAgentResult(
+  agentResult: unknown,
+  agentMeta: AgentExecutionMetadata
+): { result: unknown; execution_metadata: AgentExecutionMetadata } {
+  return {
+    result: agentResult,
+    execution_metadata: agentMeta,
+  };
+}

package/dist/bundled-agents/copilot-agents/functions/src/handler.test.ts

@@ -0,0 +1,340 @@
+/**
+ * Cloud Function Handler Tests
+ *
+ * Tests for the copilot-agents Cloud Function entry point.
+ * Validates routing, CORS, health, execution_metadata, and layers_executed.
+ */
+
+import { handler, CfRequest, CfResponse } from './index';
+import { IncomingMessage, ServerResponse } from 'http';
+
+// Helper to create mock request
+function mockRequest(method: string, url: string, body?: unknown, headers?: Record<string, string>): CfRequest {
+  const req = {
+    method,
+    url,
+    headers: { host: 'localhost', ...headers },
+    body,
+  } as CfRequest;
+  return req;
+}
+
+// Helper to create mock response and capture output
+function mockResponse(): { res: CfResponse; getResult: () => { statusCode: number; headers: Record<string, string>; body: unknown } } {
+  const result = {
+    statusCode: 200,
+    headers: {} as Record<string, string>,
+    body: null as unknown,
+    ended: false,
+  };
+
+  const res = {
+    writeHead(code: number, headers?: Record<string, string>) {
+      result.statusCode = code;
+      if (headers) {
+        Object.assign(result.headers, headers);
+      }
+      return this;
+    },
+    setHeader(key: string, value: string) {
+      result.headers[key] = value;
+      return this;
+    },
+    end(data?: string) {
+      result.ended = true;
+      if (data) {
+        try {
+          result.body = JSON.parse(data);
+        } catch {
+          result.body = data;
+        }
+      }
+    },
+  } as unknown as CfResponse;
+
+  return {
+    res,
+    getResult: () => ({ statusCode: result.statusCode, headers: result.headers, body: result.body }),
+  };
+}
+
+describe('Cloud Function Handler', () => {
+  describe('CORS', () => {
+    it('should set CORS headers on all responses', async () => {
+      const req = mockRequest('GET', '/health');
+      const { res, getResult } = mockResponse();
+
+      await handler(req, res);
+      const result = getResult();
+
+      expect(result.headers['Access-Control-Allow-Origin']).toBe('*');
+      expect(result.headers['Access-Control-Allow-Methods']).toContain('POST');
+      expect(result.headers['Access-Control-Allow-Headers']).toContain('X-Correlation-Id');
+    });
+
+    it('should handle OPTIONS preflight with 204', async () => {
+      const req = mockRequest('OPTIONS', '/v1/copilot/planner');
+      const { res, getResult } = mockResponse();
+
+      await handler(req, res);
+      const result = getResult();
+
+      expect(result.statusCode).toBe(204);
+    });
+  });
+
+  describe('Health Endpoint', () => {
+    it('should return health status with all 7 agents', async () => {
+      const req = mockRequest('GET', '/health');
+      const { res, getResult } = mockResponse();
+
+      await handler(req, res);
+      const result = getResult();
+
+      expect(result.statusCode).toBe(200);
+      const body = result.body as {
+        data: { status: string; agents: Array<{ agent: string }> };
+        execution_metadata: { service: string; trace_id: string };
+        layers_executed: Array<{ layer: string }>;
+      };
+
+      expect(body.data.status).toBe('healthy');
+      expect(body.data.agents).toHaveLength(7);
+
+      const agentNames = body.data.agents.map(a => a.agent);
+      expect(agentNames).toContain('planner');
+      expect(agentNames).toContain('config');
+      expect(agentNames).toContain('decomposer');
+      expect(agentNames).toContain('clarifier');
+      expect(agentNames).toContain('intent');
+      expect(agentNames).toContain('reflection');
+      expect(agentNames).toContain('meta-reasoner');
+    });
+
+    it('should include execution_metadata in health response', async () => {
+      const req = mockRequest('GET', '/health');
+      const { res, getResult } = mockResponse();
+
+      await handler(req, res);
+      const body = getResult().body as {
+        execution_metadata: { service: string; trace_id: string; execution_id: string; timestamp: string };
+      };
+
+      expect(body.execution_metadata.service).toBe('copilot-agents');
+      expect(body.execution_metadata.trace_id).toBeDefined();
+      expect(body.execution_metadata.execution_id).toBeDefined();
+      expect(body.execution_metadata.timestamp).toBeDefined();
+    });
+
+    it('should include layers_executed in health response', async () => {
+      const req = mockRequest('GET', '/health');
+      const { res, getResult } = mockResponse();
+
+      await handler(req, res);
+      const body = getResult().body as {
+        layers_executed: Array<{ layer: string; status: string }>;
+      };
+
+      expect(body.layers_executed).toHaveLength(2);
+      expect(body.layers_executed[0].layer).toBe('AGENT_ROUTING');
+      expect(body.layers_executed[1].layer).toBe('HEALTH_CHECK');
+    });
+  });
+
+  describe('Execution Metadata', () => {
+    it('should use x-correlation-id header as trace_id', async () => {
+      const traceId = '12345-abcde-67890';
+      const req = mockRequest('GET', '/health', undefined, { 'x-correlation-id': traceId });
+      const { res, getResult } = mockResponse();
+
+      await handler(req, res);
+      const body = getResult().body as {
+        execution_metadata: { trace_id: string };
+      };
+
+      expect(body.execution_metadata.trace_id).toBe(traceId);
+    });
+
+    it('should generate trace_id if x-correlation-id not provided', async () => {
+      const req = mockRequest('GET', '/health');
+      const { res, getResult } = mockResponse();
+
+      await handler(req, res);
+      const body = getResult().body as {
+        execution_metadata: { trace_id: string };
+      };
+
+      expect(body.execution_metadata.trace_id).toBeDefined();
+      expect(body.execution_metadata.trace_id.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Agent Routing', () => {
+    it('should return 400 for POST without body', async () => {
+      const req = mockRequest('POST', '/v1/copilot/planner');
+      const { res, getResult } = mockResponse();
+
+      await handler(req, res);
+      const result = getResult();
+
+      expect(result.statusCode).toBe(400);
+    });
+
+    it('should return 404 for unknown routes', async () => {
+      const req = mockRequest('GET', '/unknown');
+      const { res, getResult } = mockResponse();
+
+      await handler(req, res);
+      const result = getResult();
+
+      expect(result.statusCode).toBe(404);
+      const body = result.body as { data: { available_routes: string[] } };
+      expect(body.data.available_routes).toHaveLength(8);
+    });
+
+    it('should include layers_executed on error responses', async () => {
+      const req = mockRequest('GET', '/not-found');
+      const { res, getResult } = mockResponse();
+
+      await handler(req, res);
+      const body = getResult().body as {
+        layers_executed: Array<{ layer: string; status: string }>;
+        execution_metadata: { service: string };
+      };
+
+      expect(body.layers_executed).toBeDefined();
+      expect(body.execution_metadata.service).toBe('copilot-agents');
+    });
+
+    it('should route POST /v1/copilot/planner to PlannerAgent', async () => {
+      const req = mockRequest('POST', '/v1/copilot/planner', {
+        objective: 'Build a test system',
+      });
+      const { res, getResult } = mockResponse();
+
+      await handler(req, res);
+      const result = getResult();
+
+      // Should succeed (200) or validation error (422) but NOT 404
+      expect([200, 422, 500]).toContain(result.statusCode);
+      const body = result.body as {
+        execution_metadata: { service: string };
+        layers_executed: Array<{ layer: string }>;
+      };
+      expect(body.execution_metadata.service).toBe('copilot-agents');
+      expect(body.layers_executed.some(l => l.layer === 'COPILOT_PLANNER')).toBe(true);
+    });
+
+    it('should route POST /v1/copilot/intent to IntentClassifierAgent', async () => {
+      const req = mockRequest('POST', '/v1/copilot/intent', {
+        text: 'Create a new user',
+      });
+      const { res, getResult } = mockResponse();
+
+      await handler(req, res);
+      const result = getResult();
+
+      expect([200, 422, 500]).toContain(result.statusCode);
+      const body = result.body as {
+        layers_executed: Array<{ layer: string }>;
+      };
+      expect(body.layers_executed.some(l => l.layer === 'COPILOT_INTENT')).toBe(true);
+    });
+
+    it('should route POST /v1/copilot/decomposer to DecomposerAgent', async () => {
+      const req = mockRequest('POST', '/v1/copilot/decomposer', {
+        objective: 'Build and deploy a microservice',
+      });
+      const { res, getResult } = mockResponse();
+
+      await handler(req, res);
+      const result = getResult();
+
+      expect([200, 422, 500]).toContain(result.statusCode);
+      const body = result.body as {
+        layers_executed: Array<{ layer: string }>;
+      };
+      expect(body.layers_executed.some(l => l.layer === 'COPILOT_DECOMPOSER')).toBe(true);
+    });
+  });
+
+  describe('Pipeline Context', () => {
+    it('should include per-agent execution_metadata in agent response', async () => {
+      const req = mockRequest('POST', '/v1/copilot/intent', {
+        text: 'Create a new user',
+      });
+      const { res, getResult } = mockResponse();
+
+      await handler(req, res);
+      const result = getResult();
+
+      expect([200, 422, 500]).toContain(result.statusCode);
+      const body = result.body as {
+        data: {
+          result: unknown;
+          execution_metadata: { trace_id: string; agent: string; domain: string; timestamp: string };
+        };
+      };
+      // Agent response should be wrapped with result + execution_metadata
+      expect(body.data.execution_metadata).toBeDefined();
+      expect(body.data.execution_metadata.agent).toBe('intent');
+      expect(body.data.execution_metadata.domain).toBe('copilot');
+      expect(body.data.execution_metadata.trace_id).toBeDefined();
+      expect(body.data.execution_metadata.timestamp).toBeDefined();
+    });
+
+    it('should echo pipeline_context in agent execution_metadata when provided', async () => {
+      const pipelineContext = {
+        plan_id: 'test-plan-123',
+        step_id: '2',
+        previous_steps: [
+          { step_id: '1', domain: 'copilot', agent: 'decomposer', output: {} }
+        ],
+        execution_metadata: {
+          trace_id: 'trace-abc',
+          initiated_by: 'orchestrator-agents',
+        },
+      };
+      const req = mockRequest('POST', '/v1/copilot/intent', {
+        text: 'Create a new user',
+        pipeline_context: pipelineContext,
+      });
+      const { res, getResult } = mockResponse();
+
+      await handler(req, res);
+      const result = getResult();
+
+      expect([200, 422, 500]).toContain(result.statusCode);
+      const body = result.body as {
+        data: {
+          execution_metadata: {
+            pipeline_context?: { plan_id: string; step_id: string };
+          };
+        };
+      };
+      expect(body.data.execution_metadata.pipeline_context).toBeDefined();
+      expect(body.data.execution_metadata.pipeline_context?.plan_id).toBe('test-plan-123');
+      expect(body.data.execution_metadata.pipeline_context?.step_id).toBe('2');
+    });
+
+    it('should NOT include pipeline_context when not provided (backwards compatible)', async () => {
+      const req = mockRequest('POST', '/v1/copilot/intent', {
+        text: 'Create a new user',
+      });
+      const { res, getResult } = mockResponse();
+
+      await handler(req, res);
+      const result = getResult();
+
+      expect([200, 422, 500]).toContain(result.statusCode);
+      const body = result.body as {
+        data: {
+          execution_metadata: {
+            pipeline_context?: unknown;
+          };
+        };
+      };
+      expect(body.data.execution_metadata.pipeline_context).toBeUndefined();
+    });
+  });
+});

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

@@ -0,0 +1,53 @@
+/**
+ * Health Check Handler
+ *
+ * Returns the status of all 7 copilot agents.
+ * Agents: planner, config, decomposer, clarifier, intent, reflection, meta-reasoner
+ */
+
+export interface AgentHealthStatus {
+  agent: string;
+  status: 'healthy' | 'degraded' | 'unhealthy';
+  version: string;
+}
+
+export interface HealthResponse {
+  status: 'healthy' | 'degraded' | 'unhealthy';
+  service: string;
+  version: string;
+  agents: AgentHealthStatus[];
+  uptime_seconds: number;
+}
+
+const SERVICE_START_TIME = Date.now();
+
+const AGENT_REGISTRY: Array<{ name: string; version: string }> = [
+  { name: 'planner', version: '1.0.0' },
+  { name: 'config', version: '1.0.0' },
+  { name: 'decomposer', version: '1.0.0' },
+  { name: 'clarifier', version: '1.0.0' },
+  { name: 'intent', version: '1.0.0' },
+  { name: 'reflection', version: '1.0.0' },
+  { name: 'meta-reasoner', version: '1.0.0' },
+];
+
+/**
+ * Build health check response for all agents
+ */
+export function handleHealth(): HealthResponse {
+  const agents: AgentHealthStatus[] = AGENT_REGISTRY.map(agent => ({
+    agent: agent.name,
+    status: 'healthy' as const,
+    version: agent.version,
+  }));
+
+  const allHealthy = agents.every(a => a.status === 'healthy');
+
+  return {
+    status: allHealthy ? 'healthy' : 'degraded',
+    service: 'copilot-agents',
+    version: '1.0.0',
+    agents,
+    uptime_seconds: Math.floor((Date.now() - SERVICE_START_TIME) / 1000),
+  };
+}