@the-open-engine/zeroshot 6.8.3 → 6.9.1

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

@@ -1,4 +1,5 @@
 import { getArray, getRecord, getString, isRecord, unknownToMessage } from './json';
+import type { GatewayProtocol } from './types';
 
 export interface GatewayChatToolDefinition {
   readonly type: 'function';
@@ -18,6 +19,7 @@ export interface GatewayToolCall {
 export interface GatewayChatMessage {
   readonly role: 'system' | 'user' | 'assistant' | 'tool';
   readonly content: string;
+  readonly anthropicContent?: readonly unknown[];
   readonly toolCalls?: readonly GatewayToolCall[];
   readonly toolCallId?: string;
 }
@@ -25,6 +27,7 @@ export interface GatewayChatMessage {
 export interface GatewayChatResponse {
   readonly text: string;
   readonly toolCalls: readonly GatewayToolCall[];
+  readonly anthropicContent?: readonly unknown[];
 }
 
 class GatewayHttpError extends Error {
@@ -37,14 +40,32 @@ class GatewayHttpError extends Error {
   }
 }
 
-export async function createGatewayChatCompletion(input: {
+interface GatewayChatCompletionInput {
+  readonly protocol: GatewayProtocol;
   readonly baseUrl: string;
   readonly apiKey: string;
   readonly headers: Readonly<Record<string, string>>;
   readonly model: string;
+  readonly maxTokens?: number;
   readonly messages: readonly GatewayChatMessage[];
   readonly tools: readonly GatewayChatToolDefinition[];
-}): Promise<GatewayChatResponse> {
+}
+
+export function createGatewayChatCompletion(
+  input: GatewayChatCompletionInput
+): Promise<GatewayChatResponse> {
+  if (input.protocol === 'anthropic') {
+    if (input.maxTokens === undefined) {
+      throw new Error('Gateway Anthropic requests require maxTokens.');
+    }
+    return createAnthropicChatCompletion({ ...input, maxTokens: input.maxTokens });
+  }
+  return createOpenAIChatCompletion(input);
+}
+
+async function createOpenAIChatCompletion(
+  input: GatewayChatCompletionInput
+): Promise<GatewayChatResponse> {
   const response = await fetch(`${input.baseUrl}/chat/completions`, {
     method: 'POST',
     headers: {
@@ -54,7 +75,8 @@ export async function createGatewayChatCompletion(input: {
     },
     body: JSON.stringify({
       model: input.model,
-      messages: input.messages.map((message) => serializeMessage(message)),
+      ...(input.maxTokens === undefined ? {} : { max_tokens: input.maxTokens }),
+      messages: input.messages.map((message) => serializeOpenAIMessage(message)),
       tools: input.tools,
       tool_choice: 'auto',
       temperature: 0,
@@ -85,7 +107,51 @@ export async function createGatewayChatCompletion(input: {
   };
 }
 
-function serializeMessage(message: GatewayChatMessage): Record<string, unknown> {
+async function createAnthropicChatCompletion(
+  input: GatewayChatCompletionInput & { readonly maxTokens: number }
+): Promise<GatewayChatResponse> {
+  const system = input.messages
+    .filter((message) => message.role === 'system')
+    .map((message) => message.content)
+    .join('\n\n');
+  const response = await fetch(`${input.baseUrl}/v1/messages`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-api-key': input.apiKey,
+      'anthropic-version': '2023-06-01',
+      ...input.headers,
+    },
+    body: JSON.stringify({
+      model: input.model,
+      max_tokens: input.maxTokens,
+      ...(system ? { system } : {}),
+      messages: serializeAnthropicMessages(input.messages),
+      tools: input.tools.map((tool) => ({
+        name: tool.function.name,
+        description: tool.function.description,
+        input_schema: tool.function.parameters,
+      })),
+    }),
+  });
+
+  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 anthropicContent = getArray(parsed, 'content');
+  return {
+    text: getAnthropicMessageText(parsed),
+    toolCalls: getAnthropicToolCalls(parsed),
+    anthropicContent,
+  };
+}
+
+function serializeOpenAIMessage(message: GatewayChatMessage): Record<string, unknown> {
   if (message.role === 'assistant' && message.toolCalls && message.toolCalls.length > 0) {
     return {
       role: 'assistant',
@@ -113,6 +179,48 @@ function serializeMessage(message: GatewayChatMessage): Record<string, unknown>
   };
 }
 
+function serializeAnthropicMessages(
+  messages: readonly GatewayChatMessage[]
+): readonly Record<string, unknown>[] {
+  const result: Record<string, unknown>[] = [];
+  let pendingToolResults: Record<string, unknown>[] | undefined;
+  for (const message of messages) {
+    if (message.role === 'system') continue;
+    if (message.role === 'tool') {
+      const toolResult = {
+        type: 'tool_result',
+        tool_use_id: message.toolCallId,
+        content: message.content,
+      };
+      if (pendingToolResults) {
+        pendingToolResults.push(toolResult);
+      } else {
+        pendingToolResults = [toolResult];
+        result.push({ role: 'user', content: pendingToolResults });
+      }
+      continue;
+    }
+    pendingToolResults = undefined;
+    if (message.role === 'assistant' && message.toolCalls && message.toolCalls.length > 0) {
+      result.push({
+        role: 'assistant',
+        content: message.anthropicContent ?? [
+          ...(message.content ? [{ type: 'text', text: message.content }] : []),
+          ...message.toolCalls.map((toolCall) => ({
+            type: 'tool_use',
+            id: toolCall.id,
+            name: toolCall.name,
+            input: tryParseJson(toolCall.argumentsText) ?? {},
+          })),
+        ],
+      });
+      continue;
+    }
+    result.push({ role: message.role, content: message.content });
+  }
+  return result;
+}
+
 function getGatewayMessageText(message: Record<string, unknown>): string {
   const content = message.content;
   if (typeof content === 'string') return content;
@@ -143,6 +251,29 @@ function getGatewayToolCalls(message: Record<string, unknown>): readonly Gateway
   return result;
 }
 
+function getAnthropicMessageText(message: Record<string, unknown>): string {
+  return getArray(message, 'content')
+    .filter((item) => isRecord(item) && getString(item, 'type') === 'text')
+    .map((item) => (isRecord(item) ? getString(item, 'text') ?? '' : ''))
+    .join('');
+}
+
+function getAnthropicToolCalls(message: Record<string, unknown>): readonly GatewayToolCall[] {
+  const result: GatewayToolCall[] = [];
+  for (const item of getArray(message, 'content')) {
+    if (!isRecord(item) || getString(item, 'type') !== 'tool_use') continue;
+    const id = getString(item, 'id');
+    const name = getString(item, 'name');
+    if (!id || !name) continue;
+    result.push({
+      id,
+      name,
+      argumentsText: JSON.stringify(isRecord(item.input) ? item.input : {}),
+    });
+  }
+  return result;
+}
+
 function httpError(status: number, body: unknown): GatewayHttpError {
   return new GatewayHttpError(status, buildGatewayErrorMessage(status, body));
 }

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

@@ -164,10 +164,12 @@ async function runGatewayLoop(
 
   for (let turn = 0; turn < MAX_GATEWAY_TURNS; turn += 1) {
     const response = await createGatewayChatCompletion({
+      protocol: gateway.protocol,
       baseUrl: gateway.baseUrl,
       apiKey: gateway.apiKey,
       headers: gateway.headers,
       model: gateway.model,
+      ...(gateway.maxTokens === undefined ? {} : { maxTokens: gateway.maxTokens }),
       messages,
       tools: TOOL_DEFINITIONS,
     });
@@ -184,6 +186,9 @@ async function runGatewayLoop(
     messages.push({
       role: 'assistant',
       content: response.text,
+      ...(response.anthropicContent === undefined
+        ? {}
+        : { anthropicContent: response.anthropicContent }),
       toolCalls: response.toolCalls,
     });
 

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

@@ -5,6 +5,7 @@ import { contractError, invalidField } from './contract-errors';
 import { getString, isRecord, unknownToMessage } from './json';
 import type {
   GatewayBuildOptions,
+  GatewayProtocol,
   GatewayToolPolicy,
   ResolvedGatewayBuildOptions,
 } from './types';
@@ -48,15 +49,19 @@ export function normalizeGatewayBuildOptions(
   }
 
   const result: Record<string, unknown> = {};
+  const protocol = optionalGatewayProtocol(value.protocol, `${field}.protocol`);
   const baseUrl = optionalString(value.baseUrl, `${field}.baseUrl`);
   const apiKey = optionalString(value.apiKey, `${field}.apiKey`);
   const model = optionalNullableString(value.model, `${field}.model`);
+  const maxTokens = optionalNullablePositiveInteger(value.maxTokens, `${field}.maxTokens`);
   const headers = optionalStringRecord(value.headers, `${field}.headers`);
   const toolPolicy = optionalGatewayToolPolicy(value.toolPolicy, `${field}.toolPolicy`, cwd);
 
+  if (protocol !== undefined) result.protocol = protocol;
   if (baseUrl !== undefined) result.baseUrl = baseUrl;
   if (typeof apiKey === 'string') result.apiKey = apiKey;
   if (model !== undefined) result.model = model;
+  if (maxTokens !== undefined) result.maxTokens = maxTokens;
   if (headers !== undefined) result.headers = headers;
   if (toolPolicy !== undefined) result.toolPolicy = toolPolicy;
 
@@ -76,27 +81,51 @@ export function resolveGatewayConfiguration(
       message: `${field} is required for the gateway provider.`,
     });
   }
+  const protocol = value.protocol ?? 'openai';
   const baseUrl = requiredNonEmptyString(value.baseUrl, `${field}.baseUrl`);
   const apiKey = requiredNonEmptyString(value.apiKey, `${field}.apiKey`);
   const model = requiredNonEmptyString(value.model, `${field}.model`);
+  const maxTokens = value.maxTokens;
   const headers = value.headers ?? {};
   const toolPolicy = requiredGatewayToolPolicy(value.toolPolicy, `${field}.toolPolicy`, cwd);
 
+  if (protocol === 'anthropic' && maxTokens === undefined) {
+    invalidField(
+      `${field}.maxTokens`,
+      `${field}.maxTokens is required when ${field}.protocol is "anthropic".`
+    );
+  }
   assertValidGatewayBaseUrl(baseUrl, `${field}.baseUrl`);
   return {
+    protocol,
     baseUrl: normalizeBaseUrl(baseUrl),
     apiKey,
     headers,
     model,
+    ...(maxTokens === undefined ? {} : { maxTokens }),
     toolPolicy,
   };
 }
 
 export function validateGatewaySettings(settings: Record<string, unknown>): string | null {
   try {
+    const protocol = optionalGatewayProtocol(
+      settings.protocol,
+      'providerSettings.gateway.protocol'
+    );
     optionalString(settings.baseUrl, 'providerSettings.gateway.baseUrl');
     optionalString(settings.apiKey, 'providerSettings.gateway.apiKey');
     optionalNullableString(settings.model, 'providerSettings.gateway.model');
+    const maxTokens = optionalNullablePositiveInteger(
+      settings.maxTokens,
+      'providerSettings.gateway.maxTokens'
+    );
+    if (protocol === 'anthropic' && maxTokens === undefined) {
+      invalidField(
+        'providerSettings.gateway.maxTokens',
+        'providerSettings.gateway.maxTokens is required when providerSettings.gateway.protocol is "anthropic".'
+      );
+    }
     optionalStringRecord(settings.headers, 'providerSettings.gateway.headers');
     optionalGatewayToolPolicy(
       settings.toolPolicy,
@@ -595,6 +624,17 @@ function optionalFiniteInteger(value: unknown, field: string): number | undefine
   return requiredFiniteInteger(value, field);
 }
 
+function optionalNullablePositiveInteger(value: unknown, field: string): number | undefined {
+  if (value === undefined || value === null) return undefined;
+  return requiredFiniteInteger(value, field);
+}
+
+function optionalGatewayProtocol(value: unknown, field: string): GatewayProtocol | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (value === 'openai' || value === 'anthropic') return value;
+  invalidField(field, `${field} must be "openai" or "anthropic".`);
+}
+
 function requiredFiniteInteger(value: unknown, field: string): number {
   if (typeof value === 'number' && Number.isInteger(value) && value > 0) return value;
   invalidField(field, `${field} must be a positive integer.`);

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

@@ -68,6 +68,7 @@ export type {
   ErrorClassificationKind,
   GatewayBuildOptions,
   GatewayCliFeatures,
+  GatewayProtocol,
   GatewayToolPolicy,
   GeminiCliFeatures,
   KnownProviderName,

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

@@ -227,10 +227,18 @@ export const providerRegistry = [
     invoke: SPAWN_INVOKE,
     installInstructions: 'Bundled with Zeroshot; no external provider CLI install is required.',
     authInstructions:
-      'Configure providerSettings.gateway.baseUrl, apiKey, model, and toolPolicy in Zeroshot settings.',
+      'Configure providerSettings.gateway.protocol, baseUrl, apiKey, model, maxTokens when required, and toolPolicy in Zeroshot settings.',
     credentialPaths: [],
     credentialEnvKeys: gatewayAdapter.credentialEnvKeys,
-    settingsFields: ['baseUrl', 'apiKey', 'headers', 'model', 'toolPolicy'],
+    settingsFields: [
+      'protocol',
+      'baseUrl',
+      'apiKey',
+      'headers',
+      'model',
+      'maxTokens',
+      'toolPolicy',
+    ],
     settingsDefaults: gatewaySettingsDefaults,
     settingsValidator: validateGatewaySettings,
     capabilities: {

package/src/agent-cli-provider/single-agent-runtime.ts

@@ -228,6 +228,9 @@ function resolveRuntimeGatewayOptions(
       ? settingsGateway.headers
       : { ...(settingsGateway.headers ?? {}), ...requestGateway.headers };
   const mergedGateway: GatewayBuildOptions = {
+    ...(requestGateway.protocol ?? settingsGateway.protocol
+      ? { protocol: requestGateway.protocol ?? settingsGateway.protocol }
+      : {}),
     ...((requestGateway.baseUrl ?? settingsGateway.baseUrl)
       ? { baseUrl: requestGateway.baseUrl ?? settingsGateway.baseUrl }
       : {}),
@@ -236,6 +239,9 @@ function resolveRuntimeGatewayOptions(
       : {}),
     ...(mergedHeaders === undefined ? {} : { headers: mergedHeaders }),
     model: requestGateway.model ?? modelSpec.model ?? settingsGateway.model ?? null,
+    ...(requestGateway.maxTokens ?? settingsGateway.maxTokens
+      ? { maxTokens: requestGateway.maxTokens ?? settingsGateway.maxTokens }
+      : {}),
     ...((requestGateway.toolPolicy ?? settingsGateway.toolPolicy)
       ? { toolPolicy: requestGateway.toolPolicy ?? settingsGateway.toolPolicy }
       : {}),

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

@@ -17,6 +17,7 @@ export type KnownProviderName = ProviderId | ProviderAlias;
 export type ModelLevel = 'level1' | 'level2' | 'level3';
 export type ReasoningEffort = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
 export type OutputFormat = 'text' | 'json' | 'stream-json';
+export type GatewayProtocol = 'openai' | 'anthropic';
 export type {
   ProviderCapabilities,
   ProviderCapabilityState,
@@ -66,18 +67,22 @@ export interface GatewayToolPolicy {
 }
 
 export interface GatewayBuildOptions {
+  readonly protocol?: GatewayProtocol;
   readonly baseUrl?: string;
   readonly apiKey?: string;
   readonly headers?: Readonly<Record<string, string>>;
   readonly model?: string | null;
+  readonly maxTokens?: number;
   readonly toolPolicy?: GatewayToolPolicy;
 }
 
 export interface ResolvedGatewayBuildOptions {
+  readonly protocol: GatewayProtocol;
   readonly baseUrl: string;
   readonly apiKey: string;
   readonly headers: Readonly<Record<string, string>>;
   readonly model: string;
+  readonly maxTokens?: number;
   readonly toolPolicy: GatewayToolPolicy;
 }
 

package/src/preflight.js

@@ -426,11 +426,12 @@ function validateGatewayProvider() {
     errors: [
       formatError(
         'Gateway provider not configured',
-        'providerSettings.gateway must define baseUrl, apiKey, model, and toolPolicy before gateway can run.',
+        'providerSettings.gateway must define protocol, baseUrl, apiKey, model, and toolPolicy before gateway can run.',
         [
           'Run: zeroshot settings',
-          'Set providerSettings.gateway.baseUrl to your OpenAI-compatible endpoint base URL',
+          'Set providerSettings.gateway.protocol and baseUrl for your compatible endpoint',
           'Set providerSettings.gateway.apiKey and providerSettings.gateway.model',
+          'Set providerSettings.gateway.maxTokens when protocol is anthropic',
           'Set providerSettings.gateway.toolPolicy.roots and toolPolicy.commands explicitly',
         ]
       ),