@the-open-engine/zeroshot 6.17.0 → 6.19.0

package/lib/cluster/payload-value.cjs

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstInputValidationIssue = firstInputValidationIssue;
+exports.assertInputValue = assertInputValue;
+const errors_js_1 = require("./errors.cjs");
+function isJsonInteger(value) {
+    return typeof value === 'number' && Number.isFinite(value) && Number.isInteger(value);
+}
+function evaluate(type, value, path) {
+    switch (type.kind) {
+        case 'null':
+            return value === null ? null : { path, code: 'TYPE_MISMATCH', expectedKind: 'null' };
+        case 'boolean':
+            return typeof value === 'boolean' ? null : { path, code: 'TYPE_MISMATCH', expectedKind: 'boolean' };
+        case 'integer':
+            return isJsonInteger(value) ? null : { path, code: 'TYPE_MISMATCH', expectedKind: 'integer' };
+        case 'number':
+            return typeof value === 'number' && Number.isFinite(value)
+                ? null
+                : { path, code: 'TYPE_MISMATCH', expectedKind: 'number' };
+        case 'string':
+            return typeof value === 'string' ? null : { path, code: 'TYPE_MISMATCH', expectedKind: 'string' };
+        case 'enum':
+            if (typeof value !== 'string')
+                return { path, code: 'TYPE_MISMATCH', expectedKind: 'enum' };
+            return type.values.includes(value)
+                ? null
+                : { path, code: 'UNKNOWN_ENUM_LABEL', expectedKind: 'enum' };
+        case 'array': {
+            if (!Array.isArray(value))
+                return { path, code: 'TYPE_MISMATCH', expectedKind: 'array' };
+            for (let index = 0; index < value.length; index += 1) {
+                const issue = evaluate(type.items, value[index], `${path}/${index}`);
+                if (issue)
+                    return issue;
+            }
+            return null;
+        }
+        case 'record': {
+            if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+                return { path, code: 'TYPE_MISMATCH', expectedKind: 'record' };
+            }
+            const record = value;
+            const fieldNames = Object.keys(type.fields).sort();
+            for (const name of fieldNames) {
+                const field = type.fields[name];
+                if (!field)
+                    continue;
+                const fieldPath = `${path}/${name}`;
+                if (Object.prototype.hasOwnProperty.call(record, name)) {
+                    const issue = evaluate(field.type, record[name], fieldPath);
+                    if (issue)
+                        return issue;
+                }
+                else if (field.required) {
+                    return { path: fieldPath, code: 'MISSING_REQUIRED_FIELD', expectedKind: field.type.kind };
+                }
+            }
+            const declared = new Set(fieldNames);
+            const unknownField = Object.keys(record).sort().find((name) => !declared.has(name));
+            return unknownField
+                ? { path: `${path}/${unknownField}`, code: 'UNKNOWN_FIELD', expectedKind: 'record' }
+                : null;
+        }
+    }
+}
+function firstInputValidationIssue(type, value, path = '') {
+    const issue = evaluate(type, value, path);
+    return issue ? { path: issue.path, code: issue.code } : null;
+}
+function assertInputValue(type, value) {
+    const issue = evaluate(type, value, '');
+    if (!issue)
+        return;
+    throw new errors_js_1.ClusterRequestError(`input value at '${issue.path || '/'}' failed validation: ${issue.code}, expected ${issue.expectedKind}`, 'INVALID_INPUT');
+}

package/lib/cluster/payload-value.d.ts

@@ -0,0 +1,7 @@
+import type { PayloadType } from './generated/protocol.js';
+export type InputValidationIssue = {
+    readonly path: string;
+    readonly code: 'TYPE_MISMATCH' | 'MISSING_REQUIRED_FIELD' | 'UNKNOWN_FIELD' | 'UNKNOWN_ENUM_LABEL';
+};
+export declare function firstInputValidationIssue(type: PayloadType, value: unknown, path?: string): InputValidationIssue | null;
+export declare function assertInputValue(type: PayloadType, value: unknown): void;

package/lib/cluster/payload-value.mjs

@@ -0,0 +1,72 @@
+import { ClusterRequestError } from './errors.mjs';
+function isJsonInteger(value) {
+    return typeof value === 'number' && Number.isFinite(value) && Number.isInteger(value);
+}
+function evaluate(type, value, path) {
+    switch (type.kind) {
+        case 'null':
+            return value === null ? null : { path, code: 'TYPE_MISMATCH', expectedKind: 'null' };
+        case 'boolean':
+            return typeof value === 'boolean' ? null : { path, code: 'TYPE_MISMATCH', expectedKind: 'boolean' };
+        case 'integer':
+            return isJsonInteger(value) ? null : { path, code: 'TYPE_MISMATCH', expectedKind: 'integer' };
+        case 'number':
+            return typeof value === 'number' && Number.isFinite(value)
+                ? null
+                : { path, code: 'TYPE_MISMATCH', expectedKind: 'number' };
+        case 'string':
+            return typeof value === 'string' ? null : { path, code: 'TYPE_MISMATCH', expectedKind: 'string' };
+        case 'enum':
+            if (typeof value !== 'string')
+                return { path, code: 'TYPE_MISMATCH', expectedKind: 'enum' };
+            return type.values.includes(value)
+                ? null
+                : { path, code: 'UNKNOWN_ENUM_LABEL', expectedKind: 'enum' };
+        case 'array': {
+            if (!Array.isArray(value))
+                return { path, code: 'TYPE_MISMATCH', expectedKind: 'array' };
+            for (let index = 0; index < value.length; index += 1) {
+                const issue = evaluate(type.items, value[index], `${path}/${index}`);
+                if (issue)
+                    return issue;
+            }
+            return null;
+        }
+        case 'record': {
+            if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+                return { path, code: 'TYPE_MISMATCH', expectedKind: 'record' };
+            }
+            const record = value;
+            const fieldNames = Object.keys(type.fields).sort();
+            for (const name of fieldNames) {
+                const field = type.fields[name];
+                if (!field)
+                    continue;
+                const fieldPath = `${path}/${name}`;
+                if (Object.prototype.hasOwnProperty.call(record, name)) {
+                    const issue = evaluate(field.type, record[name], fieldPath);
+                    if (issue)
+                        return issue;
+                }
+                else if (field.required) {
+                    return { path: fieldPath, code: 'MISSING_REQUIRED_FIELD', expectedKind: field.type.kind };
+                }
+            }
+            const declared = new Set(fieldNames);
+            const unknownField = Object.keys(record).sort().find((name) => !declared.has(name));
+            return unknownField
+                ? { path: `${path}/${unknownField}`, code: 'UNKNOWN_FIELD', expectedKind: 'record' }
+                : null;
+        }
+    }
+}
+export function firstInputValidationIssue(type, value, path = '') {
+    const issue = evaluate(type, value, path);
+    return issue ? { path: issue.path, code: issue.code } : null;
+}
+export function assertInputValue(type, value) {
+    const issue = evaluate(type, value, '');
+    if (!issue)
+        return;
+    throw new ClusterRequestError(`input value at '${issue.path || '/'}' failed validation: ${issue.code}, expected ${issue.expectedKind}`, 'INVALID_INPUT');
+}

package/lib/cluster/validators.cjs

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertDefinition = assertDefinition;
 exports.assertMethodResult = assertMethodResult;
+exports.assertGraphSpec = assertGraphSpec;
+exports.assertGraphProfile = assertGraphProfile;
+exports.assertGraphProfileSupported = assertGraphProfileSupported;
 const _2020_js_1 = require("ajv/dist/2020.js");
 const protocol_js_1 = require("./generated/protocol.cjs");
 const protocol_schema_js_1 = require("./generated/protocol-schema.cjs");
@@ -44,3 +47,21 @@ function assertMethodResult(method, value) {
         throw error;
     }
 }
+function assertRequestDefinition(definition, value, code) {
+    const validate = validatorFor(definition);
+    if (validate(value))
+        return;
+    const details = (validate.errors ?? []).map((error) => `${error.instancePath || '/'} ${error.message ?? 'is invalid'}`).join('; ');
+    throw new errors_js_1.ClusterRequestError(`${definition} validation failed: ${details}`, code);
+}
+function assertGraphSpec(value) {
+    assertRequestDefinition('GraphSpec', value, 'INVALID_GRAPH');
+}
+function assertGraphProfile(value) {
+    assertRequestDefinition('GraphProfile', value, 'INVALID_GRAPH_PROFILE');
+}
+function assertGraphProfileSupported(profile, capabilities) {
+    if (!capabilities.graphProfiles?.includes(profile)) {
+        throw new errors_js_1.ClusterRequestError(`graph profile ${profile} is not among the server's advertised graphProfiles`, 'UNSUPPORTED_GRAPH_PROFILE');
+    }
+}

package/lib/cluster/validators.d.ts

@@ -1,3 +1,6 @@
-import type { ClusterMethod } from './generated/protocol.js';
+import type { ClusterMethod, GraphProfile, GraphSpec, ServerCapabilities } from './generated/protocol.js';
 export declare function assertDefinition(definition: string, value: unknown): void;
 export declare function assertMethodResult(method: ClusterMethod, value: unknown): void;
+export declare function assertGraphSpec(value: unknown): asserts value is GraphSpec;
+export declare function assertGraphProfile(value: unknown): asserts value is GraphProfile;
+export declare function assertGraphProfileSupported(profile: GraphProfile, capabilities: ServerCapabilities): void;

package/lib/cluster/validators.mjs

@@ -1,7 +1,7 @@
 import Ajv2020 from 'ajv/dist/2020.js';
 import { METHOD_RESULT_DEFINITIONS, PROTOCOL_VERSION, } from './generated/protocol.mjs';
 import { CLUSTER_PROTOCOL_SCHEMA } from './generated/protocol-schema.mjs';
-import { ClusterProtocolError } from './errors.mjs';
+import { ClusterProtocolError, ClusterRequestError } from './errors.mjs';
 const ajv = new Ajv2020({
     allErrors: true,
     strict: false,
@@ -40,3 +40,21 @@ export function assertMethodResult(method, value) {
         throw error;
     }
 }
+function assertRequestDefinition(definition, value, code) {
+    const validate = validatorFor(definition);
+    if (validate(value))
+        return;
+    const details = (validate.errors ?? []).map((error) => `${error.instancePath || '/'} ${error.message ?? 'is invalid'}`).join('; ');
+    throw new ClusterRequestError(`${definition} validation failed: ${details}`, code);
+}
+export function assertGraphSpec(value) {
+    assertRequestDefinition('GraphSpec', value, 'INVALID_GRAPH');
+}
+export function assertGraphProfile(value) {
+    assertRequestDefinition('GraphProfile', value, 'INVALID_GRAPH_PROFILE');
+}
+export function assertGraphProfileSupported(profile, capabilities) {
+    if (!capabilities.graphProfiles?.includes(profile)) {
+        throw new ClusterRequestError(`graph profile ${profile} is not among the server's advertised graphProfiles`, 'UNSUPPORTED_GRAPH_PROFILE');
+    }
+}

package/lib/provider-names.js

@@ -63,15 +63,25 @@ function providerSupportsCapability(name, capability) {
   return registry.supportsProviderCapability(name, capability);
 }
 
+function providerSupportsOutputReformatting(name) {
+  return registry.supportsProviderOutputReformatting(name);
+}
+
+function getDefaultProviderId() {
+  return registry.getDefaultProviderId();
+}
+
 module.exports = {
   KNOWN_PROVIDER_NAMES,
   PROVIDER_ALIASES,
   PROVIDER_CAPABILITIES,
   VALID_PROVIDERS,
+  getDefaultProviderId,
   getProviderMetadata,
   listProviderMetadata,
   normalizeProviderName,
   normalizeProviderSettings,
   providerSupportsCapability,
+  providerSupportsOutputReformatting,
   resolveProviderCommand,
 };

package/lib/settings.js

@@ -11,6 +11,7 @@ const lockfile = require('proper-lockfile');
 const { validateMountConfig, validateEnvPassthrough } = require('./docker-config');
 const {
   VALID_PROVIDERS,
+  getDefaultProviderId,
   normalizeProviderName,
   normalizeProviderSettings,
 } = require('./provider-names');
@@ -119,7 +120,7 @@ function validateModelAgainstMax(requestedModel, maxModel, minModel = null) {
 const DEFAULT_SETTINGS_BASE = {
   maxModel: 'opus', // Cost ceiling - agents cannot use models above this
   minModel: null, // Cost floor - agents cannot use models below this (null = no minimum)
-  defaultProvider: 'claude',
+  defaultProvider: getDefaultProviderId(),
   get providerSettings() {
     // Dynamically build from providers on first access
     return getProviderDefaults();
@@ -297,7 +298,10 @@ function mergeLoadedSettings(parsed) {
   const merged = { ...resolvedDefaultSettings(), ...normalized };
   merged.defaultProvider =
     normalizeProviderName(merged.defaultProvider) || DEFAULT_SETTINGS.defaultProvider;
-  merged.providerSettings = mergeProviderSettings(getProviderDefaults(), normalized.providerSettings);
+  merged.providerSettings = mergeProviderSettings(
+    getProviderDefaults(),
+    normalized.providerSettings
+  );
   if (
     merged.autoCheckUpdates === false ||
     typeof merged.lastUpdateCheckClaim !== 'string' ||
@@ -351,7 +355,6 @@ function readSettingsForMutation(settingsFile) {
     };
   }
 
-
   const updatesDisabled = parsed.autoCheckUpdates === false || parsed.updatePolicy === 'off';
   return {
     settings: mergeLoadedSettings(parsed),

package/lib/setup-plan.js

@@ -77,6 +77,7 @@ function defaultDeps() {
   const { execSync } = require('../src/lib/safe-exec');
   const { listProviders, getProvider } = require('../src/providers');
   const { getProviderDefaults } = require('./provider-defaults');
+  const { getDefaultProviderId } = require('./provider-names');
   const packageJson = require('../package.json');
 
   return {
@@ -88,6 +89,7 @@ function defaultDeps() {
     listProviders,
     getProvider,
     getProviderDefaults,
+    getDefaultProviderId,
     getNodeVersion: () => process.version,
     getPackageVersion: () => packageJson.version,
   };
@@ -204,11 +206,9 @@ function buildRecommendedAndRisk({ cwd, facts, env, deps }) {
   const recommended = {};
   const risk = {};
 
-  const firstAvailableProvider = Object.entries(facts.providers).find(
-    ([, info]) => info.cliAvailable
-  );
-  recommended.defaultProvider = firstAvailableProvider ? firstAvailableProvider[0] : 'claude';
-  risk.defaultProvider = firstAvailableProvider ? 'low' : 'medium';
+  const registryDefault = deps.getDefaultProviderId();
+  recommended.defaultProvider = registryDefault;
+  risk.defaultProvider = facts.providers[registryDefault]?.cliAvailable ? 'low' : 'medium';
 
   for (const name of Object.keys(facts.providers)) {
     recommended[providerLevelDecisionId(name)] = buildProviderLevelRecommendation(name, deps);

package/lib/start-cluster.js

@@ -1,7 +1,7 @@
 const path = require('path');
 const { spawnSync } = require('child_process');
 const chalk = require('chalk');
-const { normalizeProviderName } = require('./provider-names');
+const { normalizeProviderName, getDefaultProviderId } = require('./provider-names');
 const { getProvider } = require('../src/providers');
 const { detectProvider } = require('../src/issue-providers');
 const TemplateResolver = require('../src/template-resolver');
@@ -161,9 +161,9 @@ function resolveConfigPath(configName) {
 
 function ensureConfigProviderDefaults(config, settings) {
   if (!config.defaultProvider) {
-    config.defaultProvider = settings.defaultProvider || 'claude';
+    config.defaultProvider = settings.defaultProvider || getDefaultProviderId();
   }
-  config.defaultProvider = normalizeProviderName(config.defaultProvider) || 'claude';
+  config.defaultProvider = normalizeProviderName(config.defaultProvider) || getDefaultProviderId();
 }
 
 function applyProviderOverrideToConfig(config, providerOverride, settings) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@the-open-engine/zeroshot",
-  "version": "6.17.0",
+  "version": "6.19.0",
   "description": "Multi-agent orchestration engine for Claude, Codex, and Gemini",
   "main": "src/orchestrator.js",
   "bin": {
@@ -50,7 +50,7 @@
     "test:providers:live": "npm run build:agent-cli-provider && node scripts/live-provider-smoke.js",
     "check:agent-cli-provider": "npm run check:agent-cli-provider:ci",
     "check:agent-cli-provider:ci": "npm run typecheck:agent-cli-provider && npm run lint:agent-cli-provider && npm run build:agent-cli-provider && npm run test:agent-cli-provider",
-    "test:cluster-client": "npm run build:cluster && node --test tests/cluster/client.test.js tests/cluster/parity.test.js tests/cluster/architecture.test.js tests/cluster/verifier-regressions.test.js",
+    "test:cluster-client": "npm run build:cluster && node --test tests/cluster/client.test.js tests/cluster/parity.test.js tests/cluster/architecture.test.js tests/cluster/verifier-regressions.test.js tests/cluster/request-validation.test.js",
     "test:cluster-package": "npm run build:cluster && node --test tests/cluster/package.test.js",
     "dev:link": "npm link",
     "lint": "eslint .",

package/src/agent/agent-lifecycle.js

@@ -18,7 +18,7 @@ const IsolationManager = require('../isolation-manager');
 const crypto = require('crypto');
 const { bufferMessage, scheduleDrain, drainBufferedMessages } = require('../message-buffer');
 const { isPlatformSupported } = require('./agent-stuck-detector');
-const { normalizeProviderName } = require('../../lib/provider-names');
+const { normalizeProviderName, getDefaultProviderId } = require('../../lib/provider-names');
 const { loadSettings } = require('../../lib/settings');
 const { findPlatformMismatchReason } = require('./validation-platform');
 const { calculateRateLimitDelay, isRateLimitError } = require('./rate-limit-backoff');
@@ -64,7 +64,7 @@ async function createValidatorIsolation(agent, isolationConfig) {
       cluster.config?.forceProvider ||
       cluster.config?.defaultProvider ||
       loadSettings().defaultProvider ||
-      'claude'
+      getDefaultProviderId()
   );
   // Run validators on the provider's image variant (installs its CLI as a Docker-cached layer).
   const image = IsolationManager.imageForProvider(providerName, isolationConfig.image);
@@ -427,7 +427,7 @@ function publishTaskStarted(agent, triggeringMessage) {
   agent._publishLifecycle('TASK_STARTED', {
     iteration: agent.iteration,
     model: agent._selectModel(),
-    provider: agent._resolveProvider ? agent._resolveProvider() : 'claude',
+    provider: agent._resolveProvider ? agent._resolveProvider() : getDefaultProviderId(),
     modelSpec,
     triggeredBy: triggeringMessage.topic,
     triggerFrom: triggeringMessage.sender,
@@ -447,7 +447,7 @@ function publishTaskCompleted(agent, result) {
     iteration: agent.iteration,
     success: true,
     taskId: agent.currentTaskId,
-    provider: agent._resolveProvider ? agent._resolveProvider() : 'claude',
+    provider: agent._resolveProvider ? agent._resolveProvider() : getDefaultProviderId(),
     tokenUsage: result.tokenUsage || null,
     contextSequence: session?.contextSequence ?? agent.currentContextSequence,
     guidanceSequence: session?.guidanceSequence ?? agent.currentGuidanceSequence ?? null,