@shipfox/client-agent 4.0.0 → 6.0.1

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

@@ -0,0 +1,120 @@
+import type {
+  CustomModelProviderConfigDto,
+  ListModelProviderConfigsResponseDto,
+  ModelProviderCatalogEntryDto,
+  ModelProviderCatalogResponseDto,
+  ModelProviderConfigDto,
+  ModelProviderConfigResponseDto,
+  SetDefaultHarnessResponseDto,
+  SetDefaultModelProviderResponseDto,
+} from '@shipfox/api-agent-dto';
+import type {
+  AgentModel,
+  BuiltinProviderConfig,
+  CustomProviderConfig,
+  DefaultHarnessSelection,
+  DefaultModelProviderSelection,
+  ProviderCatalog,
+  ProviderCatalogEntry,
+  ProviderConfig,
+  ProviderConfiguration,
+} from '#core/models.js';
+
+export function toProviderCatalog(response: ModelProviderCatalogResponseDto): ProviderCatalog {
+  return {providers: response.providers.map(toProviderCatalogEntry)};
+}
+
+export function toProviderCatalogEntry(entry: ModelProviderCatalogEntryDto): ProviderCatalogEntry {
+  if (entry.support_status === 'unsupported') {
+    return {
+      kind: 'unsupported',
+      id: entry.id,
+      label: entry.label,
+      unsupportedReason: entry.unsupported_reason ?? 'Unsupported provider',
+    };
+  }
+  return {
+    kind: 'supported',
+    id: entry.id,
+    label: entry.label,
+    defaultModel: entry.default_model,
+    credentialFields: entry.credential_fields.map((field) => ({
+      key: field.key,
+      label: field.label,
+      secret: field.secret,
+    })),
+    models: entry.models.map(toAgentModel),
+  };
+}
+
+export function toProviderConfiguration(
+  response: ListModelProviderConfigsResponseDto,
+): ProviderConfiguration {
+  return {
+    configs: response.configs.map(toProviderConfig),
+    defaultHarnessId: response.default_harness_id,
+    defaultProviderId: response.default_provider_id,
+  };
+}
+
+export function toDefaultModelProviderSelection(
+  response: SetDefaultModelProviderResponseDto,
+): DefaultModelProviderSelection {
+  return {defaultProviderId: response.default_provider_id};
+}
+
+export function toDefaultHarnessSelection(
+  response: SetDefaultHarnessResponseDto,
+): DefaultHarnessSelection {
+  return {defaultHarnessId: response.default_harness_id};
+}
+
+export function toProviderConfig(config: ModelProviderConfigResponseDto): ProviderConfig {
+  return config.kind === 'builtin'
+    ? toBuiltinProviderConfig(config)
+    : toCustomProviderConfig(config);
+}
+
+export function toBuiltinProviderConfig(config: ModelProviderConfigDto): BuiltinProviderConfig {
+  return {
+    kind: 'builtin',
+    providerId: config.provider_id,
+    defaultModel: config.default_model,
+    createdAt: config.created_at,
+    updatedAt: config.updated_at,
+  };
+}
+
+export function toCustomProviderConfig(config: CustomModelProviderConfigDto): CustomProviderConfig {
+  return {
+    kind: 'custom',
+    providerId: config.provider_id,
+    displayName: config.display_name,
+    api: config.api,
+    baseUrl: config.base_url,
+    headers: config.headers.map((header) => ({name: header.name, value: header.value})),
+    secretHeaderNames: config.secret_header_names,
+    models: config.models.map(toAgentModel),
+    defaultModel: config.default_model,
+    createdAt: config.created_at,
+    updatedAt: config.updated_at,
+  };
+}
+
+function toAgentModel(model: {
+  id: string;
+  label: string;
+  context_window?: number | undefined;
+  max_output_tokens?: number | undefined;
+  input_image?: boolean | undefined;
+  reasoning?: boolean | undefined;
+}): AgentModel {
+  return {
+    id: model.id,
+    label: model.label,
+    ...(model.context_window === undefined ? {} : {contextWindow: model.context_window}),
+    ...(model.max_output_tokens === undefined ? {} : {maxOutputTokens: model.max_output_tokens}),
+    ...(model.input_image === undefined ? {} : {inputImage: model.input_image}),
+    ...(model.reasoning === undefined ? {} : {reasoning: model.reasoning}),
+  };
+}

package/src/hooks/api/model-providers.test.ts

@@ -47,7 +47,7 @@ describe('model provider transport', () => {
     const result = await listModelProviderConfigs({workspaceId: AGENT_TEST_WORKSPACE_ID});
 
     const request = fetchImpl.mock.calls[0]?.[0] as Request;
-    expect(result.default_provider_id).toBe('anthropic');
+    expect(result.defaultProviderId).toBe('anthropic');
     expect(request.url).toBe(
       `https://api.example.test/workspaces/${AGENT_TEST_WORKSPACE_ID}/agent/model-providers`,
     );
@@ -66,11 +66,11 @@ describe('model provider transport', () => {
     const result = await upsertModelProviderConfig({
       workspaceId: AGENT_TEST_WORKSPACE_ID,
       providerId: 'anthropic',
-      body,
+      command: {defaultModel: 'claude-haiku-4-5', credentials: {api_key: 'sk-ant-secret'}},
     });
 
     const request = fetchImpl.mock.calls[0]?.[0] as Request;
-    expect(result.provider_id).toBe('anthropic');
+    expect(result.providerId).toBe('anthropic');
     expect(request.url).toBe(
       `https://api.example.test/workspaces/${AGENT_TEST_WORKSPACE_ID}/agent/model-providers/anthropic`,
     );
@@ -102,21 +102,21 @@ describe('model provider transport', () => {
       return jsonResponse(modelProviderConfig({default_model: null}));
     });
     configureApiClient({fetchImpl});
-    const body = {default_model: null};
+    const defaultModel: string | null = null;
 
     const result = await updateModelProviderDefaultModel({
       workspaceId: AGENT_TEST_WORKSPACE_ID,
       providerId: 'anthropic',
-      body,
+      defaultModel,
     });
 
     const request = fetchImpl.mock.calls[0]?.[0] as Request;
-    expect(result.default_model).toBeNull();
+    expect(result.defaultModel).toBeNull();
     expect(request.url).toBe(
       `https://api.example.test/workspaces/${AGENT_TEST_WORKSPACE_ID}/agent/model-providers/anthropic/default-model`,
     );
     expect(request.method).toBe('PUT');
-    expect(requestBody).toEqual(body);
+    expect(requestBody).toEqual({default_model: defaultModel});
   });
 
   test('sets the default model provider', async () => {
@@ -126,20 +126,20 @@ describe('model provider transport', () => {
       return jsonResponse({default_provider_id: 'anthropic'});
     });
     configureApiClient({fetchImpl});
-    const body = {provider_id: 'anthropic'} as const;
+    const providerId = 'anthropic';
 
     const result = await setDefaultModelProvider({
       workspaceId: AGENT_TEST_WORKSPACE_ID,
-      body,
+      providerId,
     });
 
     const request = fetchImpl.mock.calls[0]?.[0] as Request;
-    expect(result.default_provider_id).toBe('anthropic');
+    expect(result.defaultProviderId).toBe('anthropic');
     expect(request.url).toBe(
       `https://api.example.test/workspaces/${AGENT_TEST_WORKSPACE_ID}/agent/default-model-provider`,
     );
     expect(request.method).toBe('PUT');
-    expect(requestBody).toEqual(body);
+    expect(requestBody).toEqual({provider_id: providerId});
   });
 
   test('sets the default harness', async () => {
@@ -149,19 +149,19 @@ describe('model provider transport', () => {
       return jsonResponse({default_harness_id: 'claude'});
     });
     configureApiClient({fetchImpl});
-    const body = {harness_id: 'claude'} as const;
+    const harnessId = 'claude' as const;
 
     const result = await setDefaultHarness({
       workspaceId: AGENT_TEST_WORKSPACE_ID,
-      body,
+      harnessId,
     });
 
     const request = fetchImpl.mock.calls[0]?.[0] as Request;
-    expect(result.default_harness_id).toBe('claude');
+    expect(result.defaultHarnessId).toBe('claude');
     expect(request.url).toBe(
       `https://api.example.test/workspaces/${AGENT_TEST_WORKSPACE_ID}/agent/default-harness`,
     );
     expect(request.method).toBe('PUT');
-    expect(requestBody).toEqual(body);
+    expect(requestBody).toEqual({harness_id: harnessId});
   });
 });

package/src/hooks/api/model-providers.ts

@@ -1,24 +1,51 @@
-import type {
-  CreateCustomModelProviderBodyDto,
-  CustomModelProviderConfigDto,
-  DiscoverCustomModelProviderModelsBodyDto,
-  DiscoverCustomModelProviderModelsBySlugBodyDto,
-  DiscoverCustomModelProviderModelsResponseDto,
-  ListModelProviderConfigsResponseDto,
-  ModelProviderCatalogResponseDto,
-  ModelProviderConfigDto,
-  ModelProviderRef,
-  SetDefaultHarnessBodyDto,
-  SetDefaultHarnessResponseDto,
-  SetDefaultModelProviderBodyDto,
-  SetDefaultModelProviderResponseDto,
-  SupportedModelProviderId,
-  UpdateCustomModelProviderBodyDto,
-  UpdateModelProviderConfigBodyDto,
-  UpdateModelProviderDefaultModelBodyDto,
+import {
+  customModelProviderConfigDtoSchema,
+  discoverCustomModelProviderModelsResponseSchema,
+  listModelProviderConfigsResponseSchema,
+  type ModelProviderRef,
+  modelProviderCatalogResponseSchema,
+  modelProviderConfigDtoSchema,
+  setDefaultHarnessResponseSchema,
+  setDefaultModelProviderResponseSchema,
 } from '@shipfox/api-agent-dto';
-import {apiRequest} from '@shipfox/client-api';
-import {useMutation, useQuery, useQueryClient} from '@tanstack/react-query';
+import {checkedApiRequest, emptyResponseSchema} from '@shipfox/client-api';
+import {
+  type FetchQueryOptions,
+  queryOptions,
+  useMutation,
+  useQuery,
+  useQueryClient,
+} from '@tanstack/react-query';
+import type {
+  AgentModel,
+  CreateCustomProviderCommand,
+  DefaultHarnessSelection,
+  DefaultModelProviderSelection,
+  DiscoverProviderModelsCommand,
+  HarnessId,
+  ProviderCatalog,
+  ProviderConfig,
+  ProviderConfiguration,
+  ProviderCredentialsCommand,
+  UpdateCustomProviderCommand,
+} from '#core/models.js';
+import {
+  toCreateCustomProviderBody,
+  toDefaultHarnessBody,
+  toDefaultModelBody,
+  toDefaultProviderBody,
+  toDiscoverModelsBody,
+  toDiscoverModelsBySlugBody,
+  toProviderCredentialsBody,
+  toUpdateCustomProviderBody,
+} from './model-provider-command-mapper.js';
+import {
+  toDefaultHarnessSelection,
+  toDefaultModelProviderSelection,
+  toProviderCatalog,
+  toProviderConfig,
+  toProviderConfiguration,
+} from './model-provider-mapper.js';
 
 export const modelProviderQueryKeys = {
   all: ['model-providers'] as const,
@@ -27,10 +54,34 @@ export const modelProviderQueryKeys = {
     [...modelProviderQueryKeys.all, 'configs', workspaceId] as const,
 };
 
-export async function getModelProviderCatalog({signal}: {signal?: AbortSignal} = {}) {
-  return await apiRequest<ModelProviderCatalogResponseDto>('/agent/model-provider-catalog', {
-    signal,
-  });
+type ModelProviderConfigsQueryKey =
+  | ReturnType<typeof modelProviderQueryKeys.configs>
+  | readonly ['model-providers', 'configs'];
+
+type ModelProviderConfigsQueryOptions = FetchQueryOptions<
+  ProviderConfiguration,
+  Error,
+  ProviderConfiguration,
+  ModelProviderConfigsQueryKey
+>;
+
+type ModelProviderCatalogQueryOptions = FetchQueryOptions<
+  ProviderCatalog,
+  Error,
+  ProviderCatalog,
+  ReturnType<typeof modelProviderQueryKeys.catalog>
+>;
+
+export async function getModelProviderCatalog({
+  signal,
+}: {
+  signal?: AbortSignal;
+} = {}): Promise<ProviderCatalog> {
+  return toProviderCatalog(
+    await checkedApiRequest(modelProviderCatalogResponseSchema, '/agent/model-provider-catalog', {
+      signal,
+    }),
+  );
 }
 
 export async function listModelProviderConfigs({
@@ -39,82 +90,110 @@ export async function listModelProviderConfigs({
 }: {
   workspaceId: string;
   signal?: AbortSignal;
-}) {
-  return await apiRequest<ListModelProviderConfigsResponseDto>(
-    `/workspaces/${workspaceId}/agent/model-providers`,
-    {signal},
+}): Promise<ProviderConfiguration> {
+  return toProviderConfiguration(
+    await checkedApiRequest(
+      listModelProviderConfigsResponseSchema,
+      `/workspaces/${workspaceId}/agent/model-providers`,
+      {signal},
+    ),
   );
 }
 
+export function modelProviderConfigsQueryOptions(
+  workspaceId: string | undefined,
+): ModelProviderConfigsQueryOptions {
+  return queryOptions({
+    queryKey: workspaceId
+      ? modelProviderQueryKeys.configs(workspaceId)
+      : ([...modelProviderQueryKeys.all, 'configs'] as const),
+    enabled: Boolean(workspaceId),
+    queryFn: ({signal}) => listModelProviderConfigs({workspaceId: workspaceId ?? '', signal}),
+  });
+}
+
 export async function upsertModelProviderConfig({
   workspaceId,
   providerId,
-  body,
+  command,
 }: {
   workspaceId: string;
-  providerId: SupportedModelProviderId;
-  body: UpdateModelProviderConfigBodyDto;
-}) {
-  return await apiRequest<ModelProviderConfigDto>(
-    `/workspaces/${workspaceId}/agent/model-providers/${providerId}`,
-    {method: 'PUT', body},
+  providerId: string;
+  command: ProviderCredentialsCommand;
+}): Promise<ProviderConfig> {
+  return toProviderConfig(
+    await checkedApiRequest(
+      modelProviderConfigDtoSchema,
+      `/workspaces/${workspaceId}/agent/model-providers/${providerId}`,
+      {method: 'PUT', body: toProviderCredentialsBody(command)},
+    ),
   );
 }
 
 export async function createCustomModelProviderConfig({
   workspaceId,
-  body,
+  command,
 }: {
   workspaceId: string;
-  body: CreateCustomModelProviderBodyDto;
-}) {
-  return await apiRequest<CustomModelProviderConfigDto>(
-    `/workspaces/${workspaceId}/agent/custom-model-providers`,
-    {method: 'POST', body},
+  command: CreateCustomProviderCommand;
+}): Promise<ProviderConfig> {
+  return toProviderConfig(
+    await checkedApiRequest(
+      customModelProviderConfigDtoSchema,
+      `/workspaces/${workspaceId}/agent/custom-model-providers`,
+      {method: 'POST', body: toCreateCustomProviderBody(command)},
+    ),
   );
 }
 
 export async function updateCustomModelProviderConfig({
   workspaceId,
   providerId,
-  body,
+  command,
 }: {
   workspaceId: string;
   providerId: ModelProviderRef;
-  body: UpdateCustomModelProviderBodyDto;
-}) {
-  return await apiRequest<CustomModelProviderConfigDto>(
-    `/workspaces/${workspaceId}/agent/custom-model-providers/${providerId}`,
-    {method: 'PUT', body},
+  command: UpdateCustomProviderCommand;
+}): Promise<ProviderConfig> {
+  return toProviderConfig(
+    await checkedApiRequest(
+      customModelProviderConfigDtoSchema,
+      `/workspaces/${workspaceId}/agent/custom-model-providers/${providerId}`,
+      {method: 'PUT', body: toUpdateCustomProviderBody(command)},
+    ),
   );
 }
 
 export async function discoverCustomModelProviderModels({
   workspaceId,
-  body,
+  command,
 }: {
   workspaceId: string;
-  body: DiscoverCustomModelProviderModelsBodyDto;
-}) {
-  return await apiRequest<DiscoverCustomModelProviderModelsResponseDto>(
+  command: DiscoverProviderModelsCommand;
+}): Promise<readonly AgentModel[]> {
+  const response = await checkedApiRequest(
+    discoverCustomModelProviderModelsResponseSchema,
     `/workspaces/${workspaceId}/agent/custom-model-providers/discover-models`,
-    {method: 'POST', body},
+    {method: 'POST', body: toDiscoverModelsBody(command)},
   );
+  return response.models.map((model) => ({id: model.id, label: model.label}));
 }
 
 export async function discoverCustomModelProviderModelsBySlug({
   workspaceId,
   providerId,
-  body,
+  command,
 }: {
   workspaceId: string;
   providerId: ModelProviderRef;
-  body: DiscoverCustomModelProviderModelsBySlugBodyDto;
-}) {
-  return await apiRequest<DiscoverCustomModelProviderModelsResponseDto>(
+  command: DiscoverProviderModelsCommand;
+}): Promise<readonly AgentModel[]> {
+  const response = await checkedApiRequest(
+    discoverCustomModelProviderModelsResponseSchema,
     `/workspaces/${workspaceId}/agent/custom-model-providers/${providerId}/discover-models`,
-    {method: 'POST', body},
+    {method: 'POST', body: toDiscoverModelsBySlugBody(command)},
   );
+  return response.models.map((model) => ({id: model.id, label: model.label}));
 }
 
 export async function deleteModelProviderConfig({
@@ -124,54 +203,69 @@ export async function deleteModelProviderConfig({
   workspaceId: string;
   providerId: ModelProviderRef;
 }) {
-  return await apiRequest<void>(`/workspaces/${workspaceId}/agent/model-providers/${providerId}`, {
-    method: 'DELETE',
-  });
+  return await checkedApiRequest(
+    emptyResponseSchema,
+    `/workspaces/${workspaceId}/agent/model-providers/${providerId}`,
+    {method: 'DELETE'},
+  );
 }
 
 export async function updateModelProviderDefaultModel({
   workspaceId,
   providerId,
-  body,
+  defaultModel,
 }: {
   workspaceId: string;
-  providerId: SupportedModelProviderId;
-  body: UpdateModelProviderDefaultModelBodyDto;
-}) {
-  return await apiRequest<ModelProviderConfigDto>(
-    `/workspaces/${workspaceId}/agent/model-providers/${providerId}/default-model`,
-    {method: 'PUT', body},
+  providerId: string;
+  defaultModel: string | null;
+}): Promise<ProviderConfig> {
+  return toProviderConfig(
+    await checkedApiRequest(
+      modelProviderConfigDtoSchema,
+      `/workspaces/${workspaceId}/agent/model-providers/${providerId}/default-model`,
+      {method: 'PUT', body: toDefaultModelBody(defaultModel)},
+    ),
   );
 }
 
 export async function setDefaultModelProvider({
   workspaceId,
-  body,
+  providerId,
 }: {
   workspaceId: string;
-  body: SetDefaultModelProviderBodyDto;
-}) {
-  return await apiRequest<SetDefaultModelProviderResponseDto>(
-    `/workspaces/${workspaceId}/agent/default-model-provider`,
-    {method: 'PUT', body},
+  providerId: string;
+}): Promise<DefaultModelProviderSelection> {
+  return toDefaultModelProviderSelection(
+    await checkedApiRequest(
+      setDefaultModelProviderResponseSchema,
+      `/workspaces/${workspaceId}/agent/default-model-provider`,
+      {method: 'PUT', body: toDefaultProviderBody(providerId)},
+    ),
   );
 }
 
 export async function setDefaultHarness({
   workspaceId,
-  body,
+  harnessId,
 }: {
   workspaceId: string;
-  body: SetDefaultHarnessBodyDto;
-}) {
-  return await apiRequest<SetDefaultHarnessResponseDto>(
-    `/workspaces/${workspaceId}/agent/default-harness`,
-    {method: 'PUT', body},
+  harnessId: HarnessId;
+}): Promise<DefaultHarnessSelection> {
+  return toDefaultHarnessSelection(
+    await checkedApiRequest(
+      setDefaultHarnessResponseSchema,
+      `/workspaces/${workspaceId}/agent/default-harness`,
+      {method: 'PUT', body: toDefaultHarnessBody(harnessId)},
+    ),
   );
 }
 
 export function useModelProviderCatalogQuery() {
-  return useQuery({
+  return useQuery(modelProviderCatalogQueryOptions());
+}
+
+export function modelProviderCatalogQueryOptions(): ModelProviderCatalogQueryOptions {
+  return queryOptions({
     queryKey: modelProviderQueryKeys.catalog(),
     queryFn: ({signal}) => getModelProviderCatalog({signal}),
     staleTime: 1000 * 60 * 60,
@@ -179,13 +273,7 @@ export function useModelProviderCatalogQuery() {
 }
 
 export function useModelProviderConfigsQuery(workspaceId: string | undefined) {
-  return useQuery({
-    queryKey: workspaceId
-      ? modelProviderQueryKeys.configs(workspaceId)
-      : [...modelProviderQueryKeys.all, 'configs'],
-    enabled: Boolean(workspaceId),
-    queryFn: ({signal}) => listModelProviderConfigs({workspaceId: workspaceId ?? '', signal}),
-  });
+  return useQuery(modelProviderConfigsQueryOptions(workspaceId));
 }
 
 export function useUpsertModelProviderConfigMutation() {