@shipfox/api-agent 4.0.0 → 6.0.0

package/src/presentation/e2eRoutes/create-model-provider.ts

@@ -1,9 +1,9 @@
 import {DEFAULT_AGENT_THINKING, getModelProviderEntry} from '@shipfox/api-agent-dto';
-import {setSecrets} from '@shipfox/api-secrets';
 import {ClientError, defineRoute} from '@shipfox/node-fastify';
 import {z} from 'zod';
 import {agentSystemNamespace} from '#core/credential-fingerprints.js';
 import {listHarnessProviderModels} from '#core/harness/registry.js';
+import type {AgentSecretsClient} from '#core/secrets-client.js';
 import {upsertModelProviderConfig} from '#db/index.js';
 
 const createE2eModelProviderBodySchema = z.object({
@@ -18,44 +18,46 @@ const createE2eModelProviderResponseSchema = z.object({
   provider_id: z.literal('anthropic'),
 });
 
-export const createE2eModelProviderRoute = defineRoute({
-  method: 'POST',
-  path: '/model-provider',
-  description: 'Create an Anthropic model provider config for E2E tests.',
-  schema: {
-    body: createE2eModelProviderBodySchema,
-    response: {201: createE2eModelProviderResponseSchema},
-  },
-  handler: async (request, reply) => {
-    const entry = getModelProviderEntry(request.body.provider_id);
-    if (entry === undefined || entry.default_model === null) {
-      throw new ClientError('Unsupported E2E model provider', 'unsupported-model-provider', {
-        status: 400,
+export function createE2eModelProviderRoute(secrets: AgentSecretsClient) {
+  return defineRoute({
+    method: 'POST',
+    path: '/model-provider',
+    description: 'Create an Anthropic model provider config for E2E tests.',
+    schema: {
+      body: createE2eModelProviderBodySchema,
+      response: {201: createE2eModelProviderResponseSchema},
+    },
+    handler: async (request, reply) => {
+      const entry = getModelProviderEntry(request.body.provider_id);
+      if (entry === undefined || entry.default_model === null) {
+        throw new ClientError('Unsupported E2E model provider', 'unsupported-model-provider', {
+          status: 400,
+        });
+      }
+      const defaultModel = request.body.default_model ?? entry.default_model;
+      const supportedModels = listHarnessProviderModels('claude', request.body.provider_id);
+      if (!supportedModels.some((model) => model.id === defaultModel)) {
+        throw new ClientError('Unsupported Anthropic default model', 'unsupported-model', {
+          status: 400,
+          details: {default_model: defaultModel},
+        });
+      }
+
+      await secrets.setSecrets({
+        workspaceId: request.body.workspace_id,
+        namespace: agentSystemNamespace(request.body.provider_id),
+        values: {API_KEY: request.body.api_key},
       });
-    }
-    const defaultModel = request.body.default_model ?? entry.default_model;
-    const supportedModels = listHarnessProviderModels('claude', request.body.provider_id);
-    if (!supportedModels.some((model) => model.id === defaultModel)) {
-      throw new ClientError('Unsupported Anthropic default model', 'unsupported-model', {
-        status: 400,
-        details: {default_model: defaultModel},
+      await upsertModelProviderConfig({
+        workspaceId: request.body.workspace_id,
+        providerId: request.body.provider_id,
+        defaultModel,
+        defaultThinking: DEFAULT_AGENT_THINKING,
+        setAsDefault: request.body.set_as_default,
       });
-    }
-
-    await setSecrets({
-      workspaceId: request.body.workspace_id,
-      namespace: agentSystemNamespace(request.body.provider_id),
-      values: {API_KEY: request.body.api_key},
-    });
-    await upsertModelProviderConfig({
-      workspaceId: request.body.workspace_id,
-      providerId: request.body.provider_id,
-      defaultModel,
-      defaultThinking: DEFAULT_AGENT_THINKING,
-      setAsDefault: request.body.set_as_default,
-    });
 
-    reply.code(201);
-    return {provider_id: request.body.provider_id};
-  },
-});
+      reply.code(201);
+      return {provider_id: request.body.provider_id};
+    },
+  });
+}

package/src/presentation/e2eRoutes/index.ts

@@ -1,7 +1,9 @@
 import type {RouteGroup} from '@shipfox/node-fastify';
+import type {AgentSecretsClient} from '#core/secrets-client.js';
 import {createE2eModelProviderRoute} from './create-model-provider.js';
 
-export const agentE2eRoutes: RouteGroup = {
-  prefix: '/agent',
-  routes: [createE2eModelProviderRoute],
-};
+export function createAgentE2eRoutes(secrets: AgentSecretsClient): RouteGroup {
+  return {prefix: '/agent', routes: [createE2eModelProviderRoute(secrets)]};
+}
+
+export const agentE2eRoutes = createAgentE2eRoutes(undefined as unknown as AgentSecretsClient);

package/src/presentation/index.ts

@@ -1 +1 @@
-export {agentRoutes as routes} from './routes/index.js';
+export {agentRoutes as routes, createAgentRoutes} from './routes/index.js';

package/src/presentation/inter-module.ts

@@ -0,0 +1,78 @@
+import {agentInterModuleContract} from '@shipfox/api-agent-dto/inter-module';
+import {secretsInterModuleContract} from '@shipfox/api-secrets-dto/inter-module';
+import {
+  createInterModuleKnownError,
+  defineInterModulePresentation,
+  type InterModulePresentation,
+  isInterModuleKnownError,
+} from '@shipfox/inter-module';
+import {
+  InvalidAgentModelError,
+  ModelProviderConfigNotFoundError,
+  UnsupportedHarnessProviderError,
+  UnsupportedHarnessThinkingError,
+  UnsupportedModelProviderError,
+} from '#core/errors.js';
+import {resolveAgentConfig} from '#core/resolve-agent-config.js';
+import {resolveRuntimeCredentials} from '#core/resolve-runtime-credentials.js';
+import type {AgentSecretsClient} from '#core/secrets-client.js';
+import {createWorkspaceAgentDefaultsResolver} from '#core/workspace-agent-defaults-resolver.js';
+
+export function createAgentInterModulePresentation(params: {
+  secrets: AgentSecretsClient;
+}): InterModulePresentation<typeof agentInterModuleContract> {
+  return defineInterModulePresentation(agentInterModuleContract, {
+    resolveAgentConfig: async ({workspaceId, config}) => {
+      try {
+        const resolve =
+          workspaceId === null
+            ? resolveAgentConfig
+            : await createWorkspaceAgentDefaultsResolver(workspaceId);
+        return await resolve(config);
+      } catch (error) {
+        throw toResolveAgentConfigKnownError(error);
+      }
+    },
+    resolveRuntimeCredentials: async (input) => {
+      try {
+        return await resolveRuntimeCredentials(input, {secrets: params.secrets});
+      } catch (error) {
+        throw toResolveRuntimeCredentialsKnownError(error);
+      }
+    },
+  });
+}
+
+function toResolveAgentConfigKnownError(error: unknown): unknown {
+  if (
+    error instanceof InvalidAgentModelError ||
+    error instanceof UnsupportedHarnessProviderError ||
+    error instanceof UnsupportedHarnessThinkingError ||
+    error instanceof UnsupportedModelProviderError
+  ) {
+    return createInterModuleKnownError(
+      agentInterModuleContract.methods.resolveAgentConfig,
+      'agent-config-invalid',
+      {},
+    );
+  }
+  return error;
+}
+
+function toResolveRuntimeCredentialsKnownError(error: unknown): unknown {
+  if (error instanceof ModelProviderConfigNotFoundError) {
+    return createInterModuleKnownError(
+      agentInterModuleContract.methods.resolveRuntimeCredentials,
+      'model-provider-not-configured',
+      {},
+    );
+  }
+  if (isInterModuleKnownError(secretsInterModuleContract.methods.getSecretsByNamespace, error)) {
+    return createInterModuleKnownError(
+      agentInterModuleContract.methods.resolveRuntimeCredentials,
+      'model-provider-credentials-invalid',
+      {},
+    );
+  }
+  return error;
+}

package/src/presentation/routes/create-custom-model-provider.ts

@@ -6,40 +6,46 @@ import {requireWorkspaceAccess} from '@shipfox/api-auth-context';
 import {defineRoute} from '@shipfox/node-fastify';
 import {z} from 'zod';
 import {createCustomModelProviderConfig} from '#core/index.js';
+import type {AgentSecretsClient} from '#core/secrets-client.js';
 import {toCustomModelProviderConfigDto} from '#presentation/dto/index.js';
 import {translateModelProviderRouteError} from './errors.js';
 
-export const createCustomModelProviderRoute = defineRoute({
-  method: 'POST',
-  path: '/custom-model-providers',
-  description: 'Create a custom model provider configuration for a workspace',
-  schema: {
-    params: z.object({workspaceId: z.string().uuid()}),
-    body: createCustomModelProviderBodySchema,
-    response: {
-      200: customModelProviderConfigDtoSchema,
+export function createCustomModelProviderRoute(secrets: AgentSecretsClient) {
+  return defineRoute({
+    method: 'POST',
+    path: '/custom-model-providers',
+    description: 'Create a custom model provider configuration for a workspace',
+    schema: {
+      params: z.object({workspaceId: z.string().uuid()}),
+      body: createCustomModelProviderBodySchema,
+      response: {
+        200: customModelProviderConfigDtoSchema,
+      },
     },
-  },
-  errorHandler: translateModelProviderRouteError,
-  handler: async (request, reply) => {
-    const {workspaceId} = request.params;
-    const abortController = new AbortController();
-    let responseFinished = false;
-    reply.raw.on('finish', () => {
-      responseFinished = true;
-    });
-    reply.raw.on('close', () => {
-      if (!responseFinished) abortController.abort();
-    });
+    errorHandler: translateModelProviderRouteError,
+    handler: async (request, reply) => {
+      const {workspaceId} = request.params;
+      const abortController = new AbortController();
+      let responseFinished = false;
+      reply.raw.on('finish', () => {
+        responseFinished = true;
+      });
+      reply.raw.on('close', () => {
+        if (!responseFinished) abortController.abort();
+      });
 
-    requireWorkspaceAccess({request, workspaceId});
+      requireWorkspaceAccess({request, workspaceId});
 
-    const config = await createCustomModelProviderConfig({
-      workspaceId,
-      body: request.body,
-      signal: abortController.signal,
-    });
+      const config = await createCustomModelProviderConfig(
+        {
+          workspaceId,
+          body: request.body,
+          signal: abortController.signal,
+        },
+        {secrets},
+      );
 
-    return toCustomModelProviderConfigDto(config);
-  },
-});
+      return toCustomModelProviderConfigDto(config);
+    },
+  });
+}

package/src/presentation/routes/delete-model-provider-config.ts

@@ -3,29 +3,32 @@ import {requireWorkspaceAccess} from '@shipfox/api-auth-context';
 import {ClientError, defineRoute} from '@shipfox/node-fastify';
 import {z} from 'zod';
 import {deleteModelProviderConfig} from '#core/index.js';
+import type {AgentSecretsClient} from '#core/secrets-client.js';
 
-export const deleteModelProviderConfigRoute = defineRoute({
-  method: 'DELETE',
-  path: '/model-providers/:providerId',
-  description: 'Delete a model provider configuration for a workspace',
-  schema: {
-    params: z.object({
-      workspaceId: z.string().uuid(),
-      providerId: modelProviderRefSchema,
-    }),
-    response: {
-      204: z.void(),
+export function createDeleteModelProviderConfigRoute(secrets: AgentSecretsClient) {
+  return defineRoute({
+    method: 'DELETE',
+    path: '/model-providers/:providerId',
+    description: 'Delete a model provider configuration for a workspace',
+    schema: {
+      params: z.object({
+        workspaceId: z.string().uuid(),
+        providerId: modelProviderRefSchema,
+      }),
+      response: {
+        204: z.void(),
+      },
     },
-  },
-  handler: async (request, reply) => {
-    const {workspaceId, providerId} = request.params;
-    requireWorkspaceAccess({request, workspaceId});
+    handler: async (request, reply) => {
+      const {workspaceId, providerId} = request.params;
+      requireWorkspaceAccess({request, workspaceId});
 
-    const deleted = await deleteModelProviderConfig({workspaceId, providerId});
-    if (!deleted) {
-      throw new ClientError('Model provider configuration not found', 'not-found', {status: 404});
-    }
+      const deleted = await deleteModelProviderConfig({workspaceId, providerId}, {secrets});
+      if (!deleted) {
+        throw new ClientError('Model provider configuration not found', 'not-found', {status: 404});
+      }
 
-    reply.code(204);
-  },
-});
+      reply.code(204);
+    },
+  });
+}

package/src/presentation/routes/discover-custom-model-provider-models-by-slug.ts

@@ -10,33 +10,39 @@ import {
   discoverCustomModelProviderModels,
   resolveCustomModelProviderDiscoveryParams,
 } from '#core/index.js';
+import type {AgentSecretsClient} from '#core/secrets-client.js';
 import {translateModelProviderRouteError} from './errors.js';
 
-export const discoverCustomModelProviderModelsBySlugRoute = defineRoute({
-  method: 'POST',
-  path: '/custom-model-providers/:slug/discover-models',
-  description: 'Discover models for a stored custom model provider configuration',
-  schema: {
-    params: z.object({
-      workspaceId: z.string().uuid(),
-      slug: modelProviderRefSchema,
-    }),
-    body: discoverCustomModelProviderModelsBySlugBodySchema,
-    response: {
-      200: discoverCustomModelProviderModelsResponseSchema,
+export function createDiscoverCustomModelProviderModelsBySlugRoute(secrets: AgentSecretsClient) {
+  return defineRoute({
+    method: 'POST',
+    path: '/custom-model-providers/:slug/discover-models',
+    description: 'Discover models for a stored custom model provider configuration',
+    schema: {
+      params: z.object({
+        workspaceId: z.string().uuid(),
+        slug: modelProviderRefSchema,
+      }),
+      body: discoverCustomModelProviderModelsBySlugBodySchema,
+      response: {
+        200: discoverCustomModelProviderModelsResponseSchema,
+      },
     },
-  },
-  errorHandler: translateModelProviderRouteError,
-  handler: async (request) => {
-    const {workspaceId, slug} = request.params;
-    requireWorkspaceAccess({request, workspaceId});
+    errorHandler: translateModelProviderRouteError,
+    handler: async (request) => {
+      const {workspaceId, slug} = request.params;
+      requireWorkspaceAccess({request, workspaceId});
 
-    const discoveryParams = await resolveCustomModelProviderDiscoveryParams({
-      workspaceId,
-      providerId: slug,
-      body: request.body ?? {},
-    });
+      const discoveryParams = await resolveCustomModelProviderDiscoveryParams(
+        {
+          workspaceId,
+          providerId: slug,
+          body: request.body ?? {},
+        },
+        {secrets},
+      );
 
-    return await discoverCustomModelProviderModels(discoveryParams);
-  },
-});
+      return await discoverCustomModelProviderModels(discoveryParams);
+    },
+  });
+}

package/src/presentation/routes/errors.ts

@@ -1,5 +1,6 @@
 import {getModelProviderCredentialKeys} from '@shipfox/api-agent-dto';
-import {SecretValueTooLargeError, WorkspaceSecretCapExceededError} from '@shipfox/api-secrets';
+import {secretsInterModuleContract} from '@shipfox/api-secrets-dto/inter-module';
+import {isInterModuleKnownError} from '@shipfox/inter-module';
 import {EgressDeniedError} from '@shipfox/node-egress-guard';
 import {ClientError} from '@shipfox/node-fastify';
 import {
@@ -104,17 +105,16 @@ export function translateModelProviderRouteError(error: unknown): never {
     });
   }
 
-  if (error instanceof WorkspaceSecretCapExceededError) {
-    throw new ClientError('Workspace secret cap exceeded', 'workspace-secret-cap-exceeded', {
-      status: 409,
-      details: {cap: error.cap},
-    });
-  }
-
-  if (error instanceof SecretValueTooLargeError) {
-    throw new ClientError(error.message, 'value-too-large', {
+  if (isInterModuleKnownError(secretsInterModuleContract.methods.setSecrets, error)) {
+    if (error.code === 'workspace-secret-cap-exceeded') {
+      throw new ClientError('Workspace secret cap exceeded', 'workspace-secret-cap-exceeded', {
+        status: 409,
+        details: {cap: error.details.cap},
+      });
+    }
+    throw new ClientError('Secret value is too large', 'value-too-large', {
       status: 400,
-      details: {max_bytes: error.maxBytes},
+      details: {max_bytes: error.details.maxBytes},
     });
   }
 

package/src/presentation/routes/index.ts

@@ -1,37 +1,42 @@
 import {AUTH_USER} from '@shipfox/api-auth-context';
 import type {RouteGroup} from '@shipfox/node-fastify';
+import type {AgentSecretsClient} from '#core/secrets-client.js';
 import {createCustomModelProviderRoute} from './create-custom-model-provider.js';
-import {deleteModelProviderConfigRoute} from './delete-model-provider-config.js';
+import {createDeleteModelProviderConfigRoute} from './delete-model-provider-config.js';
 import {discoverCustomModelProviderModelsRoute} from './discover-custom-model-provider-models.js';
-import {discoverCustomModelProviderModelsBySlugRoute} from './discover-custom-model-provider-models-by-slug.js';
+import {createDiscoverCustomModelProviderModelsBySlugRoute} from './discover-custom-model-provider-models-by-slug.js';
 import {listModelProviderCatalogRoute} from './list-model-provider-catalog.js';
 import {listModelProviderConfigsRoute} from './list-model-provider-configs.js';
 import {setDefaultHarnessRoute} from './set-default-harness.js';
 import {setDefaultModelProviderRoute} from './set-default-model-provider.js';
-import {updateCustomModelProviderRoute} from './update-custom-model-provider.js';
+import {createUpdateCustomModelProviderRoute} from './update-custom-model-provider.js';
 import {updateModelProviderDefaultModelRoute} from './update-model-provider-default-model.js';
-import {upsertModelProviderConfigRoute} from './upsert-model-provider-config.js';
+import {createUpsertModelProviderConfigRoute} from './upsert-model-provider-config.js';
 
-export const agentRoutes: RouteGroup[] = [
-  {
-    prefix: '/workspaces/:workspaceId/agent',
-    auth: AUTH_USER,
-    routes: [
-      listModelProviderConfigsRoute,
-      createCustomModelProviderRoute,
-      discoverCustomModelProviderModelsRoute,
-      discoverCustomModelProviderModelsBySlugRoute,
-      updateCustomModelProviderRoute,
-      upsertModelProviderConfigRoute,
-      updateModelProviderDefaultModelRoute,
-      deleteModelProviderConfigRoute,
-      setDefaultHarnessRoute,
-      setDefaultModelProviderRoute,
-    ],
-  },
-  {
-    prefix: '/agent',
-    auth: AUTH_USER,
-    routes: [listModelProviderCatalogRoute],
-  },
-];
+export function createAgentRoutes(secrets: AgentSecretsClient): RouteGroup[] {
+  return [
+    {
+      prefix: '/workspaces/:workspaceId/agent',
+      auth: AUTH_USER,
+      routes: [
+        listModelProviderConfigsRoute,
+        createCustomModelProviderRoute(secrets),
+        discoverCustomModelProviderModelsRoute,
+        createDiscoverCustomModelProviderModelsBySlugRoute(secrets),
+        createUpdateCustomModelProviderRoute(secrets),
+        createUpsertModelProviderConfigRoute(secrets),
+        updateModelProviderDefaultModelRoute,
+        createDeleteModelProviderConfigRoute(secrets),
+        setDefaultHarnessRoute,
+        setDefaultModelProviderRoute,
+      ],
+    },
+    {
+      prefix: '/agent',
+      auth: AUTH_USER,
+      routes: [listModelProviderCatalogRoute],
+    },
+  ];
+}
+
+export const agentRoutes = createAgentRoutes(undefined as unknown as AgentSecretsClient);

package/src/presentation/routes/model-provider-config.test.ts

@@ -6,7 +6,6 @@ import {
   setUserContext,
   type UserContextMembership,
 } from '@shipfox/api-auth-context';
-import {getSecretsByNamespace, setSecrets} from '@shipfox/api-secrets';
 import type {AuthMethod, FastifyRequest} from '@shipfox/node-fastify';
 import {ClientError, closeApp, createApp} from '@shipfox/node-fastify';
 import {eq} from 'drizzle-orm';
@@ -20,6 +19,7 @@ import {
   upsertModelProviderConfig,
 } from '#db/index.js';
 import {modelProviderConfigs} from '#db/schema/model-provider-configs.js';
+import {getSecretsByNamespace, setSecrets} from '#test/fixtures/secrets-client.js';
 import {agentRoutes} from './index.js';
 
 vi.mock('@earendil-works/pi-ai', async (importOriginal) => {

package/src/presentation/routes/update-custom-model-provider.ts

@@ -7,44 +7,50 @@ import {requireWorkspaceAccess} from '@shipfox/api-auth-context';
 import {defineRoute} from '@shipfox/node-fastify';
 import {z} from 'zod';
 import {updateCustomModelProviderConfig} from '#core/index.js';
+import type {AgentSecretsClient} from '#core/secrets-client.js';
 import {toCustomModelProviderConfigDto} from '#presentation/dto/index.js';
 import {translateModelProviderRouteError} from './errors.js';
 
-export const updateCustomModelProviderRoute = defineRoute({
-  method: 'PUT',
-  path: '/custom-model-providers/:slug',
-  description: 'Update a custom model provider configuration for a workspace',
-  schema: {
-    params: z.object({
-      workspaceId: z.string().uuid(),
-      slug: modelProviderRefSchema,
-    }),
-    body: updateCustomModelProviderBodySchema,
-    response: {
-      200: customModelProviderConfigDtoSchema,
+export function createUpdateCustomModelProviderRoute(secrets: AgentSecretsClient) {
+  return defineRoute({
+    method: 'PUT',
+    path: '/custom-model-providers/:slug',
+    description: 'Update a custom model provider configuration for a workspace',
+    schema: {
+      params: z.object({
+        workspaceId: z.string().uuid(),
+        slug: modelProviderRefSchema,
+      }),
+      body: updateCustomModelProviderBodySchema,
+      response: {
+        200: customModelProviderConfigDtoSchema,
+      },
     },
-  },
-  errorHandler: translateModelProviderRouteError,
-  handler: async (request, reply) => {
-    const {workspaceId, slug} = request.params;
-    const abortController = new AbortController();
-    let responseFinished = false;
-    reply.raw.on('finish', () => {
-      responseFinished = true;
-    });
-    reply.raw.on('close', () => {
-      if (!responseFinished) abortController.abort();
-    });
+    errorHandler: translateModelProviderRouteError,
+    handler: async (request, reply) => {
+      const {workspaceId, slug} = request.params;
+      const abortController = new AbortController();
+      let responseFinished = false;
+      reply.raw.on('finish', () => {
+        responseFinished = true;
+      });
+      reply.raw.on('close', () => {
+        if (!responseFinished) abortController.abort();
+      });
 
-    requireWorkspaceAccess({request, workspaceId});
+      requireWorkspaceAccess({request, workspaceId});
 
-    const config = await updateCustomModelProviderConfig({
-      workspaceId,
-      providerId: slug,
-      body: request.body,
-      signal: abortController.signal,
-    });
+      const config = await updateCustomModelProviderConfig(
+        {
+          workspaceId,
+          providerId: slug,
+          body: request.body,
+          signal: abortController.signal,
+        },
+        {secrets},
+      );
 
-    return toCustomModelProviderConfigDto(config);
-  },
-});
+      return toCustomModelProviderConfigDto(config);
+    },
+  });
+}