@shipfox/client-agent 23.0.0 → 25.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/client-agent",
   "license": "MIT",
-  "version": "23.0.0",
+  "version": "25.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -28,10 +28,10 @@
     "@swc/helpers": "^0.5.17",
     "@tanstack/react-form": "^1.32.0",
     "@tanstack/react-query": "^5.101.0",
-    "@shipfox/api-agent-dto": "14.0.0",
     "@shipfox/client-api": "6.0.1",
-    "@shipfox/client-shell": "23.0.0",
-    "@shipfox/client-ui": "22.0.3",
+    "@shipfox/client-shell": "25.0.0",
+    "@shipfox/client-ui": "24.0.0",
+    "@shipfox/api-agent-dto": "16.0.0",
     "@shipfox/react-ui": "2.2.0"
   },
   "peerDependencies": {

package/src/components/agent-workflow-example.test.ts

@@ -68,7 +68,7 @@ describe('buildAgentWorkflowExample', () => {
     expect(lines).toContain(expectedHarness);
     expect(lines).toContain(expectedProvider);
     expect(lines).toContain(expectedModel);
-    expect(example.highlightedLineRange).toEqual({startLine: 11, endLine: 13});
-    expect(lines.slice(10, 13)).toEqual([expectedHarness, expectedProvider, expectedModel]);
+    expect(example.highlightedLineRange).toEqual({startLine: 10, endLine: 12});
+    expect(lines.slice(9, 12)).toEqual([expectedHarness, expectedProvider, expectedModel]);
   });
 });

package/src/components/agent-workflow-example.ts

@@ -22,7 +22,6 @@ export function buildAgentWorkflowExample({
     'triggers:',
     '  on_demand:',
     '    source: manual',
-    '    event: fire',
     'jobs:',
     '  agent:',
     '    runner: ubuntu-latest',

package/src/components/harness-availability.test.ts

@@ -44,7 +44,9 @@ describe('harness availability', () => {
 
   test('marks harnesses available from a managed-only catalog without workspace configs', () => {
     const catalog = toProviderCatalog(
-      modelProviderCatalogResponse([managedModelProviderEntry()], 'disabled'),
+      modelProviderCatalogResponse([managedModelProviderEntry()], 'disabled', {
+        managedProviderId: 'shipfox',
+      }),
     );
 
     expect(isHarnessAvailable(getHarness('pi'), [], catalog)).toBe(true);
@@ -61,6 +63,7 @@ describe('harness availability', () => {
           }),
         ],
         'disabled',
+        {managedProviderId: 'shipfox'},
       ),
     );
 

package/src/components/model-providers-section.stories.tsx

@@ -239,7 +239,9 @@ function fetchForScenario(scenario: Scenario): typeof fetch {
       return Promise.resolve(
         jsonResponse({
           providers: catalogForScenario(scenario),
-          ...(scenario === 'managed-only' ? {workspace_providers: 'disabled'} : {}),
+          ...(scenario === 'managed-only'
+            ? {workspace_providers: 'disabled', managed_provider_id: 'shipfox'}
+            : {}),
         }),
       );
     }

package/src/components/model-providers-section.test.tsx

@@ -66,7 +66,11 @@ describe('WorkspaceModelProvidersSection', () => {
     const fetchImpl = vi.fn((input: RequestInfo | URL) => {
       if (requestPath(input).endsWith('/agent/model-provider-catalog')) {
         return Promise.resolve(
-          jsonResponse(modelProviderCatalogResponse([managedModelProviderEntry()], 'disabled')),
+          jsonResponse(
+            modelProviderCatalogResponse([managedModelProviderEntry()], 'disabled', {
+              managedProviderId: 'shipfox',
+            }),
+          ),
         );
       }
       return Promise.resolve(
@@ -101,6 +105,29 @@ describe('WorkspaceModelProvidersSection', () => {
     expect(usageDialog).toHaveTextContent('model: claude-opus-4-8');
   });
 
+  test('renders managed provider models from an older managed-only catalog response', async () => {
+    const fetchImpl = vi.fn((input: RequestInfo | URL) => {
+      if (requestPath(input).endsWith('/agent/model-provider-catalog')) {
+        return Promise.resolve(
+          jsonResponse({
+            providers: [managedModelProviderEntry()],
+            workspace_providers: 'disabled',
+          }),
+        );
+      }
+      return Promise.resolve(
+        jsonResponse(modelProviderConfigsResponse({configs: [], default_provider_id: null})),
+      );
+    });
+    configureApiClient({baseUrl: 'https://api.example.test', fetchImpl});
+
+    renderModelProviders(<WorkspaceModelProvidersSection workspaceId={AGENT_TEST_WORKSPACE_ID} />);
+
+    expect(await screen.findByText('Managed provider')).toBeVisible();
+    expect(screen.getByText('Shipfox Managed')).toBeVisible();
+    expect(screen.queryByText('Managed provider unavailable')).not.toBeInTheDocument();
+  });
+
   test('renders configured, available, and unsupported providers', async () => {
     const fetchImpl = vi.fn((input: RequestInfo | URL) => {
       if (requestPath(input).endsWith('/agent/model-provider-catalog')) {

package/src/core/models.ts

@@ -79,6 +79,8 @@ export type ProviderConfig = BuiltinProviderConfig | CustomProviderConfig;
 export interface ProviderCatalog {
   readonly providers: readonly ProviderCatalogEntry[];
   readonly workspaceProviders: WorkspaceProvidersPolicy;
+  readonly managedProviderId: string | null;
+  readonly instanceDefaultProviderId: string | null;
 }
 
 export interface ProviderConfiguration {

package/src/core/provider-policy.test.ts

@@ -0,0 +1,78 @@
+import {toProviderCatalog} from '#hooks/api/model-provider-mapper.js';
+import {
+  managedModelProviderEntry,
+  modelProviderCatalogResponse,
+  modelProviderEntry,
+  unsupportedModelProviderEntry,
+} from '#test/fixtures/model-providers.js';
+import {isManagedOnlyCatalog, managedProviderFromCatalog} from './provider-policy.js';
+
+describe('managedProviderFromCatalog', () => {
+  test('returns the managed entry from a managed-only catalog', () => {
+    const catalog = toProviderCatalog(
+      modelProviderCatalogResponse([managedModelProviderEntry()], 'disabled', {
+        managedProviderId: 'shipfox',
+      }),
+    );
+
+    expect(managedProviderFromCatalog(catalog)).toMatchObject({
+      id: 'shipfox',
+      kind: 'supported',
+    });
+    expect(isManagedOnlyCatalog(catalog)).toBe(true);
+  });
+
+  test('returns the managed entry from a mixed catalog under the enabled policy', () => {
+    const catalog = toProviderCatalog(
+      modelProviderCatalogResponse([modelProviderEntry(), managedModelProviderEntry()], 'enabled', {
+        managedProviderId: 'shipfox',
+      }),
+    );
+
+    expect(managedProviderFromCatalog(catalog)).toMatchObject({
+      id: 'shipfox',
+      kind: 'supported',
+    });
+    expect(isManagedOnlyCatalog(catalog)).toBe(false);
+  });
+
+  test('falls back to the supported entry for older managed-only catalogs', () => {
+    const catalog = toProviderCatalog(
+      modelProviderCatalogResponse([managedModelProviderEntry()], 'disabled'),
+    );
+
+    expect(managedProviderFromCatalog(catalog)).toMatchObject({
+      id: 'shipfox',
+      kind: 'supported',
+    });
+    expect(isManagedOnlyCatalog(catalog)).toBe(true);
+  });
+
+  test('returns undefined without a managed provider id in a mixed catalog', () => {
+    const catalog = toProviderCatalog(modelProviderCatalogResponse());
+
+    expect(managedProviderFromCatalog(catalog)).toBeUndefined();
+    expect(managedProviderFromCatalog(undefined)).toBeUndefined();
+    expect(isManagedOnlyCatalog(catalog)).toBe(false);
+  });
+
+  test('returns undefined when the managed provider id is absent from the catalog', () => {
+    const catalog = toProviderCatalog(
+      modelProviderCatalogResponse([modelProviderEntry()], 'enabled', {
+        managedProviderId: 'missing-provider',
+      }),
+    );
+
+    expect(managedProviderFromCatalog(catalog)).toBeUndefined();
+  });
+
+  test('returns undefined when the managed provider entry is unsupported', () => {
+    const catalog = toProviderCatalog(
+      modelProviderCatalogResponse([unsupportedModelProviderEntry()], 'enabled', {
+        managedProviderId: 'amazon-bedrock',
+      }),
+    );
+
+    expect(managedProviderFromCatalog(catalog)).toBeUndefined();
+  });
+});

package/src/core/provider-policy.ts

@@ -21,8 +21,14 @@ export function isManagedOnlyCatalog(catalog: ProviderCatalog | undefined): bool
 export function managedProviderFromCatalog(
   catalog: ProviderCatalog | undefined,
 ): SupportedProvider | undefined {
-  if (!isManagedOnlyCatalog(catalog)) return undefined;
-  return catalog?.providers.find(isSupportedProvider);
+  const providers = catalog?.providers;
+  const managedProviderId = catalog?.managedProviderId;
+  if (providers === undefined) return undefined;
+  if (managedProviderId === null || managedProviderId === undefined) {
+    return isManagedOnlyCatalog(catalog) ? providers.find(isSupportedProvider) : undefined;
+  }
+  const managedEntry = providers.find((provider) => provider.id === managedProviderId);
+  return managedEntry !== undefined && isSupportedProvider(managedEntry) ? managedEntry : undefined;
 }
 
 export function availableProviders(

package/src/hooks/api/model-provider-mapper.test.ts

@@ -20,10 +20,14 @@ test('maps provider catalog entries before they reach the client domain', () =>
 
 test('maps the managed-only workspace policy and managed provider models', () => {
   const catalog = toProviderCatalog(
-    modelProviderCatalogResponse([managedModelProviderEntry()], 'disabled'),
+    modelProviderCatalogResponse([managedModelProviderEntry()], 'disabled', {
+      managedProviderId: 'shipfox',
+    }),
   );
 
   expect(catalog.workspaceProviders).toBe('disabled');
+  expect(catalog.managedProviderId).toBe('shipfox');
+  expect(catalog.instanceDefaultProviderId).toBeNull();
   expect(catalog.providers[0]).toEqual(
     expect.objectContaining({
       id: 'shipfox',
@@ -35,6 +39,20 @@ test('maps the managed-only workspace policy and managed provider models', () =>
   );
 });
 
+test('maps the managed provider id and instance default provider id from a mixed catalog', () => {
+  const catalog = toProviderCatalog(
+    modelProviderCatalogResponse([modelProviderEntry(), managedModelProviderEntry()], 'enabled', {
+      managedProviderId: 'shipfox',
+      instanceDefaultProviderId: 'anthropic',
+    }),
+  );
+
+  expect(catalog.workspaceProviders).toBe('enabled');
+  expect(catalog.managedProviderId).toBe('shipfox');
+  expect(catalog.instanceDefaultProviderId).toBe('anthropic');
+  expect(catalog.providers).toHaveLength(2);
+});
+
 test('maps configuration response defaults and provider config fields', () => {
   const configuration = toProviderConfiguration(modelProviderConfigsResponse());
 

package/src/hooks/api/model-provider-mapper.ts

@@ -24,6 +24,8 @@ export function toProviderCatalog(response: ModelProviderCatalogResponseDto): Pr
   return {
     providers: response.providers.map(toProviderCatalogEntry),
     workspaceProviders: response.workspace_providers ?? 'enabled',
+    managedProviderId: response.managed_provider_id ?? null,
+    instanceDefaultProviderId: response.instance_default_provider_id ?? null,
   };
 }
 

package/src/pages/model-provider-onboarding-page.test.tsx

@@ -79,11 +79,13 @@ describe('ModelProviderOnboardingPage', () => {
 
   test('continues directly when workspace providers are managed by the instance', async () => {
     const onConfigured = vi.fn();
-    const fetchImpl = vi
-      .fn()
-      .mockResolvedValue(
-        jsonResponse(modelProviderCatalogResponse([managedModelProviderEntry()], 'disabled')),
-      );
+    const fetchImpl = vi.fn().mockResolvedValue(
+      jsonResponse(
+        modelProviderCatalogResponse([managedModelProviderEntry()], 'disabled', {
+          managedProviderId: 'shipfox',
+        }),
+      ),
+    );
     configureApiClient({baseUrl: 'https://api.example.test', fetchImpl});
 
     renderOnboarding(

package/test/fixtures/model-providers.ts

@@ -113,10 +113,13 @@ export function customModelProviderConfig(
 export function modelProviderCatalogResponse(
   modelProviders: ModelProviderCatalogEntryDto[] = [modelProviderEntry()],
   workspaceProviders?: WorkspaceProvidersPolicy,
+  providerIds: {managedProviderId?: string | null; instanceDefaultProviderId?: string | null} = {},
 ): ModelProviderCatalogResponseDto {
   return {
     providers: modelProviders,
     ...(workspaceProviders === undefined ? {} : {workspace_providers: workspaceProviders}),
+    managed_provider_id: providerIds.managedProviderId ?? null,
+    instance_default_provider_id: providerIds.instanceDefaultProviderId ?? null,
   };
 }