@the-open-engine/zeroshot 6.4.0 → 6.6.0

package/src/agent-cli-provider/contract-options.ts

@@ -1,6 +1,7 @@
 import { isRecord } from './json';
 import { invalidField, contractError } from './contract-errors';
 import { stringRecord } from './contract-env';
+import { normalizeGatewayBuildOptions } from './gateway-tools';
 import type {
   BuildProviderCommandOptions,
   CliFeatureOverrides,
@@ -23,14 +24,46 @@ const CLI_FEATURE_FIELDS = [
   'supportsModel',
   'supportsJson',
   'supportsOutputSchema',
+  'supportsDir',
   'supportsCwd',
   'supportsConfigOverride',
   'supportsSkipGitRepoCheck',
   'supportsVariant',
+  'supportsJsonMode',
+  'supportsNoSession',
+  'supportsNoExtensions',
+  'supportsNoSkills',
+  'supportsNoPromptTemplates',
+  'supportsNoContextFiles',
+  'supportsNoApprove',
+  'supportsJsonOutput',
+  'supportsAllowAll',
+  'supportsNoAskUser',
+  'supportsAddDir',
+  'supportsMcpConfig',
+  'supportsBundledRunner',
+  'supportsAcpStdio',
+  'supportsPromptImages',
+  'supportsLoadSession',
+  'supportsSessionCancel',
+  'supportsSessionSetModel',
+  'supportsSessionSetMode',
+  'supportsRemoteTransport',
+  'supportsCustomTransport',
+  'supportsPermissionRequests',
+  'supportsFsTools',
+  'supportsTerminalTools',
   'unknown',
 ] as const;
 
 type CliFeatureField = (typeof CLI_FEATURE_FIELDS)[number];
+const FALSE_ONLY_CLI_FEATURE_FIELDS = new Set<CliFeatureField>([
+  'supportsRemoteTransport',
+  'supportsCustomTransport',
+  'supportsPermissionRequests',
+  'supportsFsTools',
+  'supportsTerminalTools',
+]);
 
 export function requestOptions(value: unknown): BuildProviderCommandOptions {
   if (value === undefined) return {};
@@ -77,6 +110,25 @@ function optionalBooleanValue(value: unknown, field: string): boolean | undefine
   invalidField(field, `${field} must be a boolean.`);
 }
 
+function optionalMcpConfig(value: unknown): readonly string[] | undefined {
+  if (value === undefined) return undefined;
+  if (!Array.isArray(value)) {
+    invalidField('options.mcpConfig', 'options.mcpConfig must be an array of strings.');
+  }
+  return value.map((item, index) => {
+    if (typeof item !== 'string') {
+      invalidField(`options.mcpConfig[${index}]`, `options.mcpConfig[${index}] must be a string.`);
+    }
+    if (item.trim().length === 0) {
+      invalidField(
+        `options.mcpConfig[${index}]`,
+        `options.mcpConfig[${index}] must be a non-empty string.`
+      );
+    }
+    return item;
+  });
+}
+
 function optionalEnumValue<T extends string>(
   value: unknown,
   field: string,
@@ -119,12 +171,19 @@ function optionalCliFeatures(value: unknown): CliFeatureOverrides | undefined {
     invalidField('options.cliFeatures', 'options.cliFeatures must be an object.');
   }
 
-  const result: Partial<Record<CliFeatureField, boolean>> = {};
+  const result: Record<string, boolean> = {};
   for (const field of CLI_FEATURE_FIELDS) {
     const item = optionalBooleanValue(value[field], `options.cliFeatures.${field}`);
-    if (item !== undefined) result[field] = item;
+    if (item === undefined) continue;
+    if (item && FALSE_ONLY_CLI_FEATURE_FIELDS.has(field)) {
+      invalidField(
+        `options.cliFeatures.${field}`,
+        `options.cliFeatures.${field} must be false when provided.`
+      );
+    }
+    result[field] = item;
   }
-  return result;
+  return result as CliFeatureOverrides;
 }
 
 function normalizeBuildOptions(value: Record<string, unknown>): BuildProviderCommandOptions {
@@ -149,11 +208,21 @@ function normalizeBuildOptions(value: Record<string, unknown>): BuildProviderCom
     optionalBooleanValue(value.continueSession, 'options.continueSession')
   );
   addDefined(result, 'cliFeatures', optionalCliFeatures(value.cliFeatures));
+  addDefined(result, 'mcpConfig', optionalMcpConfig(value.mcpConfig));
   addDefined(
     result,
     'strictSchema',
     optionalBooleanValue(value.strictSchema, 'options.strictSchema')
   );
+  addDefined(
+    result,
+    'gateway',
+    normalizeGatewayBuildOptions(
+      value.gateway,
+      'options.gateway',
+      optionalStringValue(value.cwd, 'options.cwd') ?? process.cwd()
+    )
+  );
   if (Object.prototype.hasOwnProperty.call(value, 'authEnv')) {
     result.authEnv = stringRecord(value.authEnv, 'options.authEnv');
   }

package/src/agent-cli-provider/contract-support.ts

@@ -40,10 +40,10 @@ export function adapterForProvider(provider: string | null): ProviderAdapter {
   }
   try {
     return getProviderAdapter(provider);
-  } catch {
+  } catch (error) {
     throw contractError({
       code: 'unknown-provider',
-      message: `Unknown provider: ${provider}.`,
+      message: error instanceof Error ? error.message : `Unknown provider: ${provider}.`,
       exitCode: 4,
       field: 'provider',
     });
@@ -54,7 +54,17 @@ function mergeCommandSpec(
   commandSpec: CommandSpec,
   env: Readonly<Record<string, string>>
 ): CommandSpec {
-  const mergedEnv = { ...commandSpec.env, ...env };
+  const overriddenKey = findReservedCommandEnvKey(commandSpec.env, env);
+  if (overriddenKey !== null) {
+    throw contractError({
+      code: 'forbidden-field',
+      message: `env.${overriddenKey.requestKey} is not accepted by provider executable requests; provider adapters own ${overriddenKey.commandKey} and other runner control/auth environment variables.`,
+      exitCode: 2,
+      field: `env.${overriddenKey.requestKey}`,
+    });
+  }
+
+  const mergedEnv = { ...env, ...commandSpec.env };
   return {
     ...commandSpec,
     env: mergedEnv,
@@ -62,6 +72,21 @@ function mergeCommandSpec(
   };
 }
 
+function findReservedCommandEnvKey(
+  commandEnv: Readonly<Record<string, string>>,
+  requestedEnv: Readonly<Record<string, string>>
+): { readonly requestKey: string; readonly commandKey: string } | null {
+  const commandEnvKeys = new Map<string, string>();
+  for (const key of Object.keys(commandEnv)) {
+    commandEnvKeys.set(key.toLowerCase(), key);
+  }
+  for (const key of Object.keys(requestedEnv)) {
+    const commandKey = commandEnvKeys.get(key.toLowerCase());
+    if (commandKey !== undefined) return { requestKey: key, commandKey };
+  }
+  return null;
+}
+
 function buildOptions(request: RequestData): BuildProviderCommandOptions {
   const options = requestOptions(request.raw.options);
   const cwd = optionalString(request.raw, 'cwd');
@@ -73,6 +98,7 @@ export function buildCommandSpec(request: RequestData): {
   readonly adapter: ProviderAdapter;
   readonly commandSpec: CommandSpec;
   readonly options: BuildProviderCommandOptions;
+  readonly context: string;
 } {
   const adapter = adapterForProvider(request.provider);
   const context = requiredString(request.raw, 'context');
@@ -84,6 +110,7 @@ export function buildCommandSpec(request: RequestData): {
   });
   return {
     adapter: prepared.adapter,
+    context,
     options: prepared.options,
     commandSpec: mergeCommandSpec(prepared.commandSpec, request.env),
   };

package/src/agent-cli-provider/errors.ts

@@ -34,14 +34,24 @@ const BASE_PERMANENT_PATTERNS: readonly RegExp[] = [
   /insufficient quota/i,
 ];
 
-function getStatus(error: unknown): number | null {
+function statusFromMessage(message: string): number | null {
+  const match = /\b(?:status(?: code)?|http)\s+(?<status>\d{3})\b/i.exec(message);
+  if (!match?.groups?.status) return null;
+  const status = Number.parseInt(match.groups.status, 10);
+  return Number.isInteger(status) ? status : null;
+}
+
+export function extractErrorStatus(error: unknown): number | null {
   if (!isRecord(error)) return null;
   const directStatus = getNumber(error, 'status') ?? getNumber(error, 'statusCode');
   if (directStatus !== null) return directStatus;
 
   const response = getRecord(error, 'response');
-  if (response === null) return null;
-  return getNumber(response, 'status') ?? getNumber(response, 'statusCode');
+  const responseStatus =
+    response === null ? null : getNumber(response, 'status') ?? getNumber(response, 'statusCode');
+  if (responseStatus !== null) return responseStatus;
+
+  return statusFromMessage(unknownToMessage(error));
 }
 
 function getCode(error: unknown): string | null {
@@ -69,7 +79,7 @@ export function classifyErrorWithPatterns(
   retryablePatterns: readonly RegExp[],
   permanentPatterns: readonly RegExp[]
 ): ErrorClassification {
-  const statusClassification = classifyStatus(getStatus(error));
+  const statusClassification = classifyStatus(extractErrorStatus(error));
   if (statusClassification !== null) return statusClassification;
 
   const codeClassification = classifyCode(getCode(error));

package/src/agent-cli-provider/gateway-client.ts

@@ -0,0 +1,170 @@
+import { getArray, getRecord, getString, isRecord, unknownToMessage } from './json';
+
+export interface GatewayChatToolDefinition {
+  readonly type: 'function';
+  readonly function: {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: Record<string, unknown>;
+  };
+}
+
+export interface GatewayToolCall {
+  readonly id: string;
+  readonly name: string;
+  readonly argumentsText: string;
+}
+
+export interface GatewayChatMessage {
+  readonly role: 'system' | 'user' | 'assistant' | 'tool';
+  readonly content: string;
+  readonly toolCalls?: readonly GatewayToolCall[];
+  readonly toolCallId?: string;
+}
+
+export interface GatewayChatResponse {
+  readonly text: string;
+  readonly toolCalls: readonly GatewayToolCall[];
+}
+
+class GatewayHttpError extends Error {
+  readonly status: number;
+
+  constructor(status: number, message: string) {
+    super(message);
+    this.name = 'GatewayHttpError';
+    this.status = status;
+  }
+}
+
+export async function createGatewayChatCompletion(input: {
+  readonly baseUrl: string;
+  readonly apiKey: string;
+  readonly headers: Readonly<Record<string, string>>;
+  readonly model: string;
+  readonly messages: readonly GatewayChatMessage[];
+  readonly tools: readonly GatewayChatToolDefinition[];
+}): Promise<GatewayChatResponse> {
+  const response = await fetch(`${input.baseUrl}/chat/completions`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${input.apiKey}`,
+      ...input.headers,
+    },
+    body: JSON.stringify({
+      model: input.model,
+      messages: input.messages.map((message) => serializeMessage(message)),
+      tools: input.tools,
+      tool_choice: 'auto',
+      temperature: 0,
+    }),
+  });
+
+  const bodyText = await response.text();
+  const parsed = tryParseJson(bodyText);
+  if (!response.ok) {
+    throw httpError(response.status, parsed ?? bodyText);
+  }
+  if (!isRecord(parsed)) {
+    throw new Error('Gateway returned a non-JSON response.');
+  }
+
+  const choice = getArray(parsed, 'choices')[0];
+  if (!isRecord(choice)) {
+    throw new Error('Gateway response did not include choices[0].');
+  }
+  const message = getRecord(choice, 'message');
+  if (message === null) {
+    throw new Error('Gateway response did not include choices[0].message.');
+  }
+
+  return {
+    text: getGatewayMessageText(message),
+    toolCalls: getGatewayToolCalls(message),
+  };
+}
+
+function serializeMessage(message: GatewayChatMessage): Record<string, unknown> {
+  if (message.role === 'assistant' && message.toolCalls && message.toolCalls.length > 0) {
+    return {
+      role: 'assistant',
+      content: message.content,
+      tool_calls: message.toolCalls.map((toolCall) => ({
+        id: toolCall.id,
+        type: 'function',
+        function: {
+          name: toolCall.name,
+          arguments: toolCall.argumentsText,
+        },
+      })),
+    };
+  }
+  if (message.role === 'tool') {
+    return {
+      role: 'tool',
+      tool_call_id: message.toolCallId,
+      content: message.content,
+    };
+  }
+  return {
+    role: message.role,
+    content: message.content,
+  };
+}
+
+function getGatewayMessageText(message: Record<string, unknown>): string {
+  const content = message.content;
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+
+  let text = '';
+  for (const item of content) {
+    if (!isRecord(item)) continue;
+    const type = getString(item, 'type');
+    if (type === 'text') {
+      text += getString(item, 'text') ?? '';
+    }
+  }
+  return text;
+}
+
+function getGatewayToolCalls(message: Record<string, unknown>): readonly GatewayToolCall[] {
+  const result: GatewayToolCall[] = [];
+  for (const item of getArray(message, 'tool_calls')) {
+    if (!isRecord(item)) continue;
+    const id = getString(item, 'id');
+    const fn = getRecord(item, 'function');
+    const name = fn === null ? null : getString(fn, 'name');
+    const argumentsText = fn === null ? null : getString(fn, 'arguments');
+    if (!id || !name || argumentsText === null) continue;
+    result.push({ id, name, argumentsText });
+  }
+  return result;
+}
+
+function httpError(status: number, body: unknown): GatewayHttpError {
+  return new GatewayHttpError(status, buildGatewayErrorMessage(status, body));
+}
+
+function buildGatewayErrorMessage(status: number, body: unknown): string {
+  if (isRecord(body)) {
+    const nested = getRecord(body, 'error');
+    if (nested) {
+      const message = getString(nested, 'message');
+      if (message) return `Gateway request failed with status ${status}: ${message}`;
+      return `Gateway request failed with status ${status}: ${unknownToMessage(nested)}`;
+    }
+    const message = getString(body, 'message');
+    if (message) return `Gateway request failed with status ${status}: ${message}`;
+  }
+  return `Gateway request failed with status ${status}: ${unknownToMessage(body)}`;
+}
+
+function tryParseJson(value: string): unknown | null {
+  try {
+    return JSON.parse(value) as unknown;
+  } catch {
+    return null;
+  }
+}