@the-open-engine/zeroshot 6.30.2 → 6.31.0

package/src/agent-cli-provider/omp/sdk-settings-constants.ts

@@ -0,0 +1,147 @@
+import { OMP_SDK_REASONING_EFFORTS } from './sdk-settings-types';
+
+export const LEVELS = ['level1', 'level2', 'level3'] as const;
+export const EFFORTS = OMP_SDK_REASONING_EFFORTS;
+export const APIS = [
+  'openai-completions',
+  'openai-responses',
+  'openai-codex-responses',
+  'azure-openai-responses',
+  'anthropic-messages',
+  'bedrock-converse-stream',
+  'google-generative-ai',
+  'google-gemini-cli',
+  'google-vertex',
+] as const;
+export const INPUT_TYPES = ['text', 'image'] as const;
+export const THINKING_MODES = [
+  'effort',
+  'budget',
+  'google-level',
+  'anthropic-adaptive',
+  'anthropic-budget-effort',
+] as const;
+export const COMPAT_FIELDS = new Set([
+  'supportsStore',
+  'supportsDeveloperRole',
+  'supportsMultipleSystemMessages',
+  'supportsReasoningEffort',
+  'reasoningEffortMap',
+  'maxTokensField',
+  'supportsUsageInStreaming',
+  'requiresToolResultName',
+  'requiresMistralToolIds',
+  'requiresAssistantAfterToolResult',
+  'requiresThinkingAsText',
+  'reasoningContentField',
+  'requiresReasoningContentForToolCalls',
+  'allowsSyntheticReasoningContentForToolCalls',
+  'requiresAssistantContentForToolCalls',
+  'supportsToolChoice',
+  'supportsForcedToolChoice',
+  'disableReasoningOnForcedToolChoice',
+  'disableReasoningOnToolChoice',
+  'thinkingFormat',
+  'openRouterRouting',
+  'vercelGatewayRouting',
+  'cacheControlFormat',
+  'supportsStrictMode',
+  'toolStrictMode',
+  'streamIdleTimeoutMs',
+  'supportsLongPromptCacheRetention',
+  'supportsReasoningParams',
+  'alwaysSendMaxTokens',
+  'strictResponsesPairing',
+  'supportsImageDetailOriginal',
+  'supportsEagerToolInputStreaming',
+  'allowAnthropicHeaderOverrides',
+  'requiresToolResultId',
+  'replayUnsignedThinking',
+  'promptCacheMode',
+  'promptCacheMinimumTokens',
+  'promptCacheMaximumCheckpoints',
+  'whenThinking',
+  'extraBody',
+]);
+export const COMPAT_STRING_ENUMS = {
+  maxTokensField: ['max_completion_tokens', 'max_tokens'],
+  reasoningContentField: ['reasoning_content', 'reasoning', 'reasoning_text'],
+  thinkingFormat: ['openai', 'openrouter', 'zai', 'qwen', 'qwen-chat-template'],
+  cacheControlFormat: ['anthropic'],
+  toolStrictMode: ['all_strict', 'none'],
+  promptCacheMode: ['none', 'automatic', 'explicit'],
+} as const;
+export const COMPAT_NUMBER_FIELDS = new Set([
+  'streamIdleTimeoutMs',
+  'promptCacheMinimumTokens',
+  'promptCacheMaximumCheckpoints',
+]);
+export const COMPAT_RECORD_FIELDS = new Set([
+  'reasoningEffortMap',
+  'openRouterRouting',
+  'vercelGatewayRouting',
+]);
+export const PROVIDER_FIELDS = new Set([
+  'baseUrl',
+  'apiKey',
+  'api',
+  'headers',
+  'compat',
+  'remoteCompaction',
+  'authHeader',
+  'auth',
+  'discovery',
+  'models',
+  'modelOverrides',
+  'disableStrictTools',
+  'transport',
+]);
+export const MODEL_FIELDS = new Set([
+  'id',
+  'name',
+  'api',
+  'baseUrl',
+  'reasoning',
+  'thinking',
+  'input',
+  'supportsTools',
+  'cost',
+  'premiumMultiplier',
+  'contextWindow',
+  'maxTokens',
+  'omitMaxOutputTokens',
+  'headers',
+  'compat',
+  'contextPromotionTarget',
+  'compactionModel',
+  'remoteCompaction',
+]);
+export const MODEL_OVERRIDE_FIELDS = new Set(
+  [...MODEL_FIELDS].filter((field) => field !== 'id' && field !== 'api' && field !== 'baseUrl')
+);
+export const THINKING_FIELDS = new Set([
+  'mode',
+  'efforts',
+  'defaultLevel',
+  'effortMap',
+  'supportsDisplay',
+  'minLevel',
+  'maxLevel',
+  'levels',
+]);
+export const COST_FIELDS = new Set(['input', 'output', 'cacheRead', 'cacheWrite']);
+export const TOP_LEVEL_FIELDS = new Set([
+  'transport',
+  'minLevel',
+  'defaultLevel',
+  'maxLevel',
+  'levelOverrides',
+  'modelsConfig',
+  'auth',
+  'tools',
+  'nestedAgents',
+  'mcp',
+]);
+export const ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+export const PROVIDER_ID = /^[a-z0-9][a-z0-9._-]*$/;
+export const MODEL_COMPONENT = /^\S+$/;

package/src/agent-cli-provider/omp/sdk-settings-model-fields.ts

@@ -0,0 +1,233 @@
+import { invalidField } from '../contract-errors';
+import { isRecord } from '../json';
+import {
+  APIS,
+  COMPAT_FIELDS,
+  COMPAT_NUMBER_FIELDS,
+  COMPAT_RECORD_FIELDS,
+  COMPAT_STRING_ENUMS,
+  COST_FIELDS,
+  EFFORTS,
+  INPUT_TYPES,
+  MODEL_FIELDS,
+  MODEL_OVERRIDE_FIELDS,
+  MODEL_COMPONENT,
+  THINKING_FIELDS,
+  THINKING_MODES,
+} from './sdk-settings-constants';
+import type { OmpModelDefinition } from './sdk-settings-types';
+import {
+  booleanValue,
+  emptyHeaders,
+  enumValue,
+  nonEmptyString,
+  nonNegativeNumber,
+  rejectUnknown,
+  safeUrl,
+} from './sdk-settings-values';
+
+export function normalizeModelDefinition(value: unknown, field: string): OmpModelDefinition {
+  if (!isRecord(value)) invalidField(field, `${field} must be an object.`);
+  rejectUnknown(value, MODEL_FIELDS, field);
+  if (typeof value.id !== 'string' || value.id.length === 0 || !MODEL_COMPONENT.test(value.id)) {
+    invalidField(`${field}.id`, 'Custom model id must be a non-empty string without whitespace.');
+  }
+  const result: { [field: string]: unknown; id: string } = { id: value.id };
+  copyModelFields(value, result, field, true);
+  return result;
+}
+
+export function normalizeModelOverride(value: unknown, field: string): Record<string, unknown> {
+  if (!isRecord(value)) invalidField(field, `${field} must be an object.`);
+  rejectUnknown(value, MODEL_OVERRIDE_FIELDS, field);
+  const result: Record<string, unknown> = {};
+  copyModelFields(value, result, field, false);
+  return result;
+}
+
+function copyModelFields(
+  value: Record<string, unknown>,
+  result: Record<string, unknown>,
+  field: string,
+  allowApiAndBaseUrl: boolean
+): void {
+  if (value.name !== undefined) result.name = nonEmptyString(value.name, `${field}.name`);
+  if (allowApiAndBaseUrl && value.api !== undefined) {
+    result.api = enumValue(value.api, APIS, `${field}.api`);
+  }
+  if (allowApiAndBaseUrl && value.baseUrl !== undefined) {
+    result.baseUrl = safeUrl(value.baseUrl, `${field}.baseUrl`);
+  }
+  for (const key of ['reasoning', 'supportsTools', 'omitMaxOutputTokens'] as const) {
+    if (value[key] !== undefined) result[key] = booleanValue(value[key], `${field}.${key}`);
+  }
+  for (const key of ['premiumMultiplier', 'contextWindow', 'maxTokens'] as const) {
+    if (value[key] !== undefined) {
+      result[key] = nonNegativeNumber(value[key], `${field}.${key}`);
+    }
+  }
+  for (const key of ['contextPromotionTarget', 'compactionModel'] as const) {
+    if (value[key] !== undefined) result[key] = nonEmptyString(value[key], `${field}.${key}`);
+  }
+  if (value.input !== undefined) {
+    if (!Array.isArray(value.input) || value.input.length === 0) {
+      invalidField(`${field}.input`, 'input must be a non-empty text/image array.');
+    }
+    result.input = value.input.map((item, index) =>
+      enumValue(item, INPUT_TYPES, `${field}.input[${index}]`)
+    );
+  }
+  if (value.thinking !== undefined) {
+    result.thinking = normalizeThinking(value.thinking, `${field}.thinking`);
+  }
+  if (value.cost !== undefined) {
+    result.cost = normalizeCost(value.cost, `${field}.cost`, allowApiAndBaseUrl);
+  }
+  if (value.headers !== undefined) result.headers = emptyHeaders(value.headers, `${field}.headers`);
+  if (value.compat !== undefined) result.compat = normalizeCompat(value.compat, `${field}.compat`);
+  if (value.remoteCompaction !== undefined) {
+    invalidField(`${field}.remoteCompaction`, 'Remote compaction config is not accepted.');
+  }
+}
+
+function normalizeThinking(value: unknown, field: string): Record<string, unknown> {
+  if (!isRecord(value)) invalidField(field, `${field} must be an object.`);
+  rejectUnknown(value, THINKING_FIELDS, field);
+  const result: Record<string, unknown> = {
+    mode: enumValue(value.mode, THINKING_MODES, `${field}.mode`),
+  };
+  for (const key of ['efforts', 'levels'] as const) {
+    if (value[key] !== undefined) {
+      if (!Array.isArray(value[key]) || value[key].length === 0) {
+        invalidField(`${field}.${key}`, `${key} must be a non-empty effort array.`);
+      }
+      result[key] = value[key].map((item, index) =>
+        enumValue(item, EFFORTS, `${field}.${key}[${index}]`)
+      );
+    }
+  }
+  for (const key of ['defaultLevel', 'minLevel', 'maxLevel'] as const) {
+    if (value[key] !== undefined) {
+      result[key] = enumValue(value[key], EFFORTS, `${field}.${key}`);
+    }
+  }
+  if (value.supportsDisplay !== undefined) {
+    result.supportsDisplay = booleanValue(value.supportsDisplay, `${field}.supportsDisplay`);
+  }
+  if (value.effortMap !== undefined) {
+    result.effortMap = normalizeEffortMap(value.effortMap, `${field}.effortMap`);
+  }
+  const hasEfforts = result.efforts !== undefined || result.levels !== undefined;
+  if (!hasEfforts && (result.minLevel === undefined || result.maxLevel === undefined)) {
+    invalidField(field, 'thinking requires efforts, levels, or both minLevel and maxLevel.');
+  }
+  return result;
+}
+
+function normalizeEffortMap(value: unknown, field: string): Record<string, string> {
+  if (!isRecord(value)) invalidField(field, `${field} must be an object.`);
+  rejectUnknown(value, new Set(EFFORTS), field);
+  const result: Record<string, string> = {};
+  for (const [effort, mapped] of Object.entries(value)) {
+    result[effort] = nonEmptyString(mapped, `${field}.${effort}`);
+  }
+  return result;
+}
+
+function normalizeCost(
+  value: unknown,
+  field: string,
+  requireAllFields: boolean
+): Record<string, number> {
+  if (!isRecord(value)) invalidField(field, `${field} must be an object.`);
+  rejectUnknown(value, COST_FIELDS, field);
+  if (requireAllFields) {
+    const missing = [...COST_FIELDS].find((key) => value[key] === undefined);
+    if (missing !== undefined) {
+      invalidField(`${field}.${missing}`, `${field}.${missing} is required.`);
+    }
+  }
+  const result: Record<string, number> = {};
+  for (const key of COST_FIELDS) {
+    if (value[key] !== undefined) {
+      result[key] = nonNegativeNumber(value[key], `${field}.${key}`);
+    }
+  }
+  return result;
+}
+
+export function normalizeCompat(
+  value: unknown,
+  field: string,
+  allowWhenThinking = true
+): Record<string, unknown> {
+  if (!isRecord(value)) invalidField(field, `${field} must be an object.`);
+  rejectUnknown(value, COMPAT_FIELDS, field);
+  if (Object.prototype.hasOwnProperty.call(value, 'extraBody')) {
+    invalidField(
+      `${field}.extraBody`,
+      'Arbitrary request bodies may contain persisted secrets and are not accepted.'
+    );
+  }
+  const result: Record<string, unknown> = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (key === 'whenThinking') {
+      if (!allowWhenThinking) {
+        invalidField(
+          `${field}.whenThinking`,
+          'Nested compat.whenThinking is not a native OMP field.'
+        );
+      }
+      result[key] = normalizeCompat(item, `${field}.whenThinking`, false);
+      continue;
+    }
+    if (COMPAT_RECORD_FIELDS.has(key)) {
+      result[key] =
+        key === 'reasoningEffortMap'
+          ? normalizeEffortMap(item, `${field}.${key}`)
+          : normalizeRouting(item, `${field}.${key}`);
+      continue;
+    }
+    if (COMPAT_NUMBER_FIELDS.has(key)) {
+      result[key] = nonNegativeNumber(item, `${field}.${key}`);
+      continue;
+    }
+    if (key === 'maxTokensField') {
+      result[key] = enumValue(item, COMPAT_STRING_ENUMS.maxTokensField, `${field}.${key}`);
+      continue;
+    }
+    if (key === 'reasoningContentField') {
+      result[key] = enumValue(item, COMPAT_STRING_ENUMS.reasoningContentField, `${field}.${key}`);
+      continue;
+    }
+    if (key === 'thinkingFormat') {
+      result[key] = enumValue(item, COMPAT_STRING_ENUMS.thinkingFormat, `${field}.${key}`);
+      continue;
+    }
+    if (key === 'cacheControlFormat') {
+      result[key] = enumValue(item, COMPAT_STRING_ENUMS.cacheControlFormat, `${field}.${key}`);
+      continue;
+    }
+    if (key === 'toolStrictMode') {
+      result[key] = enumValue(item, COMPAT_STRING_ENUMS.toolStrictMode, `${field}.${key}`);
+      continue;
+    }
+    if (key === 'promptCacheMode') {
+      result[key] = enumValue(item, COMPAT_STRING_ENUMS.promptCacheMode, `${field}.${key}`);
+      continue;
+    }
+    result[key] = booleanValue(item, `${field}.${key}`);
+  }
+  return result;
+}
+
+function normalizeRouting(value: unknown, field: string): Record<string, readonly string[]> {
+  if (!isRecord(value)) invalidField(field, `${field} must be an object.`);
+  rejectUnknown(value, new Set(['only', 'order']), field);
+  const result: Record<string, readonly string[]> = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (!Array.isArray(item)) invalidField(`${field}.${key}`, `${field}.${key} must be an array.`);
+    result[key] = item.map((entry, index) => nonEmptyString(entry, `${field}.${key}[${index}]`));
+  }
+  return result;
+}

package/src/agent-cli-provider/omp/sdk-settings-model.ts

@@ -0,0 +1,238 @@
+import { invalidField } from '../contract-errors';
+import { isRecord } from '../json';
+import { APIS, ENV_NAME, LEVELS, MODEL_COMPONENT, PROVIDER_FIELDS } from './sdk-settings-constants';
+import {
+  normalizeCompat,
+  normalizeModelDefinition,
+  normalizeModelOverride,
+} from './sdk-settings-model-fields';
+import { parseExactOmpModelSelector } from './sdk-settings-selector';
+import type {
+  OmpModelsConfig,
+  OmpModelLevel,
+  OmpLevelOverride,
+  OmpProviderConfig,
+  OmpSdkAuth,
+} from './sdk-settings-types';
+import {
+  assertProviderId,
+  booleanValue,
+  emptyHeaders,
+  enumValue,
+  rejectUnknown,
+  safeUrl,
+} from './sdk-settings-values';
+
+export function normalizeModelsConfig(value: unknown, auth?: OmpSdkAuth): OmpModelsConfig {
+  if (!isRecord(value)) {
+    invalidField('providerSettings.omp.modelsConfig', 'OMP modelsConfig must be an object.');
+  }
+  rejectUnknown(value, new Set(['providers']), 'providerSettings.omp.modelsConfig');
+  const providerInput = value.providers ?? {};
+  if (!isRecord(providerInput)) {
+    invalidField(
+      'providerSettings.omp.modelsConfig.providers',
+      'OMP modelsConfig.providers must be an object.'
+    );
+  }
+  const providers: Record<string, OmpProviderConfig> = {};
+  for (const [provider, config] of Object.entries(providerInput)) {
+    const field = `providerSettings.omp.modelsConfig.providers.${provider}`;
+    assertProviderId(provider, field);
+    providers[provider] = normalizeProviderConfig(provider, config, auth, field);
+  }
+  return { providers };
+}
+
+function normalizeProviderConfig(
+  provider: string,
+  value: unknown,
+  auth: OmpSdkAuth | undefined,
+  field: string
+): OmpProviderConfig {
+  if (!isRecord(value)) invalidField(field, `${field} must be an object.`);
+  rejectUnknown(value, PROVIDER_FIELDS, field);
+  const result: Record<string, unknown> = {};
+
+  if (value.baseUrl !== undefined) result.baseUrl = safeUrl(value.baseUrl, `${field}.baseUrl`);
+  if (value.api !== undefined) result.api = enumValue(value.api, APIS, `${field}.api`);
+  if (value.auth !== undefined) {
+    const providerAuth = enumValue(
+      value.auth,
+      ['apiKey', 'none', 'oauth'] as const,
+      `${field}.auth`
+    );
+    if (providerAuth === 'oauth') {
+      invalidField(
+        `${field}.auth`,
+        'Custom provider OAuth would read ambient state and is not accepted.'
+      );
+    }
+    result.auth = providerAuth;
+  }
+  if (value.transport !== undefined) {
+    invalidField(
+      `${field}.transport`,
+      'Command/gateway-backed custom provider transports are not accepted.'
+    );
+  }
+  if (value.discovery !== undefined) {
+    invalidField(`${field}.discovery`, 'Dynamic custom provider discovery is not accepted.');
+  }
+  if (value.remoteCompaction !== undefined) {
+    invalidField(`${field}.remoteCompaction`, 'Remote compaction config is not accepted.');
+  }
+  if (value.headers !== undefined) result.headers = emptyHeaders(value.headers, `${field}.headers`);
+  if (value.compat !== undefined) result.compat = normalizeCompat(value.compat, `${field}.compat`);
+  if (value.authHeader !== undefined) {
+    result.authHeader = booleanValue(value.authHeader, `${field}.authHeader`);
+  }
+  if (value.disableStrictTools !== undefined) {
+    result.disableStrictTools = booleanValue(
+      value.disableStrictTools,
+      `${field}.disableStrictTools`
+    );
+  }
+
+  if (value.models !== undefined) {
+    if (!Array.isArray(value.models) || value.models.length === 0) {
+      invalidField(`${field}.models`, 'Custom provider models must be a non-empty array.');
+    }
+    const models = value.models.map((model, index) =>
+      normalizeModelDefinition(model, `${field}.models[${index}]`)
+    );
+    result.models = models;
+    if (result.baseUrl === undefined) {
+      invalidField(`${field}.baseUrl`, 'baseUrl is required when defining custom models.');
+    }
+    const hasProviderApi = result.api !== undefined;
+    const seenModelIds = new Set<string>();
+    for (const { id: modelId } of models) {
+      if (seenModelIds.has(modelId)) {
+        invalidField(`${field}.models`, `Custom model id ${modelId} is duplicated.`);
+      }
+      seenModelIds.add(modelId);
+    }
+    if (!hasProviderApi && models.some((model) => model.api === undefined)) {
+      invalidField(
+        `${field}.api`,
+        'api is required at provider or every model when defining custom models.'
+      );
+    }
+  }
+
+  if (value.modelOverrides !== undefined) {
+    if (!isRecord(value.modelOverrides)) {
+      invalidField(`${field}.modelOverrides`, 'modelOverrides must be an object.');
+    }
+    const overrides: Record<string, unknown> = {};
+    for (const [model, override] of Object.entries(value.modelOverrides)) {
+      if (model.length === 0 || !MODEL_COMPONENT.test(model)) {
+        invalidField(`${field}.modelOverrides`, 'modelOverrides keys must be non-empty model IDs.');
+      }
+      overrides[model] = normalizeModelOverride(override, `${field}.modelOverrides.${model}`);
+    }
+    result.modelOverrides = overrides;
+  }
+
+  const credentialEnv = auth?.mode === 'environment' ? auth.credentials[provider]?.env : undefined;
+  if (value.apiKey !== undefined) {
+    if (typeof value.apiKey !== 'string' || !ENV_NAME.test(value.apiKey)) {
+      invalidField(
+        `${field}.apiKey`,
+        'apiKey must be an environment variable name; literals and command-backed values are forbidden.'
+      );
+    }
+    if (auth?.mode === 'environment' && credentialEnv === undefined) {
+      invalidField(
+        `${field}.apiKey`,
+        'apiKey must match a declared environment credential reference for this provider.'
+      );
+    }
+    if (credentialEnv !== undefined && value.apiKey !== credentialEnv) {
+      invalidField(
+        `${field}.apiKey`,
+        'apiKey must match the declared environment credential reference.'
+      );
+    }
+    if (auth !== undefined && auth.mode !== 'environment') {
+      invalidField(`${field}.apiKey`, `${auth.mode} auth forbids provider apiKey configuration.`);
+    }
+    result.apiKey = value.apiKey;
+  } else if (value.models !== undefined && result.auth !== 'none') {
+    if (auth?.mode === 'environment' && credentialEnv !== undefined) {
+      result.apiKey = credentialEnv;
+    } else if (auth !== undefined) {
+      invalidField(
+        `${field}.apiKey`,
+        'Authenticated custom models require an environment credential reference; broker and omp-home custom-provider credentials cannot be materialized safely.'
+      );
+    }
+  }
+  if (auth?.mode === 'none' && result.auth !== 'none') {
+    invalidField(
+      `${field}.auth`,
+      'Keyless settings require custom providers to declare auth: none.'
+    );
+  }
+  return result;
+}
+
+export function validateSelectedProviderAuth(
+  levels: Readonly<Record<OmpModelLevel, OmpLevelOverride>>,
+  modelsConfig: OmpModelsConfig,
+  auth: OmpSdkAuth
+): void {
+  const selectors = LEVELS.map((level) => parseExactOmpModelSelector(levels[level].model));
+  const providers = new Set(selectors.map(({ provider }) => provider));
+  for (const { provider, model } of selectors) {
+    const configuredModels = modelsConfig.providers[provider]?.models;
+    if (
+      Array.isArray(configuredModels) &&
+      !configuredModels.some((configured) => isRecord(configured) && configured.id === model)
+    ) {
+      invalidField(
+        `providerSettings.omp.levelOverrides`,
+        `Selected custom model ${provider}/${model} is not declared in modelsConfig.`
+      );
+    }
+  }
+  if (auth.mode === 'environment') {
+    for (const provider of providers) {
+      const custom = modelsConfig.providers[provider];
+      if (custom?.auth === 'none') {
+        invalidField(
+          `providerSettings.omp.auth.mode`,
+          `Selected keyless provider ${provider} requires auth mode none.`
+        );
+      }
+      if (auth.credentials[provider] === undefined) {
+        invalidField(
+          `providerSettings.omp.auth.credentials.${provider}`,
+          `Environment auth is missing a credential reference for selected provider ${provider}.`
+        );
+      }
+    }
+  }
+  if (auth.mode === 'none') {
+    for (const provider of providers) {
+      const custom = modelsConfig.providers[provider];
+      if (custom !== undefined && custom.auth !== 'none') {
+        invalidField(
+          `providerSettings.omp.modelsConfig.providers.${provider}.auth`,
+          `Selected custom provider ${provider} must declare auth: none for keyless execution.`
+        );
+      }
+    }
+  }
+  if (auth.mode === 'broker') {
+    for (const provider of providers) {
+      if (modelsConfig.providers[provider]?.models !== undefined) {
+        invalidField(
+          `providerSettings.omp.modelsConfig.providers.${provider}`,
+          'Broker auth cannot safely satisfy OMP custom-provider apiKey config; use environment auth.'
+        );
+      }
+    }
+  }
+}