@shipfox/api-agent-dto 12.2.0 → 13.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-agent-dto",
   "license": "MIT",
-  "version": "12.2.0",
+  "version": "13.1.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",

package/src/index.ts

@@ -14,6 +14,7 @@ export {
   agentThinkingSchema,
   buildHarnessToolDeploymentConfig,
   CLAUDE_HARNESS,
+  type ClaudeRuntimeConfigDto,
   type CreateCustomModelProviderBodyDto,
   type CustomAgentModelDto,
   type CustomModelProviderConfigDto,
@@ -21,6 +22,7 @@ export {
   type CustomModelProviderHeaderRequestDto,
   type CustomModelProviderRuntimeConfigDto,
   claudeAgentThinkingSchema,
+  claudeRuntimeConfigSchema,
   createCustomModelProviderBodySchema,
   customAgentModelSchema,
   customModelProviderConfigDtoSchema,
@@ -64,6 +66,10 @@ export {
   listModelProviderConfigsResponseSchema,
   listSupportedModelProviders,
   MAX_MODEL_COUNT,
+  type ManagedModelApi,
+  type ManagedModelEntry,
+  type ManagedModelProvider,
+  type ManagedProviderRuntimeConfig,
   type MaterializedAgentIntegrationConfigDto,
   type MaterializedAgentIntegrationToolConfigDto,
   type MaterializedAgentStepConfigDto,
@@ -80,6 +86,7 @@ export {
   type ModelProviderId,
   type ModelProviderRef,
   type ModelProviderSupportStatus,
+  managedModelApiSchema,
   materializedAgentIntegrationSchema,
   materializedAgentIntegrationToolSchema,
   materializedAgentStepConfigSchema,
@@ -119,4 +126,6 @@ export {
   updateCustomModelProviderHeaderRequestSchema,
   updateModelProviderConfigBodySchema,
   updateModelProviderDefaultModelBodySchema,
+  type WorkspaceProvidersPolicy,
+  workspaceProvidersPolicySchema,
 } from '#schemas/index.js';

package/src/inter-module.ts

@@ -55,11 +55,18 @@ export const agentInterModuleContract = defineInterModuleContract({
     resolveAgentConfig: {
       input: z.object({workspaceId: z.string().uuid().nullable(), config: agentConfigInputSchema}),
       output: resolvedAgentConfigSchema,
-      errors: {'agent-config-invalid': z.object({})},
+      errors: {
+        'agent-config-invalid': z.object({
+          message: z.string().min(1).optional(),
+          managed_provider_id: modelProviderRefSchema.optional(),
+        }),
+      },
     },
     resolveRuntimeCredentials: {
       input: z.object({
         workspaceId: z.string().uuid(),
+        runId: z.string().uuid(),
+        stepAttemptId: z.string().uuid(),
         harness: harnessSchema,
         provider: modelProviderRefSchema,
         model: z.string(),
@@ -69,6 +76,10 @@ export const agentInterModuleContract = defineInterModuleContract({
       errors: {
         'model-provider-not-configured': z.object({}),
         'model-provider-credentials-invalid': z.object({}),
+        'workspace-providers-disabled': z.object({
+          message: z.string().min(1).optional(),
+          managed_provider_id: modelProviderRefSchema,
+        }),
       },
     },
   },

package/src/schemas/catalog.test.ts

@@ -5,6 +5,7 @@ import {
   listSupportedModelProviders,
   MODEL_PROVIDER_CATALOG_SEED,
   modelProviderCatalogEntrySchema,
+  modelProviderCatalogResponseSchema,
   modelProviderCatalogSeedSchema,
 } from './catalog.js';
 import {
@@ -13,6 +14,16 @@ import {
   UNSUPPORTED_MODEL_PROVIDER_IDS,
 } from './model-provider-id.js';
 
+const managedProviderCatalogEntry = {
+  id: 'shipfox-managed',
+  label: 'Shipfox Managed',
+  support_status: 'supported',
+  default_model: 'managed-claude',
+  credential_fields: [],
+  unsupported_reason: null,
+  models: [{id: 'managed-claude', label: 'Managed Claude'}],
+};
+
 describe('model provider catalog', () => {
   it('parses the catalog seed', () => {
     const parsed = modelProviderCatalogSeedSchema.array().parse(MODEL_PROVIDER_CATALOG_SEED);
@@ -152,6 +163,33 @@ describe('model provider catalog', () => {
     expect(parsed).toHaveLength(37);
   });
 
+  it('parses a managed provider response entry', () => {
+    const parsed = modelProviderCatalogEntrySchema.parse(managedProviderCatalogEntry);
+
+    expect(parsed.id).toBe('shipfox-managed');
+  });
+
+  it('parses enabled and disabled policies through the full catalog response', () => {
+    for (const workspaceProviders of ['enabled', 'disabled'] as const) {
+      const parsed = modelProviderCatalogResponseSchema.parse({
+        providers: [managedProviderCatalogEntry],
+        workspace_providers: workspaceProviders,
+      });
+
+      expect(parsed.workspace_providers).toBe(workspaceProviders);
+    }
+  });
+
+  it('rejects an invalid workspace provider policy in the full catalog response', () => {
+    const parse = () =>
+      modelProviderCatalogResponseSchema.parse({
+        providers: [managedProviderCatalogEntry],
+        workspace_providers: 'invalid',
+      });
+
+    expect(parse).toThrow();
+  });
+
   it('rejects a supported response entry without models', () => {
     const supportedEntry = getModelProviderEntry('openai');
     if (supportedEntry === undefined) throw new Error('Missing OpenAI catalog entry');

package/src/schemas/catalog.ts

@@ -10,8 +10,10 @@ import {
   thinkingLevelsForHarness,
 } from '@shipfox/workflow-document';
 import {z} from 'zod';
+import {managedModelApiSchema} from './managed-provider.js';
 import {
   type ModelProviderId,
+  modelProviderRefSchema,
   providerIdSchema,
   SUPPORTED_MODEL_PROVIDER_IDS,
   type SupportedModelProviderId,
@@ -34,6 +36,7 @@ export {
 export const agentModelOptionSchema = z.object({
   id: z.string().min(1),
   label: z.string().min(1),
+  api: managedModelApiSchema.optional(),
 });
 
 export type AgentModelOptionDto = z.infer<typeof agentModelOptionSchema>;
@@ -50,6 +53,10 @@ export const modelProviderSupportStatusSchema = z.enum(['supported', 'unsupporte
 
 export type ModelProviderSupportStatus = z.infer<typeof modelProviderSupportStatusSchema>;
 
+export const workspaceProvidersPolicySchema = z.enum(['enabled', 'disabled']);
+
+export type WorkspaceProvidersPolicy = z.infer<typeof workspaceProvidersPolicySchema>;
+
 const supportedModelProviderIds = new Set<string>(SUPPORTED_MODEL_PROVIDER_IDS);
 const unsupportedModelProviderIds = new Set<string>(UNSUPPORTED_MODEL_PROVIDER_IDS);
 
@@ -67,12 +74,24 @@ export const modelProviderCatalogSeedSchema =
 
 export type ModelProviderCatalogSeedDto = z.infer<typeof modelProviderCatalogSeedSchema>;
 
-export const modelProviderCatalogEntrySchema = modelProviderCatalogSeedBaseSchema
+const modelProviderCatalogEntryBaseSchema = z.object({
+  id: modelProviderRefSchema,
+  label: z.string().min(1),
+  support_status: modelProviderSupportStatusSchema,
+  default_model: z.string().min(1).nullable(),
+  credential_fields: z.array(modelProviderCredentialFieldSchema),
+  unsupported_reason: z.string().min(1).nullable(),
+});
+
+export const modelProviderCatalogEntrySchema = modelProviderCatalogEntryBaseSchema
   .extend({
     models: z.array(agentModelOptionSchema),
   })
   .superRefine((entry, ctx) => {
-    validateCatalogSeedEntry(entry, ctx);
+    const seedId = providerIdSchema.safeParse(entry.id);
+    if (seedId.success) {
+      validateCatalogSeedEntry({...entry, id: seedId.data}, ctx);
+    }
 
     if (entry.support_status === 'supported') {
       if (entry.models.length === 0) {
@@ -105,6 +124,7 @@ export type ModelProviderCatalogEntryDto = z.infer<typeof modelProviderCatalogEn
 
 export const modelProviderCatalogResponseSchema = z.object({
   providers: z.array(modelProviderCatalogEntrySchema),
+  workspace_providers: workspaceProvidersPolicySchema.optional(),
 });
 
 export type ModelProviderCatalogResponseDto = z.infer<typeof modelProviderCatalogResponseSchema>;

package/src/schemas/index.ts

@@ -25,6 +25,8 @@ export {
   modelProviderSupportStatusSchema,
   piAgentThinkingSchema,
   thinkingLevelsForHarness,
+  type WorkspaceProvidersPolicy,
+  workspaceProvidersPolicySchema,
 } from './catalog.js';
 export {
   type CreateCustomModelProviderBodyDto,
@@ -79,6 +81,13 @@ export {
   PI_HARNESS_TOOL_PACKAGE_NAMES,
   parsePiEnabledToolPackages,
 } from './harness.js';
+export {
+  type ManagedModelApi,
+  type ManagedModelEntry,
+  type ManagedModelProvider,
+  type ManagedProviderRuntimeConfig,
+  managedModelApiSchema,
+} from './managed-provider.js';
 export {
   AGENT_INTEGRATION_MCP_AUTH,
   AGENT_INTEGRATION_MCP_ENDPOINT,
@@ -127,6 +136,8 @@ export {
 export {
   type AgentRuntimeCredentialsResponseDto,
   agentRuntimeCredentialsResponseSchema,
+  type ClaudeRuntimeConfigDto,
+  claudeRuntimeConfigSchema,
 } from './runtime-config.js';
 export {
   type SetDefaultHarnessBodyDto,

package/src/schemas/managed-provider.ts

@@ -0,0 +1,36 @@
+import type {AgentThinking} from '@shipfox/workflow-document';
+import {z} from 'zod';
+
+export const managedModelApiSchema = z.enum([
+  'anthropic-messages',
+  'openai-responses',
+  'openai-completions',
+]);
+
+export type ManagedModelApi = z.infer<typeof managedModelApiSchema>;
+
+export interface ManagedModelEntry {
+  readonly id: string;
+  readonly label: string;
+  readonly api: ManagedModelApi;
+}
+
+export interface ManagedProviderRuntimeConfig {
+  readonly api: ManagedModelApi;
+  readonly baseUrl: string;
+  readonly credentials: Record<string, string>;
+}
+
+export interface ManagedModelProvider {
+  readonly id: string;
+  readonly label: string;
+  readonly models: readonly ManagedModelEntry[];
+  readonly defaultModel: string;
+  readonly defaultThinking?: AgentThinking | undefined;
+  readonly resolveCredentials: (params: {
+    workspaceId: string;
+    runId: string;
+    stepAttemptId: string;
+    model: string;
+  }) => Promise<ManagedProviderRuntimeConfig>;
+}

package/src/schemas/runtime-config.test.ts

@@ -34,6 +34,25 @@ describe('agentRuntimeCredentialsResponseSchema', () => {
     expect(parsed.custom_provider?.api).toBe('openai-responses');
   });
 
+  it('parses managed Claude runtime credentials without a custom provider descriptor', () => {
+    const parsed = agentRuntimeCredentialsResponseSchema.parse({
+      harness: 'claude',
+      provider_id: 'shipfox',
+      model: 'managed-claude',
+      thinking: 'high',
+      credentials: {api_key: 'managed-token'},
+      claude: {
+        base_url: 'https://gateway.example.test',
+        auth_token: 'managed-token',
+      },
+    });
+
+    expect(parsed.claude).toEqual({
+      base_url: 'https://gateway.example.test',
+      auth_token: 'managed-token',
+    });
+  });
+
   it('rejects a custom model provider descriptor without key intent', () => {
     const parse = () =>
       agentRuntimeCredentialsResponseSchema.parse({

package/src/schemas/runtime-config.ts

@@ -6,6 +6,13 @@ import {isReservedModelProviderId, modelProviderRefSchema} from './model-provide
 const credentialKeySchema = z.string().min(1);
 const credentialValueSchema = z.string().min(1);
 
+export const claudeRuntimeConfigSchema = z.object({
+  base_url: z.string().url().max(2048),
+  auth_token: credentialValueSchema,
+});
+
+export type ClaudeRuntimeConfigDto = z.infer<typeof claudeRuntimeConfigSchema>;
+
 /**
  * Lease-scoped runtime credentials. The credential values are secrets and must
  * never be written to logs, traces, client state, or generic catalog surfaces.
@@ -18,9 +25,14 @@ export const agentRuntimeCredentialsResponseSchema = z
     thinking: agentThinkingSchema,
     credentials: z.record(credentialKeySchema, credentialValueSchema),
     custom_provider: customModelProviderRuntimeConfigSchema.optional(),
+    claude: claudeRuntimeConfigSchema.optional(),
   })
   .superRefine((response, ctx) => {
-    if (isReservedModelProviderId(response.provider_id) || response.custom_provider !== undefined) {
+    if (
+      isReservedModelProviderId(response.provider_id) ||
+      response.custom_provider !== undefined ||
+      response.claude !== undefined
+    ) {
       return;
     }