@shipfox/client-agent 22.0.1 → 22.0.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/client-agent",
   "license": "MIT",
-  "version": "22.0.1",
+  "version": "22.0.3",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -28,11 +28,11 @@
     "@swc/helpers": "^0.5.17",
     "@tanstack/react-form": "^1.32.0",
     "@tanstack/react-query": "^5.101.0",
-    "@shipfox/api-agent-dto": "12.2.0",
+    "@shipfox/api-agent-dto": "13.1.0",
     "@shipfox/client-api": "6.0.1",
-    "@shipfox/client-shell": "22.0.1",
-    "@shipfox/client-ui": "22.0.0",
-    "@shipfox/react-ui": "2.1.0"
+    "@shipfox/client-shell": "22.0.3",
+    "@shipfox/client-ui": "22.0.3",
+    "@shipfox/react-ui": "2.2.0"
   },
   "peerDependencies": {
     "@tanstack/react-query": "^5.101.0",

package/src/components/form-errors.test.ts

@@ -80,6 +80,15 @@ describe('modelProviderConfigErrorToFormError', () => {
       }),
       'Configure this provider before setting it as the default.',
     ],
+    [
+      new ApiError({
+        code: 'workspace-providers-disabled',
+        message: 'Provider policy rejected the request.',
+        status: 422,
+        details: {message: 'This instance only supports provider `shipfox`.'},
+      }),
+      'This instance only supports provider `shipfox`.',
+    ],
     [
       new ApiError({code: 'not-found', message: 'Provider config not found', status: 404}),
       'This custom provider no longer exists. Refresh and try again.',

package/src/components/form-errors.ts

@@ -76,6 +76,9 @@ function apiErrorMessage(error: ApiError): string {
   if (error.code === 'provider-not-configured') {
     return 'Configure this provider before setting it as the default.';
   }
+  if (error.code === 'workspace-providers-disabled') {
+    return typeof details.message === 'string' ? details.message : error.message;
+  }
   return error.message;
 }
 

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

@@ -1,6 +1,11 @@
 import {getHarness} from '#core/harness-policy.js';
-import {toProviderConfig} from '#hooks/api/model-provider-mapper.js';
-import {customModelProviderConfig, modelProviderConfig} from '#test/fixtures/model-providers.js';
+import {toProviderCatalog, toProviderConfig} from '#hooks/api/model-provider-mapper.js';
+import {
+  customModelProviderConfig,
+  managedModelProviderEntry,
+  modelProviderCatalogResponse,
+  modelProviderConfig,
+} from '#test/fixtures/model-providers.js';
 import {compatibleHarnessIds, isHarnessAvailable} from './harness-availability.js';
 
 describe('harness availability', () => {
@@ -37,6 +42,32 @@ describe('harness availability', () => {
     expect(isHarnessAvailable(getHarness('claude'), [])).toBe(false);
   });
 
+  test('marks harnesses available from a managed-only catalog without workspace configs', () => {
+    const catalog = toProviderCatalog(
+      modelProviderCatalogResponse([managedModelProviderEntry()], 'disabled'),
+    );
+
+    expect(isHarnessAvailable(getHarness('pi'), [], catalog)).toBe(true);
+    expect(isHarnessAvailable(getHarness('claude'), [], catalog)).toBe(true);
+  });
+
+  test('does not mark Claude available when managed models do not support Anthropic messages', () => {
+    const catalog = toProviderCatalog(
+      modelProviderCatalogResponse(
+        [
+          managedModelProviderEntry({
+            default_model: 'gpt-5.5-pro',
+            models: [{id: 'gpt-5.5-pro', label: 'GPT-5.5 Pro', api: 'openai-responses'}],
+          }),
+        ],
+        'disabled',
+      ),
+    );
+
+    expect(isHarnessAvailable(getHarness('pi'), [], catalog)).toBe(true);
+    expect(isHarnessAvailable(getHarness('claude'), [], catalog)).toBe(false);
+  });
+
   test('returns compatible harnesses for builtin and custom providers', () => {
     expect(compatibleHarnessIds({isCustom: false, providerId: 'anthropic'})).toEqual([
       'pi',
@@ -44,5 +75,21 @@ describe('harness availability', () => {
     ]);
     expect(compatibleHarnessIds({isCustom: false, providerId: 'openai'})).toEqual(['pi']);
     expect(compatibleHarnessIds({isCustom: true, providerId: 'custom-provider'})).toEqual(['pi']);
+    expect(
+      compatibleHarnessIds({
+        isCustom: false,
+        isManaged: true,
+        models: [{api: 'openai-responses'}, {api: 'anthropic-messages'}],
+        providerId: 'shipfox',
+      }),
+    ).toEqual(['pi', 'claude']);
+    expect(
+      compatibleHarnessIds({
+        isCustom: false,
+        isManaged: true,
+        models: [{api: 'openai-responses'}],
+        providerId: 'shipfox',
+      }),
+    ).toEqual(['pi']);
   });
 });

package/src/components/harness-availability.ts

@@ -1,11 +1,26 @@
-import {compatibleHarnessIds, configSupportsHarness} from '#core/harness-policy.js';
-import type {HarnessDescriptor, ProviderConfig} from '#core/models.js';
+import {
+  compatibleHarnessIds,
+  configSupportsHarness,
+  managedModelSupportsHarness,
+} from '#core/harness-policy.js';
+import type {HarnessDescriptor, ProviderCatalog, ProviderConfig} from '#core/models.js';
+import {isManagedOnlyCatalog, isSupportedProvider} from '#core/provider-policy.js';
 
 export function isHarnessAvailable(
   descriptor: HarnessDescriptor,
   configs: readonly ProviderConfig[],
+  catalog?: ProviderCatalog,
 ): boolean {
-  return configs.some((config) => configSupportsHarness(config, descriptor));
+  return (
+    configs.some((config) => configSupportsHarness(config, descriptor)) ||
+    (isManagedOnlyCatalog(catalog) &&
+      (catalog?.providers.some(
+        (provider) =>
+          isSupportedProvider(provider) &&
+          provider.models.some((model) => managedModelSupportsHarness(descriptor.id, model)),
+      ) ??
+        false))
+  );
 }
 
 export {compatibleHarnessIds};

package/src/components/harnesses-section.test.tsx

@@ -6,6 +6,7 @@ import userEvent from '@testing-library/user-event';
 import type {ReactElement} from 'react';
 import {
   AGENT_TEST_WORKSPACE_ID,
+  modelProviderCatalogResponse,
   modelProviderConfig,
   modelProviderConfigsResponse,
 } from '#test/fixtures/model-providers.js';
@@ -19,6 +20,13 @@ function jsonResponse(body: unknown, init: ResponseInit = {}) {
   });
 }
 
+function harnessRequestResponse(input: RequestInfo | URL, body: unknown) {
+  const url = new URL(input instanceof Request ? input.url : input.toString());
+  return url.pathname.endsWith('/agent/model-provider-catalog')
+    ? jsonResponse(modelProviderCatalogResponse())
+    : jsonResponse(body);
+}
+
 function renderHarnesses(element: ReactElement) {
   const queryClient = new QueryClient({defaultOptions: {queries: {retry: false}}});
   const result = render(
@@ -48,7 +56,11 @@ describe('WorkspaceHarnessesSection', () => {
     const user = userEvent.setup();
     configureApiClient({
       baseUrl: 'https://api.example.test',
-      fetchImpl: vi.fn().mockResolvedValue(jsonResponse(modelProviderConfigsResponse())),
+      fetchImpl: vi
+        .fn()
+        .mockImplementation((input: RequestInfo | URL) =>
+          Promise.resolve(harnessRequestResponse(input, modelProviderConfigsResponse())),
+        ),
     });
 
     renderHarnesses(<WorkspaceHarnessesSection workspaceId={AGENT_TEST_WORKSPACE_ID} />);
@@ -69,11 +81,14 @@ describe('WorkspaceHarnessesSection', () => {
     const user = userEvent.setup();
     configureApiClient({
       baseUrl: 'https://api.example.test',
-      fetchImpl: vi.fn().mockResolvedValue(
-        jsonResponse(
-          modelProviderConfigsResponse({
-            configs: [modelProviderConfig({provider_id: 'openai'})],
-          }),
+      fetchImpl: vi.fn().mockImplementation((input: RequestInfo | URL) =>
+        Promise.resolve(
+          harnessRequestResponse(
+            input,
+            modelProviderConfigsResponse({
+              configs: [modelProviderConfig({provider_id: 'openai'})],
+            }),
+          ),
         ),
       ),
     });
@@ -91,6 +106,33 @@ describe('WorkspaceHarnessesSection', () => {
     expect(screen.getByRole('menuitem', {name: 'Set as default'})).toHaveAttribute('data-disabled');
   });
 
+  test('keeps harnesses unavailable when the catalog fails and no providers are configured', async () => {
+    const user = userEvent.setup();
+    configureApiClient({
+      baseUrl: 'https://api.example.test',
+      fetchImpl: vi.fn().mockImplementation((input: RequestInfo | URL) => {
+        const url = new URL(input instanceof Request ? input.url : input.toString());
+        if (url.pathname.endsWith('/agent/model-provider-catalog')) {
+          return Promise.resolve(jsonResponse({code: 'server-error'}, {status: 500}));
+        }
+        return Promise.resolve(
+          harnessRequestResponse(input, modelProviderConfigsResponse({configs: []})),
+        );
+      }),
+    });
+
+    renderHarnesses(<WorkspaceHarnessesSection workspaceId={AGENT_TEST_WORKSPACE_ID} />);
+
+    const claudeRow = (await screen.findByText('Claude')).closest('li');
+    if (claudeRow === null) throw new Error('Expected Claude row');
+    expect(
+      within(claudeRow).getByText('Configure a compatible model provider to use this harness.'),
+    ).toHaveClass('sr-only');
+
+    await openHarnessActions(user, 'Claude');
+    expect(screen.getByRole('menuitem', {name: 'Set as default'})).toHaveAttribute('data-disabled');
+  });
+
   test('sets the default harness and shows a success toast', async () => {
     const user = userEvent.setup();
     let requestBody: unknown;
@@ -101,7 +143,7 @@ describe('WorkspaceHarnessesSection', () => {
         requestBody = await request.clone().json();
         return await updateResponse.promise;
       }
-      return jsonResponse(modelProviderConfigsResponse());
+      return harnessRequestResponse(input, modelProviderConfigsResponse());
     });
     configureApiClient({baseUrl: 'https://api.example.test', fetchImpl});
 
@@ -128,7 +170,7 @@ describe('WorkspaceHarnessesSection', () => {
       if (request.method === 'PUT') {
         return Promise.resolve(jsonResponse({code: 'server-error'}, {status: 500}));
       }
-      return Promise.resolve(jsonResponse(modelProviderConfigsResponse()));
+      return Promise.resolve(harnessRequestResponse(input, modelProviderConfigsResponse()));
     });
     configureApiClient({baseUrl: 'https://api.example.test', fetchImpl});
 
@@ -154,7 +196,7 @@ describe('WorkspaceHarnessesSection', () => {
       if (request.method === 'PUT') {
         return updateResponse.promise;
       }
-      return Promise.resolve(jsonResponse(modelProviderConfigsResponse()));
+      return Promise.resolve(harnessRequestResponse(input, modelProviderConfigsResponse()));
     });
     configureApiClient({baseUrl: 'https://api.example.test', fetchImpl});
     const nextWorkspaceId = '22222222-2222-4222-8222-222222222222';

package/src/components/harnesses-section.tsx

@@ -17,6 +17,7 @@ import {useRef, useState} from 'react';
 import {DEFAULT_HARNESS, listHarnesses} from '#core/harness-policy.js';
 import type {HarnessDescriptor, HarnessId} from '#core/models.js';
 import {
+  useModelProviderCatalogQuery,
   useModelProviderConfigsQuery,
   useSetDefaultHarnessMutation,
 } from '#hooks/api/model-providers.js';
@@ -24,6 +25,7 @@ import {modelProviderConfigErrorToFormError} from './form-errors.js';
 import {isHarnessAvailable} from './harness-availability.js';
 
 export function WorkspaceHarnessesSection({workspaceId}: {workspaceId: string}) {
+  const catalogQuery = useModelProviderCatalogQuery();
   const configsQuery = useModelProviderConfigsQuery(workspaceId);
   const setDefaultHarness = useSetDefaultHarnessMutation();
   const activeWorkspaceIdRef = useRef(workspaceId);
@@ -37,6 +39,7 @@ export function WorkspaceHarnessesSection({workspaceId}: {workspaceId: string})
     {workspaceId: string; harnessId: HarnessId; message: string} | undefined
   >();
   const configs = configsQuery.data?.configs ?? [];
+  const catalog = catalogQuery.data;
   const defaultHarnessId = configsQuery.data?.defaultHarnessId ?? DEFAULT_HARNESS;
   activeWorkspaceIdRef.current = workspaceId;
 
@@ -103,7 +106,7 @@ export function WorkspaceHarnessesSection({workspaceId}: {workspaceId: string})
                   key={harness.id}
                   harness={harness}
                   isDefault={harness.id === defaultHarnessId}
-                  isAvailable={isHarnessAvailable(harness, configs)}
+                  isAvailable={isHarnessAvailable(harness, configs, catalog)}
                   isSettingDefault={pendingDefaultHarness?.workspaceId === workspaceId}
                   defaultError={
                     defaultError?.workspaceId === workspaceId &&

package/src/components/model-provider-usage-modal.test.tsx

@@ -77,6 +77,29 @@ describe('ModelProviderUsageModal', () => {
     );
   });
 
+  test('does not offer Claude when managed models do not support Anthropic messages', async () => {
+    const onOpenChange = vi.fn();
+    const entry = supportedProvider({
+      id: 'shipfox',
+      label: 'Shipfox Managed',
+      defaultModel: 'gpt-5.5-pro',
+      models: [{id: 'gpt-5.5-pro', label: 'GPT-5.5 Pro', api: 'openai-responses'}],
+    });
+
+    render(
+      <ModelProviderUsageModal
+        target={usageTargetFromCatalogEntry(entry, {isManaged: true})}
+        initialModel="gpt-5.5-pro"
+        open
+        onOpenChange={onOpenChange}
+      />,
+    );
+
+    const dialog = await screen.findByRole('dialog', {name: 'Use Shipfox Managed in a workflow'});
+    expect(dialog).toHaveTextContent('harness: pi');
+    expect(screen.queryByRole('button', {name: 'Harness'})).not.toBeInTheDocument();
+  });
+
   test('uses the workspace default harness when it is compatible', async () => {
     const onOpenChange = vi.fn();
     const entry = supportedProvider();

package/src/components/model-provider-usage-modal.tsx

@@ -22,7 +22,12 @@ import {
 import {Tooltip, TooltipContent, TooltipTrigger} from '@shipfox/react-ui/tooltip';
 import {Code, Text} from '@shipfox/react-ui/typography';
 import {useEffect, useMemo, useRef, useState} from 'react';
-import {DEFAULT_HARNESS, getHarness, listHarnesses} from '#core/harness-policy.js';
+import {
+  DEFAULT_HARNESS,
+  getHarness,
+  listHarnesses,
+  managedModelSupportsHarness,
+} from '#core/harness-policy.js';
 import type {HarnessId} from '#core/models.js';
 import {buildAgentWorkflowExample} from './agent-workflow-example.js';
 import {compatibleHarnessIds} from './harness-availability.js';
@@ -59,6 +64,8 @@ export function ModelProviderUsageModal({
     if (!target) return;
     const nextCompatibleHarnessIds = compatibleHarnessIds({
       isCustom: target.isCustom,
+      isManaged: target.isManaged,
+      models: target.models,
       providerId: target.id,
     });
     setSelectedHarness(selectInitialHarness(nextCompatibleHarnessIds, workspaceDefaultHarnessId));
@@ -67,7 +74,12 @@ export function ModelProviderUsageModal({
   const compatibleIds = useMemo(
     () =>
       target
-        ? compatibleHarnessIds({isCustom: target.isCustom, providerId: target.id})
+        ? compatibleHarnessIds({
+            isCustom: target.isCustom,
+            isManaged: target.isManaged,
+            models: target.models,
+            providerId: target.id,
+          })
         : ([] as HarnessId[]),
     [target],
   );
@@ -79,10 +91,24 @@ export function ModelProviderUsageModal({
       })),
     [compatibleIds],
   );
+  const compatibleModels = useMemo(() => {
+    if (!target) return [];
+    return target.isManaged
+      ? target.models.filter((model) => managedModelSupportsHarness(selectedHarness, model))
+      : target.models;
+  }, [selectedHarness, target]);
   const modelOptions = useMemo(
-    () => target?.models.map((model) => ({value: model.id, label: model.label})) ?? [],
-    [target],
+    () => compatibleModels.map((model) => ({value: model.id, label: model.label})),
+    [compatibleModels],
   );
+  useEffect(() => {
+    if (!target || compatibleModels.length === 0) return;
+    setSelectedModel((current) =>
+      compatibleModels.some((model) => model.id === current)
+        ? current
+        : (compatibleModels[0]?.id ?? ''),
+    );
+  }, [compatibleModels, target]);
   const example = target
     ? buildAgentWorkflowExample({
         harness: selectedHarness,
@@ -212,10 +238,10 @@ export function ModelProviderUsageModal({
 
                 <div className="flex flex-col gap-inline">
                   <Text size="sm" bold>
-                    Available models ({target.models.length})
+                    Available models ({compatibleModels.length})
                   </Text>
                   <ul className="rounded-8 border border-border-neutral-base">
-                    {target.models.map((model) => (
+                    {compatibleModels.map((model) => (
                       <ModelProviderModelRow key={model.id} label={model.label} id={model.id} />
                     ))}
                   </ul>

package/src/components/model-provider-usage-target.ts

@@ -1,19 +1,24 @@
-import type {CustomProviderConfig, SupportedProvider} from '#core/models.js';
+import type {AgentModel, CustomProviderConfig, SupportedProvider} from '#core/models.js';
 
 export interface ModelProviderUsageTarget {
   id: string;
   label: string;
   isCustom: boolean;
-  models: ReadonlyArray<{id: string; label: string}>;
+  isManaged: boolean;
+  models: ReadonlyArray<AgentModel>;
   defaultModel: string | null;
 }
 
-export function usageTargetFromCatalogEntry(entry: SupportedProvider): ModelProviderUsageTarget {
+export function usageTargetFromCatalogEntry(
+  entry: SupportedProvider,
+  options: {isManaged?: boolean} = {},
+): ModelProviderUsageTarget {
   const provider = entry;
   return {
     id: provider.id,
     label: provider.label,
     isCustom: false,
+    isManaged: options.isManaged ?? false,
     models: provider.models,
     defaultModel: provider.defaultModel,
   };
@@ -27,6 +32,7 @@ export function usageTargetFromCustomConfig(
     id: provider.providerId,
     label: provider.displayName,
     isCustom: true,
+    isManaged: false,
     models: provider.models,
     defaultModel: provider.defaultModel,
   };

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

@@ -22,6 +22,7 @@ type Scenario =
   | 'loading'
   | 'configs-error'
   | 'catalog-error'
+  | 'managed-only'
   | 'long-names';
 
 interface ModelProvidersStoryProps {
@@ -138,6 +139,15 @@ type Story = StoryObj<typeof meta>;
 
 export const Playground: Story = {};
 
+export const ManagedOnly: Story = {
+  args: {scenario: 'managed-only'},
+  play: async ({canvasElement}) => {
+    const canvas = within(canvasElement);
+    await canvas.findByText('Managed by this instance. No workspace credentials are required.');
+    await canvas.findByRole('button', {name: 'Use in a workflow'});
+  },
+};
+
 export const EmptyConfigured: Story = {
   args: {scenario: 'empty-configured'},
 };
@@ -226,7 +236,12 @@ function fetchForScenario(scenario: Scenario): typeof fetch {
     if (scenario === 'loading') return new Promise<Response>(() => undefined);
     if (url.pathname.endsWith('/agent/model-provider-catalog')) {
       if (scenario === 'catalog-error') return Promise.resolve(errorResponse());
-      return Promise.resolve(jsonResponse({providers: catalogForScenario(scenario)}));
+      return Promise.resolve(
+        jsonResponse({
+          providers: catalogForScenario(scenario),
+          ...(scenario === 'managed-only' ? {workspace_providers: 'disabled'} : {}),
+        }),
+      );
     }
     if (url.pathname.endsWith('/agent/model-providers')) {
       if (scenario === 'configs-error') return Promise.resolve(errorResponse());
@@ -237,6 +252,20 @@ function fetchForScenario(scenario: Scenario): typeof fetch {
 }
 
 function catalogForScenario(scenario: Scenario): ModelProviderCatalogEntryDto[] {
+  if (scenario === 'managed-only') {
+    return [
+      providerEntry({
+        id: 'shipfox',
+        label: 'Shipfox Managed',
+        default_model: 'claude-opus-4-8',
+        credential_fields: [],
+        models: [
+          {id: 'claude-opus-4-8', label: 'Claude Opus 4.8', api: 'anthropic-messages'},
+          {id: 'gpt-5.5-pro', label: 'GPT-5.5 Pro', api: 'openai-responses'},
+        ],
+      }),
+    ];
+  }
   if (scenario !== 'long-names') return CATALOG;
   return [
     providerEntry({
@@ -254,6 +283,9 @@ function catalogForScenario(scenario: Scenario): ModelProviderCatalogEntryDto[]
 }
 
 function configsForScenario(scenario: Scenario) {
+  if (scenario === 'managed-only') {
+    return {configs: [], default_provider_id: null, default_harness_id: null};
+  }
   if (scenario === 'empty-configured' || scenario === 'configs-error') {
     return {configs: [], default_provider_id: null, default_harness_id: null};
   }

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

@@ -7,6 +7,7 @@ import userEvent from '@testing-library/user-event';
 import type {ReactElement} from 'react';
 import {
   AGENT_TEST_WORKSPACE_ID,
+  managedModelProviderEntry,
   modelProviderCatalogResponse,
   modelProviderConfig,
   modelProviderConfigsResponse,
@@ -60,6 +61,46 @@ function customProviderConfig(): CustomModelProviderConfigDto {
 }
 
 describe('WorkspaceModelProvidersSection', () => {
+  test('renders managed provider models without exposing workspace provider setup', async () => {
+    const user = userEvent.setup();
+    const fetchImpl = vi.fn((input: RequestInfo | URL) => {
+      if (requestPath(input).endsWith('/agent/model-provider-catalog')) {
+        return Promise.resolve(
+          jsonResponse(modelProviderCatalogResponse([managedModelProviderEntry()], '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.getByRole('list', {name: 'Shipfox Managed models'})).toHaveTextContent(
+      'Claude Opus 4.8',
+    );
+    expect(screen.getByRole('list', {name: 'Shipfox Managed models'})).toHaveTextContent(
+      'GPT-5.5 Pro',
+    );
+    expect(screen.queryByText('Available providers')).not.toBeInTheDocument();
+    expect(screen.queryByText('Unsupported providers')).not.toBeInTheDocument();
+    expect(
+      screen.queryByRole('button', {name: 'Configure custom provider'}),
+    ).not.toBeInTheDocument();
+    expect(screen.queryByLabelText('API key')).not.toBeInTheDocument();
+
+    await user.click(screen.getByRole('button', {name: 'Use in a workflow'}));
+
+    const usageDialog = await screen.findByRole('dialog', {
+      name: 'Use Shipfox Managed in a workflow',
+    });
+    expect(usageDialog).toHaveTextContent('provider: shipfox');
+    expect(usageDialog).toHaveTextContent('model: claude-opus-4-8');
+  });
+
   test('renders configured, available, and unsupported providers', async () => {
     const fetchImpl = vi.fn((input: RequestInfo | URL) => {
       if (requestPath(input).endsWith('/agent/model-provider-catalog')) {