@shipfox/api-agent 13.1.0 → 14.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-agent",
   "license": "MIT",
-  "version": "13.1.0",
+  "version": "14.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -39,7 +39,7 @@
     "drizzle-orm": "^0.45.2",
     "zod": "^4.4.3",
     "@shipfox/node-error-monitoring": "0.3.0",
-    "@shipfox/api-agent-dto": "13.1.0",
+    "@shipfox/api-agent-dto": "14.0.0",
     "@shipfox/api-auth-context": "12.2.0",
     "@shipfox/api-secrets-dto": "12.0.0",
     "@shipfox/inter-module": "0.2.3",

package/src/config.test.ts

@@ -155,6 +155,23 @@ describe('agent config', () => {
       }),
       'model API is invalid',
     ],
+    ...(
+      [
+        ['null context window', {context_window: null}],
+        ['zero max output tokens', {max_output_tokens: 0}],
+        ['fractional context window', {context_window: 1.5}],
+        ['string context window', {context_window: '128000'}],
+        ['non-boolean reasoning', {reasoning: 'true'}],
+        ['non-boolean input image', {input_image: 1}],
+      ] as const
+    ).map(
+      ([name, metadata]) =>
+        [
+          `invalid ${name}`,
+          managedProviderWithModelMetadata(metadata),
+          'model metadata is invalid',
+        ] as const,
+    ),
     [
       'unregistered default model',
       managedProvider({defaultModel: 'missing-model'}),
@@ -277,3 +294,17 @@ function managedProvider(overrides: Partial<ManagedModelProvider> = {}): Managed
     ...overrides,
   };
 }
+
+function managedProviderWithModelMetadata(metadata: object): ManagedModelProvider {
+  return managedProvider({
+    models: [
+      {
+        id: 'managed-model',
+        label: 'Managed model',
+        api: 'anthropic-messages',
+        ...metadata,
+      } as ManagedModelEntry,
+    ],
+    defaultModel: 'managed-model',
+  });
+}

package/src/config.ts

@@ -4,6 +4,7 @@ import {
   isReservedModelProviderId,
   type ManagedModelProvider,
   managedModelApiSchema,
+  managedModelMetadataSchema,
   modelProviderRefSchema,
   SUPPORTED_MODEL_PROVIDER_IDS,
   type WorkspaceProvidersPolicy,
@@ -143,6 +144,11 @@ function assertManagedProvider(provider: ManagedModelProvider): void {
     if (!managedModelApiSchema.safeParse(model.api).success) {
       throw new Error(`Managed model provider model API is invalid: ${provider.id}/${model.id}.`);
     }
+    if (!managedModelMetadataSchema.safeParse(model).success) {
+      throw new Error(
+        `Managed model provider model metadata is invalid: ${provider.id}/${model.id}.`,
+      );
+    }
   }
 
   if (!modelIds.has(provider.defaultModel)) {

package/src/core/resolve-runtime-credentials.test.ts

@@ -78,12 +78,115 @@ describe('resolveRuntimeCredentials', () => {
         base_url: 'https://gateway.example.test',
         headers: [],
         secret_header_names: [],
-        models: [{id: 'responses-model', label: 'Responses model'}],
+        models: [
+          {
+            id: 'responses-model',
+            label: 'Responses model',
+            context_window: 1_000_000,
+            max_output_tokens: 65_536,
+            reasoning: true,
+            input_image: true,
+          },
+        ],
         requires_api_key: true,
       },
     });
   });
 
+  it('omits optional model metadata when the managed model entry does not carry it', async () => {
+    const resolveCredentials = vi.fn<ManagedModelProvider['resolveCredentials']>();
+    resolveCredentials.mockResolvedValue({
+      api: 'openai-completions',
+      baseUrl: 'https://gateway.example.test',
+      credentials: {api_key: 'managed-token'},
+    });
+
+    const result = await resolveRuntimeCredentials(
+      {
+        workspaceId,
+        runId: crypto.randomUUID(),
+        stepAttemptId: crypto.randomUUID(),
+        harness: 'pi',
+        provider: 'shipfox',
+        model: 'plain-model',
+        thinking: 'high',
+      },
+      {managedProvider: managedProvider(resolveCredentials)},
+    );
+
+    expect(result).toEqual({
+      harness: 'pi',
+      provider_id: 'shipfox',
+      model: 'plain-model',
+      thinking: 'high',
+      credentials: {api_key: 'managed-token'},
+      custom_provider: {
+        api: 'openai-completions',
+        base_url: 'https://gateway.example.test',
+        headers: [],
+        secret_header_names: [],
+        models: [{id: 'plain-model', label: 'Plain model'}],
+        requires_api_key: true,
+      },
+    });
+  });
+
+  it('forwards partial managed model metadata, including false values', async () => {
+    const resolveCredentials = vi.fn<ManagedModelProvider['resolveCredentials']>();
+    resolveCredentials.mockResolvedValue({
+      api: 'openai-completions',
+      baseUrl: 'https://gateway.example.test',
+      credentials: {api_key: 'managed-token'},
+    });
+
+    const result = await resolveRuntimeCredentials(
+      {
+        workspaceId,
+        runId: crypto.randomUUID(),
+        stepAttemptId: crypto.randomUUID(),
+        harness: 'pi',
+        provider: 'shipfox',
+        model: 'partial-model',
+        thinking: 'high',
+      },
+      {managedProvider: managedProvider(resolveCredentials)},
+    );
+
+    expect(result.custom_provider?.models).toEqual([
+      {
+        id: 'partial-model',
+        label: 'Partial model',
+        max_output_tokens: 8_192,
+        reasoning: false,
+        input_image: false,
+      },
+    ]);
+  });
+
+  it('falls back to an unregistered managed model descriptor', async () => {
+    const resolveCredentials = vi.fn<ManagedModelProvider['resolveCredentials']>();
+    resolveCredentials.mockResolvedValue({
+      api: 'openai-completions',
+      baseUrl: 'https://gateway.example.test',
+      credentials: {api_key: 'managed-token'},
+    });
+
+    const result = await resolveRuntimeCredentials(
+      {
+        workspaceId,
+        runId: crypto.randomUUID(),
+        stepAttemptId: crypto.randomUUID(),
+        harness: 'pi',
+        provider: 'shipfox',
+        model: 'missing-model',
+        thinking: 'high',
+      },
+      {managedProvider: managedProvider(resolveCredentials)},
+    );
+
+    expect(result.custom_provider?.models).toEqual([{id: 'missing-model', label: 'missing-model'}]);
+  });
+
   it('resolves managed provider credentials into the Claude per-step contract', async () => {
     const resolveCredentials = vi.fn<ManagedModelProvider['resolveCredentials']>();
     resolveCredentials.mockResolvedValue({
@@ -476,7 +579,24 @@ function managedProvider(
     label: 'Shipfox',
     models: [
       {id: 'claude-model', label: 'Claude model', api: 'anthropic-messages'},
-      {id: 'responses-model', label: 'Responses model', api: 'openai-responses'},
+      {
+        id: 'responses-model',
+        label: 'Responses model',
+        api: 'openai-responses',
+        context_window: 1_000_000,
+        max_output_tokens: 65_536,
+        reasoning: true,
+        input_image: true,
+      },
+      {
+        id: 'partial-model',
+        label: 'Partial model',
+        api: 'openai-completions',
+        max_output_tokens: 8_192,
+        reasoning: false,
+        input_image: false,
+      },
+      {id: 'plain-model', label: 'Plain model', api: 'openai-completions'},
     ],
     defaultModel: 'responses-model',
     resolveCredentials,

package/src/core/resolve-runtime-credentials.ts

@@ -8,6 +8,7 @@ import type {
   SupportedModelProviderId,
   WorkspaceProvidersPolicy,
 } from '@shipfox/api-agent-dto';
+import {toCustomAgentModelDto} from '@shipfox/api-agent-dto';
 import {secretsInterModuleContract} from '@shipfox/api-secrets-dto/inter-module';
 import {isInterModuleKnownError} from '@shipfox/inter-module';
 import {config, workspaceProvidersPolicy} from '#config.js';
@@ -198,7 +199,7 @@ function toResponse(
 
   if (managed !== undefined) {
     const model = managed.provider.models.find((candidate) => candidate.id === params.model);
-    const modelDescriptor = {id: params.model, label: model?.label ?? params.model};
+    const modelDescriptor = toCustomAgentModelDto(model ?? {id: params.model, label: params.model});
 
     if (params.harness === 'pi') {
       response.custom_provider = {