@a5c-ai/krate 5.0.1-staging.660d2b90f → 5.0.1-staging.69cb593ea

package/tests/agent-subagent-controller.test.js

@@ -0,0 +1,201 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createAgentSubagentController, AGENT_SUBAGENT_CONTROLLER_BOUNDARY, createResource } from '../src/index.js';
+
+function makeSubagent(name, specOverrides = {}) {
+  return createResource('AgentSubagent', { name, namespace: 'krate-org-default' }, {
+    organizationRef: 'default',
+    rolePrompt: 'You are a specialized subagent',
+    taskKinds: ['code-review', 'linting'],
+    role: 'reviewer',
+    parentStackRef: 'parent-stack-1',
+    ...specOverrides
+  });
+}
+
+function makeParentStack(name) {
+  return createResource('AgentStack', { name, namespace: 'krate-org-default' }, {
+    organizationRef: 'default',
+    baseAgent: 'claude-code',
+    adapter: 'anthropic',
+    runtimeIdentity: { serviceAccountRef: 'sa-default' }
+  });
+}
+
+// 1. createAgentSubagentController returns controller with validate, dispatch, getToolScope
+test('createAgentSubagentController returns controller with expected methods', () => {
+  const controller = createAgentSubagentController();
+  assert.ok(controller, 'controller should be created');
+  assert.equal(typeof controller.validate, 'function', 'should have validate method');
+  assert.equal(typeof controller.dispatchSubagent, 'function', 'should have dispatchSubagent method');
+  assert.equal(typeof controller.getToolScope, 'function', 'should have getToolScope method');
+});
+
+// 2. validate accepts valid subagent (name, orgRef, parentStackRef, role)
+test('validate accepts valid subagent with name, orgRef, parentStackRef, role', () => {
+  const controller = createAgentSubagentController();
+  const subagent = makeSubagent('valid-sub');
+  const result = controller.validate(subagent);
+  assert.equal(result.valid, true, 'valid subagent should pass validation');
+  assert.equal(result.errors.length, 0, 'should have no errors');
+});
+
+// 3. validate rejects missing name
+test('validate rejects subagent missing metadata.name', () => {
+  const controller = createAgentSubagentController();
+  const subagent = makeSubagent('temp-name');
+  delete subagent.metadata.name;
+  const result = controller.validate(subagent);
+  assert.equal(result.valid, false, 'should be invalid without name');
+  assert.ok(result.errors.some(e => e.includes('name')), 'error should mention name');
+});
+
+// 4. validate rejects missing parentStackRef
+test('validate rejects subagent missing parentStackRef', () => {
+  const controller = createAgentSubagentController();
+  const subagent = makeSubagent('no-parent', { parentStackRef: undefined });
+  const result = controller.validate(subagent);
+  assert.equal(result.valid, false, 'should be invalid without parentStackRef');
+  assert.ok(result.errors.some(e => e.includes('parentStackRef')), 'error should mention parentStackRef');
+});
+
+// 5. validate rejects missing role
+test('validate rejects subagent missing role', () => {
+  const controller = createAgentSubagentController();
+  const subagent = makeSubagent('no-role', { role: undefined });
+  const result = controller.validate(subagent);
+  assert.equal(result.valid, false, 'should be invalid without role');
+  assert.ok(result.errors.some(e => e.includes('role')), 'error should mention role');
+});
+
+// 6. getToolScope returns allowed tools from spec
+test('getToolScope returns allowed tools list from spec.toolScope.allowed', () => {
+  const controller = createAgentSubagentController();
+  const subagent = makeSubagent('tool-sub', {
+    toolScope: { allowed: ['Read', 'Grep', 'Glob'], denied: ['Bash'] }
+  });
+  const scope = controller.getToolScope(subagent);
+  assert.deepEqual(scope.allowed, ['Read', 'Grep', 'Glob']);
+});
+
+// 7. getToolScope returns all tools when no restriction set
+test('getToolScope returns unrestricted scope when no toolScope set', () => {
+  const controller = createAgentSubagentController();
+  const subagent = makeSubagent('open-sub');
+  const scope = controller.getToolScope(subagent);
+  assert.equal(scope.unrestricted, true, 'should be unrestricted when no toolScope set');
+  assert.deepEqual(scope.allowed, [], 'allowed should be empty when unrestricted');
+});
+
+// 8. getDeniedTools returns denied tools list
+test('getDeniedTools returns denied tools from spec.toolScope.denied', () => {
+  const controller = createAgentSubagentController();
+  const subagent = makeSubagent('restricted-sub', {
+    toolScope: { allowed: ['Read'], denied: ['Bash', 'Write'] }
+  });
+  const denied = controller.getDeniedTools(subagent);
+  assert.deepEqual(denied, ['Bash', 'Write'], 'should return denied tools');
+});
+
+// 9. dispatchSubagent creates a dispatch record with parentSessionRef
+test('dispatchSubagent creates dispatch record with parentSessionRef', () => {
+  const controller = createAgentSubagentController();
+  const subagent = makeSubagent('dispatch-sub');
+  const parentStack = makeParentStack('parent-stack-1');
+  const result = controller.dispatchSubagent({
+    subagent,
+    parentSessionRef: 'session-parent-abc',
+    taskKind: 'code-review',
+    namespace: 'krate-org-default',
+    organizationRef: 'default',
+    resources: { AgentStack: [parentStack] }
+  });
+  assert.ok(result.dispatchRecord, 'should return a dispatch record');
+  assert.equal(result.dispatchRecord.spec.parentSessionRef, 'session-parent-abc', 'should record parentSessionRef');
+  assert.ok(result.dispatchRecord.metadata.name, 'dispatch record should have a name');
+  assert.equal(result.error, undefined, 'should have no error');
+});
+
+// 10. dispatchSubagent rejects when parent session not provided
+test('dispatchSubagent rejects when parentSessionRef not provided', () => {
+  const controller = createAgentSubagentController();
+  const subagent = makeSubagent('dispatch-no-parent');
+  const result = controller.dispatchSubagent({
+    subagent,
+    parentSessionRef: undefined,
+    taskKind: 'code-review',
+    namespace: 'krate-org-default',
+    organizationRef: 'default',
+    resources: {}
+  });
+  assert.equal(result.error, true, 'should return error when no parentSessionRef');
+  assert.ok(result.reason.includes('parentSessionRef') || result.message.includes('parentSessionRef'), 'error should mention parentSessionRef');
+});
+
+// 11. getSupervisionConfig returns supervision settings (monitorInterval, maxDuration, autoTerminate)
+test('getSupervisionConfig returns configured supervision settings', () => {
+  const controller = createAgentSubagentController();
+  const subagent = makeSubagent('supervised-sub', {
+    supervision: {
+      monitorInterval: 30,
+      maxDuration: 3600,
+      autoTerminate: true
+    }
+  });
+  const config = controller.getSupervisionConfig(subagent);
+  assert.equal(config.monitorInterval, 30, 'should return monitorInterval');
+  assert.equal(config.maxDuration, 3600, 'should return maxDuration');
+  assert.equal(config.autoTerminate, true, 'should return autoTerminate');
+});
+
+// 12. getSupervisionConfig returns defaults when not configured
+test('getSupervisionConfig returns default supervision settings when not configured', () => {
+  const controller = createAgentSubagentController();
+  const subagent = makeSubagent('default-supervision-sub');
+  const config = controller.getSupervisionConfig(subagent);
+  assert.ok(typeof config.monitorInterval === 'number', 'monitorInterval should be a number');
+  assert.ok(typeof config.maxDuration === 'number', 'maxDuration should be a number');
+  assert.ok(typeof config.autoTerminate === 'boolean', 'autoTerminate should be a boolean');
+});
+
+// 13. validateTaskRouting accepts valid routing (role matches available subagents)
+test('validateTaskRouting accepts routing when role matches available subagent', () => {
+  const controller = createAgentSubagentController();
+  const subagents = [
+    makeSubagent('sub-reviewer', { role: 'reviewer' }),
+    makeSubagent('sub-tester', { role: 'tester' })
+  ];
+  const result = controller.validateTaskRouting({ role: 'reviewer', taskKind: 'code-review', subagents });
+  assert.equal(result.valid, true, 'routing to existing role should be valid');
+  assert.ok(result.matchedSubagent, 'should return the matched subagent');
+  assert.equal(result.matchedSubagent.metadata.name, 'sub-reviewer');
+});
+
+// 14. validateTaskRouting rejects routing to non-existent role
+test('validateTaskRouting rejects routing to non-existent role', () => {
+  const controller = createAgentSubagentController();
+  const subagents = [
+    makeSubagent('sub-reviewer', { role: 'reviewer' })
+  ];
+  const result = controller.validateTaskRouting({ role: 'deployer', taskKind: 'deploy', subagents });
+  assert.equal(result.valid, false, 'routing to non-existent role should be invalid');
+  assert.ok(result.error.includes('deployer') || result.error.includes('role'), 'error should mention the missing role');
+});
+
+// 15. getSubagentStatus returns status from spec (idle, active, completed, failed)
+test('getSubagentStatus returns status from spec.status field', () => {
+  const controller = createAgentSubagentController();
+  const subagent = makeSubagent('active-sub');
+  subagent.status = { phase: 'active', sessionRef: 'session-xyz' };
+  const status = controller.getSubagentStatus(subagent);
+  assert.equal(status.phase, 'active', 'should return the phase from status');
+  assert.equal(status.sessionRef, 'session-xyz', 'should return sessionRef from status');
+});
+
+// 16. BOUNDARY exported with correct role
+test('AGENT_SUBAGENT_CONTROLLER_BOUNDARY is exported with correct role', () => {
+  assert.ok(AGENT_SUBAGENT_CONTROLLER_BOUNDARY, 'BOUNDARY should be exported');
+  assert.equal(AGENT_SUBAGENT_CONTROLLER_BOUNDARY.role, 'agent-subagent-controller', 'role should be agent-subagent-controller');
+  assert.ok(Array.isArray(AGENT_SUBAGENT_CONTROLLER_BOUNDARY.owns), 'owns should be an array');
+  assert.ok(Array.isArray(AGENT_SUBAGENT_CONTROLLER_BOUNDARY.delegatesTo), 'delegatesTo should be an array');
+});

package/tests/agent-transport-binding-controller.test.js

@@ -0,0 +1,294 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  createAgentTransportBindingController,
+  validateAgentTransportBinding,
+  createResource,
+  AGENT_TRANSPORT_BINDING_CONTROLLER_BOUNDARY
+} from '../src/index.js';
+
+// ---------------------------------------------------------------------------
+// Acceptance criteria: Slice 1.2b — Agent Transport Binding Controller
+//
+// An AgentTransportBinding connects an adapter to a specific endpoint.
+// It specifies binding name, adapterRef, connection endpoint, protocol,
+// health status tracking, and a reconnect policy.
+//
+// All tests in this file are expected to FAIL until the controller is
+// implemented and exported from src/index.js.
+// ---------------------------------------------------------------------------
+
+const VALID_PROTOCOLS = ['stdio', 'http', 'websocket', 'unix'];
+
+function makeBinding(name, overrides = {}) {
+  return createResource('AgentTransportBinding', { name, namespace: 'krate-org-default' }, {
+    organizationRef: 'default',
+    adapterRef: 'claude-code-adapter',
+    endpoint: 'http://localhost:8080',
+    protocol: 'http',
+    ...overrides
+  });
+}
+
+// ---------------------------------------------------------------------------
+// 1. Factory and shape
+// ---------------------------------------------------------------------------
+
+test('createAgentTransportBindingController returns a controller with validate method', () => {
+  const controller = createAgentTransportBindingController();
+  assert.ok(controller, 'controller must be truthy');
+  assert.equal(typeof controller.validate, 'function', 'controller must expose a validate method');
+  assert.equal(controller.role, 'agent-transport-binding-controller', 'controller must declare its role');
+});
+
+// ---------------------------------------------------------------------------
+// 2. validate — happy path
+// ---------------------------------------------------------------------------
+
+test('validate accepts valid binding with name, adapterRef, endpoint, protocol', () => {
+  const controller = createAgentTransportBindingController();
+  const binding = makeBinding('my-transport-binding');
+  const result = controller.validate(binding);
+
+  assert.equal(result.valid, true, 'valid binding must pass validation');
+  assert.ok(Array.isArray(result.errors), 'result must contain an errors array');
+  assert.equal(result.errors.length, 0, 'errors array must be empty for a valid binding');
+});
+
+// ---------------------------------------------------------------------------
+// 3. validate — missing name
+// ---------------------------------------------------------------------------
+
+test('validate rejects missing name', () => {
+  const controller = createAgentTransportBindingController();
+  const binding = {
+    apiVersion: 'krate.a5c.ai/v1alpha1',
+    kind: 'AgentTransportBinding',
+    metadata: { namespace: 'krate-org-default', labels: {}, annotations: {} },
+    spec: {
+      organizationRef: 'default',
+      adapterRef: 'claude-code-adapter',
+      endpoint: 'http://localhost:8080',
+      protocol: 'http'
+    },
+    status: {}
+  };
+  const result = controller.validate(binding);
+
+  assert.equal(result.valid, false, 'binding without name must fail validation');
+  assert.ok(result.errors.length > 0, 'errors array must not be empty');
+  assert.ok(
+    result.errors.some((e) => /name/i.test(e)),
+    'at least one error must mention "name"'
+  );
+});
+
+// ---------------------------------------------------------------------------
+// 4. validate — missing adapterRef
+// ---------------------------------------------------------------------------
+
+test('validate rejects missing adapterRef', () => {
+  const controller = createAgentTransportBindingController();
+  const binding = makeBinding('no-adapter-binding');
+  delete binding.spec.adapterRef;
+  const result = controller.validate(binding);
+
+  assert.equal(result.valid, false, 'binding without adapterRef must fail validation');
+  assert.ok(result.errors.length > 0, 'errors array must not be empty');
+  assert.ok(
+    result.errors.some((e) => /adapterRef/i.test(e)),
+    'at least one error must mention "adapterRef"'
+  );
+});
+
+// ---------------------------------------------------------------------------
+// 5. validate — missing endpoint
+// ---------------------------------------------------------------------------
+
+test('validate rejects missing endpoint', () => {
+  const controller = createAgentTransportBindingController();
+  const binding = makeBinding('no-endpoint-binding');
+  delete binding.spec.endpoint;
+  const result = controller.validate(binding);
+
+  assert.equal(result.valid, false, 'binding without endpoint must fail validation');
+  assert.ok(result.errors.length > 0, 'errors array must not be empty');
+  assert.ok(
+    result.errors.some((e) => /endpoint/i.test(e)),
+    'at least one error must mention "endpoint"'
+  );
+});
+
+// ---------------------------------------------------------------------------
+// 6. validate — invalid protocol
+// ---------------------------------------------------------------------------
+
+test('validate rejects invalid protocol (not in stdio/http/websocket/unix)', () => {
+  const controller = createAgentTransportBindingController();
+  const binding = makeBinding('bad-protocol-binding', { protocol: 'grpc' });
+  const result = controller.validate(binding);
+
+  assert.equal(result.valid, false, 'binding with unsupported protocol must fail validation');
+  assert.ok(result.errors.length > 0, 'errors array must not be empty');
+  assert.ok(
+    result.errors.some((e) => /protocol/i.test(e)),
+    'at least one error must mention "protocol"'
+  );
+  assert.ok(
+    result.errors.some((e) => VALID_PROTOCOLS.some((p) => e.includes(p))),
+    'error must enumerate valid protocols'
+  );
+});
+
+// ---------------------------------------------------------------------------
+// 7. getConnectionStatus — default 'unknown' for new binding
+// ---------------------------------------------------------------------------
+
+test('getConnectionStatus returns default "unknown" for new binding', () => {
+  const controller = createAgentTransportBindingController();
+  const binding = makeBinding('new-binding');
+  const status = controller.getConnectionStatus(binding);
+
+  assert.ok(status, 'getConnectionStatus must return a value');
+  assert.equal(status.connectionStatus, 'unknown', 'default connection status must be "unknown"');
+  assert.equal(status.bindingName, binding.metadata.name, 'result must carry the binding name');
+});
+
+// ---------------------------------------------------------------------------
+// 8. getReconnectPolicy — returns policy from spec with defaults
+// ---------------------------------------------------------------------------
+
+test('getReconnectPolicy returns policy from spec with defaults', () => {
+  const controller = createAgentTransportBindingController();
+  const binding = makeBinding('policy-binding', {
+    reconnectPolicy: {
+      maxRetries: 5,
+      backoffMs: 500,
+      maxBackoffMs: 30000
+    }
+  });
+  const policy = controller.getReconnectPolicy(binding);
+
+  assert.ok(policy, 'getReconnectPolicy must return a value');
+  assert.equal(policy.maxRetries, 5, 'maxRetries must match spec');
+  assert.equal(policy.backoffMs, 500, 'backoffMs must match spec');
+  assert.equal(policy.maxBackoffMs, 30000, 'maxBackoffMs must match spec');
+});
+
+// ---------------------------------------------------------------------------
+// 9. getReconnectPolicy — returns defaults when no policy in spec
+// ---------------------------------------------------------------------------
+
+test('getReconnectPolicy returns defaults when no policy in spec', () => {
+  const controller = createAgentTransportBindingController();
+  const binding = makeBinding('no-policy-binding');
+  // no reconnectPolicy in spec
+  const policy = controller.getReconnectPolicy(binding);
+
+  assert.ok(policy, 'getReconnectPolicy must return a value');
+  assert.ok(typeof policy.maxRetries === 'number', 'maxRetries must default to a number');
+  assert.ok(typeof policy.backoffMs === 'number', 'backoffMs must default to a number');
+  assert.ok(typeof policy.maxBackoffMs === 'number', 'maxBackoffMs must default to a number');
+  assert.ok(policy.maxRetries >= 0, 'maxRetries default must be non-negative');
+  assert.ok(policy.backoffMs >= 0, 'backoffMs default must be non-negative');
+  assert.ok(policy.maxBackoffMs >= policy.backoffMs, 'maxBackoffMs must be >= backoffMs');
+});
+
+// ---------------------------------------------------------------------------
+// 10. validate — rejects null resource
+// ---------------------------------------------------------------------------
+
+test('validate rejects null resource', () => {
+  const controller = createAgentTransportBindingController();
+  const result = controller.validate(null);
+
+  assert.equal(result.valid, false, 'null resource must fail validation');
+  assert.ok(result.errors.length > 0, 'errors array must not be empty');
+  assert.ok(
+    result.errors.some((e) => /null|undefined/i.test(e)),
+    'error must mention null or undefined'
+  );
+});
+
+// ---------------------------------------------------------------------------
+// 11. BOUNDARY object exported with correct role
+// ---------------------------------------------------------------------------
+
+test('AGENT_TRANSPORT_BINDING_CONTROLLER_BOUNDARY is exported and has correct role', () => {
+  assert.ok(AGENT_TRANSPORT_BINDING_CONTROLLER_BOUNDARY, 'BOUNDARY must be exported');
+  assert.equal(
+    AGENT_TRANSPORT_BINDING_CONTROLLER_BOUNDARY.role,
+    'agent-transport-binding-controller',
+    'BOUNDARY role must be "agent-transport-binding-controller"'
+  );
+  assert.ok(
+    Array.isArray(AGENT_TRANSPORT_BINDING_CONTROLLER_BOUNDARY.owns),
+    'BOUNDARY must declare owned concerns'
+  );
+});
+
+// ---------------------------------------------------------------------------
+// 12. validate — all valid protocols are accepted
+// ---------------------------------------------------------------------------
+
+test('validate accepts each valid protocol (stdio, http, websocket, unix)', () => {
+  const controller = createAgentTransportBindingController();
+  for (const protocol of VALID_PROTOCOLS) {
+    const binding = makeBinding(`binding-${protocol}`, { protocol });
+    const result = controller.validate(binding);
+    assert.equal(result.valid, true, `protocol "${protocol}" must be accepted`);
+    assert.equal(result.errors.length, 0, `no errors expected for protocol "${protocol}"`);
+  }
+});
+
+// ---------------------------------------------------------------------------
+// 13. getConnectionStatus — reads from status.connectionStatus when present
+// ---------------------------------------------------------------------------
+
+test('getConnectionStatus reads connectionStatus from resource status field when present', () => {
+  const controller = createAgentTransportBindingController();
+  const binding = makeBinding('connected-binding');
+  binding.status = { connectionStatus: 'connected' };
+  const status = controller.getConnectionStatus(binding);
+
+  assert.equal(status.connectionStatus, 'connected', 'must reflect status from resource status field');
+});
+
+// ---------------------------------------------------------------------------
+// 14. validate accumulates errors for multiple missing fields
+// ---------------------------------------------------------------------------
+
+test('validate accumulates errors when both adapterRef and endpoint are missing', () => {
+  const controller = createAgentTransportBindingController();
+  const binding = makeBinding('double-missing-binding');
+  delete binding.spec.adapterRef;
+  delete binding.spec.endpoint;
+  const result = controller.validate(binding);
+
+  assert.equal(result.valid, false, 'binding with multiple missing fields must fail validation');
+  assert.ok(
+    result.errors.some((e) => /adapterRef/i.test(e)),
+    'errors must include adapterRef error'
+  );
+  assert.ok(
+    result.errors.some((e) => /endpoint/i.test(e)),
+    'errors must include endpoint error'
+  );
+  assert.ok(result.errors.length >= 2, 'must accumulate at least two errors');
+});
+
+// ---------------------------------------------------------------------------
+// 15. validateAgentTransportBinding standalone export
+// ---------------------------------------------------------------------------
+
+test('validateAgentTransportBinding is exported and validates correctly', () => {
+  assert.equal(typeof validateAgentTransportBinding, 'function', 'validateAgentTransportBinding must be a named export');
+
+  const binding = makeBinding('standalone-validate-binding');
+  const result = validateAgentTransportBinding(binding);
+
+  assert.ok(result, 'validateAgentTransportBinding must return a result');
+  assert.ok('valid' in result, 'result must have a valid property');
+  assert.ok(Array.isArray(result.errors), 'result must have an errors array');
+  assert.equal(result.valid, true, 'a fully-specified binding must pass standalone validation');
+});