@shipfox/api-agent-dto 2.0.0

package/src/schemas/custom-model-provider.test.ts

@@ -0,0 +1,294 @@
+import {
+  createCustomModelProviderBodySchema,
+  customAgentModelSchema,
+  customModelProviderConfigDtoSchema,
+  customModelProviderHeaderRequestSchema,
+  customModelProviderRuntimeConfigSchema,
+  discoverCustomModelProviderModelsBodySchema,
+  discoverCustomModelProviderModelsBySlugBodySchema,
+  discoverCustomModelProviderModelsResponseSchema,
+  isReservedModelProviderId,
+  updateCustomModelProviderBodySchema,
+  updateCustomModelProviderHeaderRequestSchema,
+} from './index.js';
+import {MODEL_PROVIDER_IDS} from './model-provider-id.js';
+
+describe('custom model provider schemas', () => {
+  describe.each(MODEL_PROVIDER_IDS)('modelProviderRefSchema "%s"', (providerId) => {
+    it('accepts built-in provider ids as refs', async () => {
+      const {modelProviderRefSchema} = await import('./model-provider-id.js');
+
+      const parsed = modelProviderRefSchema.parse(providerId);
+
+      expect(parsed).toBe(providerId);
+    });
+  });
+
+  it('accepts valid custom model provider slugs', async () => {
+    const {modelProviderRefSchema} = await import('./model-provider-id.js');
+
+    const parsed = modelProviderRefSchema.parse('local-vllm-1');
+
+    expect(parsed).toBe('local-vllm-1');
+  });
+
+  it.each([
+    'ab',
+    '-local',
+    'local-',
+    'Local',
+    'local_vllm',
+  ])('rejects invalid slug "%s"', async (slug) => {
+    const {modelProviderRefSchema} = await import('./model-provider-id.js');
+
+    const parse = () => modelProviderRefSchema.parse(slug);
+
+    expect(parse).toThrow();
+  });
+
+  it('detects reserved built-in provider ids', () => {
+    expect(isReservedModelProviderId('anthropic')).toBe(true);
+    expect(isReservedModelProviderId('local-vllm')).toBe(false);
+  });
+
+  it('rejects a create body whose slug shadows a built-in provider id', () => {
+    const parse = () =>
+      createCustomModelProviderBodySchema.parse({
+        ...createBody(),
+        slug: 'anthropic',
+      });
+
+    expect(parse).toThrow();
+  });
+
+  it('parses model optional overrides', () => {
+    const parsed = customAgentModelSchema.parse({
+      id: 'llama-3.1',
+      label: 'Llama 3.1',
+      context_window: 128_000,
+      max_output_tokens: 4096,
+      input_image: true,
+      reasoning: false,
+    });
+
+    expect(parsed.context_window).toBe(128_000);
+    expect(parsed.max_output_tokens).toBe(4096);
+  });
+
+  it('rejects invalid model bounds', () => {
+    const parse = () =>
+      customAgentModelSchema.parse({
+        id: '',
+        label: 'Llama 3.1',
+        context_window: 0,
+      });
+
+    expect(parse).toThrow();
+  });
+
+  it('requires create default_model to be one of the configured models', () => {
+    const parsed = createCustomModelProviderBodySchema.parse({
+      ...createBody(),
+      default_model: 'llama-3.1',
+    });
+    const parse = () =>
+      createCustomModelProviderBodySchema.parse({
+        ...createBody(),
+        default_model: 'missing-model',
+      });
+
+    expect(parsed.default_model).toBe('llama-3.1');
+    expect(parse).toThrow();
+  });
+
+  it('requires at least one unique model id', () => {
+    const emptyModels = () =>
+      createCustomModelProviderBodySchema.parse({
+        ...createBody(),
+        models: [],
+      });
+    const duplicateModels = () =>
+      createCustomModelProviderBodySchema.parse({
+        ...createBody(),
+        models: [
+          {id: 'llama-3.1', label: 'Llama 3.1'},
+          {id: 'llama-3.1', label: 'Llama 3.1 duplicate'},
+        ],
+      });
+
+    expect(emptyModels).toThrow();
+    expect(duplicateModels).toThrow();
+  });
+
+  it('checks update default_model against models only when both are present', () => {
+    const modelOnly = updateCustomModelProviderBodySchema.parse({
+      default_model: 'stored-model',
+    });
+    const validWithModels = updateCustomModelProviderBodySchema.parse({
+      models: [{id: 'llama-3.1', label: 'Llama 3.1'}],
+      default_model: 'llama-3.1',
+    });
+    const invalidWithModels = () =>
+      updateCustomModelProviderBodySchema.parse({
+        models: [{id: 'llama-3.1', label: 'Llama 3.1'}],
+        default_model: 'missing-model',
+      });
+
+    expect(modelOnly.default_model).toBe('stored-model');
+    expect(validWithModels.default_model).toBe('llama-3.1');
+    expect(invalidWithModels).toThrow();
+  });
+
+  it('parses request header rows and lowercases names', () => {
+    const parsed = customModelProviderHeaderRequestSchema.parse({
+      name: 'Authorization',
+      value: 'Bearer secret',
+      secret: true,
+    });
+
+    expect(parsed).toEqual({
+      name: 'authorization',
+      value: 'Bearer secret',
+      secret: true,
+    });
+  });
+
+  it('parses update header keep rows for stored secret headers', () => {
+    const parsed = updateCustomModelProviderHeaderRequestSchema.parse({
+      name: 'Authorization',
+      secret: true,
+      keep: true,
+    });
+
+    expect(parsed).toEqual({
+      name: 'authorization',
+      secret: true,
+      keep: true,
+    });
+  });
+
+  it('rejects update header rows that keep non-secret or valued headers', () => {
+    const nonSecretKeep = () =>
+      updateCustomModelProviderHeaderRequestSchema.parse({
+        name: 'authorization',
+        secret: false,
+        keep: true,
+      });
+    const valuedKeep = () =>
+      updateCustomModelProviderHeaderRequestSchema.parse({
+        name: 'authorization',
+        value: 'Bearer secret',
+        secret: true,
+        keep: true,
+      });
+    const missingValue = () =>
+      updateCustomModelProviderHeaderRequestSchema.parse({
+        name: 'x-region',
+        secret: false,
+      });
+
+    expect(nonSecretKeep).toThrow();
+    expect(valuedKeep).toThrow();
+    expect(missingValue).toThrow();
+  });
+
+  it('rejects duplicate header names case-insensitively', () => {
+    const parse = () =>
+      createCustomModelProviderBodySchema.parse({
+        ...createBody(),
+        headers: [
+          {name: 'Authorization', value: 'Bearer secret', secret: true},
+          {name: 'authorization', value: 'debug', secret: false},
+        ],
+      });
+
+    expect(parse).toThrow();
+  });
+
+  it('rejects invalid URLs and oversized header lists', () => {
+    const invalidUrl = () =>
+      createCustomModelProviderBodySchema.parse({
+        ...createBody(),
+        base_url: 'not a url',
+      });
+    const tooManyHeaders = () =>
+      createCustomModelProviderBodySchema.parse({
+        ...createBody(),
+        headers: Array.from({length: 33}, (_, index) => ({
+          name: `x-test-${index}`,
+          value: 'value',
+          secret: false,
+        })),
+      });
+
+    expect(invalidUrl).toThrow();
+    expect(tooManyHeaders).toThrow();
+  });
+
+  it('parses a custom config read DTO without secret values', () => {
+    const parsed = customModelProviderConfigDtoSchema.parse({
+      kind: 'custom',
+      provider_id: 'local-vllm',
+      display_name: 'Local vLLM',
+      api: 'openai-responses',
+      base_url: 'https://llm.example.test/v1',
+      headers: [{name: 'x-region', value: 'local'}],
+      secret_header_names: ['authorization'],
+      models: [{id: 'llama-3.1', label: 'Llama 3.1'}],
+      default_model: null,
+      created_at: '2026-06-27T10:30:00.000Z',
+      updated_at: '2026-06-27T10:45:00.000Z',
+    });
+
+    expect(parsed.secret_header_names).toEqual(['authorization']);
+    expect('requires_api_key' in parsed).toBe(false);
+  });
+
+  it('requires key intent on custom provider runtime descriptors', () => {
+    const parsed = customModelProviderRuntimeConfigSchema.parse({
+      api: 'openai-responses',
+      base_url: 'https://llm.example.test/v1',
+      headers: [{name: 'x-region', value: 'local'}],
+      secret_header_names: ['authorization'],
+      models: [{id: 'llama-3.1', label: 'Llama 3.1'}],
+      requires_api_key: false,
+    });
+
+    expect(parsed.requires_api_key).toBe(false);
+  });
+
+  it('parses discovery request and response DTOs', () => {
+    const body = discoverCustomModelProviderModelsBodySchema.parse({
+      api: 'openai-responses',
+      base_url: 'https://llm.example.test/v1',
+      api_key: 'sk-local',
+      headers: [{name: 'X-Region', value: 'local'}],
+    });
+    const response = discoverCustomModelProviderModelsResponseSchema.parse({
+      models: [{id: 'llama-3.1', label: 'Llama 3.1'}],
+    });
+
+    expect(body.headers?.[0]?.name).toBe('x-region');
+    expect(response.models[0]?.id).toBe('llama-3.1');
+  });
+
+  it('parses slug-scoped discovery request DTOs with keep headers', () => {
+    const body = discoverCustomModelProviderModelsBySlugBodySchema.parse({
+      headers: [{name: 'Authorization', secret: true, keep: true}],
+    });
+
+    expect(body.headers?.[0]).toEqual({name: 'authorization', secret: true, keep: true});
+  });
+});
+
+function createBody() {
+  return {
+    slug: 'local-vllm',
+    display_name: 'Local vLLM',
+    api: 'openai-responses',
+    base_url: 'https://llm.example.test/v1',
+    api_key: 'sk-local',
+    headers: [{name: 'x-region', value: 'local', secret: false}],
+    models: [{id: 'llama-3.1', label: 'Llama 3.1'}],
+  } as const;
+}

package/src/schemas/custom-model-provider.ts

@@ -0,0 +1,258 @@
+import {z} from 'zod';
+import {isReservedModelProviderId, modelProviderRefSchema} from './model-provider-id.js';
+
+const MAX_HEADER_COUNT = 32;
+export const MAX_MODEL_COUNT = 128;
+
+export const DEFAULT_CUSTOM_MODEL_CONTEXT_WINDOW = 128_000;
+export const DEFAULT_CUSTOM_MODEL_MAX_OUTPUT_TOKENS = 16_384;
+export const DEFAULT_CUSTOM_MODEL_INPUT_IMAGE = false;
+export const DEFAULT_CUSTOM_MODEL_REASONING = false;
+
+const headerNameSchema = z
+  .string()
+  .trim()
+  .min(1)
+  .max(128)
+  .regex(/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/)
+  .transform((name) => name.toLowerCase());
+
+const headerValueSchema = z.string().min(1).max(8192);
+const modelIdSchema = z.string().min(1).max(128);
+
+export const modelProviderApiSchema = z.enum([
+  'openai-completions',
+  'openai-responses',
+  'anthropic-messages',
+  'google-generative-ai',
+]);
+
+export type ModelProviderApi = z.infer<typeof modelProviderApiSchema>;
+
+export const customAgentModelSchema = z.object({
+  id: modelIdSchema,
+  label: z.string().min(1).max(160),
+  context_window: z.number().int().positive().optional(),
+  max_output_tokens: z.number().int().positive().optional(),
+  input_image: z.boolean().optional(),
+  reasoning: z.boolean().optional(),
+});
+
+export type CustomAgentModelDto = z.infer<typeof customAgentModelSchema>;
+
+export const customModelProviderHeaderDtoSchema = z.object({
+  name: headerNameSchema,
+  value: headerValueSchema,
+});
+
+export type CustomModelProviderHeaderDto = z.infer<typeof customModelProviderHeaderDtoSchema>;
+
+export const customModelProviderHeaderRequestSchema = customModelProviderHeaderDtoSchema.extend({
+  secret: z.boolean(),
+});
+
+export type CustomModelProviderHeaderRequestDto = z.infer<
+  typeof customModelProviderHeaderRequestSchema
+>;
+
+export const updateCustomModelProviderHeaderRequestSchema = z
+  .object({
+    name: headerNameSchema,
+    value: headerValueSchema.optional(),
+    secret: z.boolean(),
+    keep: z.boolean().optional(),
+  })
+  .superRefine((header, ctx) => {
+    if (header.keep === true) {
+      if (!header.secret) {
+        ctx.addIssue({
+          code: 'custom',
+          path: ['secret'],
+          message: 'Kept headers must be secret.',
+        });
+      }
+      if (header.value !== undefined) {
+        ctx.addIssue({
+          code: 'custom',
+          path: ['value'],
+          message: 'Kept headers must not include a value.',
+        });
+      }
+      return;
+    }
+
+    if (header.value === undefined) {
+      ctx.addIssue({
+        code: 'custom',
+        path: ['value'],
+        message: 'Header value is required.',
+      });
+    }
+  });
+
+export type UpdateCustomModelProviderHeaderRequestDto = z.infer<
+  typeof updateCustomModelProviderHeaderRequestSchema
+>;
+
+const customModelProviderHeadersRequestSchema = z
+  .array(customModelProviderHeaderRequestSchema)
+  .max(MAX_HEADER_COUNT)
+  .superRefine(assertUniqueHeaderNames);
+
+const updateCustomModelProviderHeadersRequestSchema = z
+  .array(updateCustomModelProviderHeaderRequestSchema)
+  .max(MAX_HEADER_COUNT)
+  .superRefine(assertUniqueHeaderNames);
+
+const customModelProviderHeadersDtoSchema = z
+  .array(customModelProviderHeaderDtoSchema)
+  .max(MAX_HEADER_COUNT)
+  .superRefine(assertUniqueHeaderNames);
+
+const customModelProviderModelsSchema = z
+  .array(customAgentModelSchema)
+  .min(1)
+  .max(MAX_MODEL_COUNT)
+  .superRefine(assertUniqueModelIds);
+
+const customModelProviderBodyFields = {
+  display_name: z.string().min(1).max(120),
+  api: modelProviderApiSchema,
+  base_url: z.string().url().max(2048),
+  api_key: z.string().min(1).max(8192).optional(),
+  models: customModelProviderModelsSchema,
+  default_model: modelIdSchema.nullable().optional(),
+};
+
+export const createCustomModelProviderBodySchema = z
+  .object({
+    slug: modelProviderRefSchema.refine((slug) => !isReservedModelProviderId(slug), {
+      message: 'Provider ID is reserved.',
+    }),
+    ...customModelProviderBodyFields,
+    headers: customModelProviderHeadersRequestSchema.optional(),
+  })
+  .superRefine(assertDefaultModelInModels);
+
+export type CreateCustomModelProviderBodyDto = z.infer<typeof createCustomModelProviderBodySchema>;
+
+export const updateCustomModelProviderBodySchema = z
+  .object({
+    ...customModelProviderBodyFields,
+    headers: updateCustomModelProviderHeadersRequestSchema.optional(),
+    models: customModelProviderModelsSchema.optional(),
+  })
+  .partial()
+  .superRefine((body, ctx) => {
+    if (body.models === undefined) return;
+    assertDefaultModelInModels(body, ctx);
+  });
+
+export type UpdateCustomModelProviderBodyDto = z.infer<typeof updateCustomModelProviderBodySchema>;
+
+export const discoverCustomModelProviderModelsBodySchema = z.object({
+  api: modelProviderApiSchema,
+  base_url: z.string().url().max(2048),
+  api_key: z.string().min(1).max(8192).optional(),
+  headers: customModelProviderHeadersDtoSchema.optional(),
+});
+
+export type DiscoverCustomModelProviderModelsBodyDto = z.infer<
+  typeof discoverCustomModelProviderModelsBodySchema
+>;
+
+export const discoverCustomModelProviderModelsBySlugBodySchema = z.object({
+  api: modelProviderApiSchema.optional(),
+  base_url: z.string().url().max(2048).optional(),
+  api_key: z.string().min(1).max(8192).optional(),
+  headers: updateCustomModelProviderHeadersRequestSchema.optional(),
+});
+
+export type DiscoverCustomModelProviderModelsBySlugBodyDto = z.infer<
+  typeof discoverCustomModelProviderModelsBySlugBodySchema
+>;
+
+export const discoverCustomModelProviderModelsResponseSchema = z.object({
+  models: z
+    .array(z.object({id: modelIdSchema, label: z.string().min(1).max(160)}))
+    .max(MAX_MODEL_COUNT),
+});
+
+export type DiscoverCustomModelProviderModelsResponseDto = z.infer<
+  typeof discoverCustomModelProviderModelsResponseSchema
+>;
+
+const customModelProviderConfigBaseSchema = z.object({
+  api: modelProviderApiSchema,
+  base_url: z.string().url().max(2048),
+  headers: customModelProviderHeadersDtoSchema,
+  secret_header_names: z
+    .array(headerNameSchema)
+    .max(MAX_HEADER_COUNT)
+    .superRefine(assertUniqueStrings),
+  models: customModelProviderModelsSchema,
+});
+
+export const customModelProviderRuntimeConfigSchema = customModelProviderConfigBaseSchema.extend({
+  requires_api_key: z.boolean(),
+});
+
+export type CustomModelProviderRuntimeConfigDto = z.infer<
+  typeof customModelProviderRuntimeConfigSchema
+>;
+
+export const customModelProviderConfigDtoSchema = customModelProviderConfigBaseSchema.extend({
+  kind: z.literal('custom'),
+  provider_id: modelProviderRefSchema,
+  display_name: z.string().min(1).max(120),
+  default_model: modelIdSchema.nullable(),
+  created_at: z.string().datetime(),
+  updated_at: z.string().datetime(),
+});
+
+export type CustomModelProviderConfigDto = z.infer<typeof customModelProviderConfigDtoSchema>;
+
+function assertDefaultModelInModels(
+  body: {default_model?: string | null | undefined; models?: CustomAgentModelDto[] | undefined},
+  ctx: z.RefinementCtx,
+): void {
+  if (typeof body.default_model !== 'string' || body.models === undefined) return;
+
+  if (!body.models.some((model) => model.id === body.default_model)) {
+    ctx.addIssue({
+      code: 'custom',
+      path: ['default_model'],
+      message: 'Default model must be one of the configured models.',
+    });
+  }
+}
+
+function assertUniqueHeaderNames(headers: Array<{name: string}>, ctx: z.RefinementCtx): void {
+  assertUniqueStrings(
+    headers.map((header) => header.name),
+    ctx,
+  );
+}
+
+function assertUniqueModelIds(models: CustomAgentModelDto[], ctx: z.RefinementCtx): void {
+  assertUniqueStrings(
+    models.map((model) => model.id),
+    ctx,
+  );
+}
+
+function assertUniqueStrings(values: string[], ctx: z.RefinementCtx): void {
+  const seen = new Set<string>();
+  for (const [index, value] of values.entries()) {
+    if (!seen.has(value)) {
+      seen.add(value);
+      continue;
+    }
+
+    ctx.addIssue({
+      code: 'custom',
+      path: [index],
+      message: 'Duplicate value.',
+    });
+  }
+}

package/src/schemas/harness.test.ts

@@ -0,0 +1,133 @@
+import {
+  buildHarnessToolDeploymentConfig,
+  DEFAULT_HARNESS_TOOL_DEPLOYMENT_CONFIG,
+  getHarnessToolDescriptor,
+  harnessSupportsTool,
+  listEnabledHarnessTools,
+  listHarnessTools,
+  parsePiEnabledToolPackages,
+} from './harness.js';
+
+const PI_BUILT_IN_TOOLS = ['read', 'bash', 'edit', 'write', 'grep', 'find', 'ls'];
+const PI_WEB_ACCESS_TOOLS = ['web_search', 'fetch_content', 'get_search_content'];
+const CLAUDE_TOOLS = ['Read', 'Bash', 'Edit', 'Write', 'Glob', 'Grep', 'WebFetch', 'WebSearch'];
+const piToolPackagesEnvPattern = /AGENT_PI_ENABLED_TOOL_PACKAGES/;
+
+describe('harness tool catalog', () => {
+  it('lists exact pi tool names in catalog order', () => {
+    const toolNames = listHarnessTools('pi').map((tool) => tool.name);
+
+    expect(toolNames).toEqual([...PI_BUILT_IN_TOOLS, ...PI_WEB_ACCESS_TOOLS]);
+  });
+
+  it('lists exact Claude tool names in catalog order', () => {
+    const toolNames = listHarnessTools('claude').map((tool) => tool.name);
+
+    expect(toolNames).toEqual(CLAUDE_TOOLS);
+  });
+
+  it('marks pi web access tools as package-backed catalog entries', () => {
+    const packageTools = PI_WEB_ACCESS_TOOLS.map((toolName) =>
+      getHarnessToolDescriptor('pi', toolName),
+    );
+
+    expect(packageTools).toEqual(
+      PI_WEB_ACCESS_TOOLS.map((toolName) =>
+        expect.objectContaining({
+          name: toolName,
+          source: 'package',
+          packageName: 'pi-web-access',
+          enabledByDefault: true,
+        }),
+      ),
+    );
+  });
+
+  it('leaves pi package-backed tools unavailable unless their package is enabled', () => {
+    const enabledToolNames = listEnabledHarnessTools('pi').map((tool) => tool.name);
+
+    expect(enabledToolNames).toEqual(PI_BUILT_IN_TOOLS);
+    expect(harnessSupportsTool('pi', 'fetch_content')).toBe(false);
+    expect(harnessSupportsTool('pi', 'web_search')).toBe(false);
+    expect(harnessSupportsTool('pi', 'get_search_content')).toBe(false);
+  });
+
+  it('enables pi web access tools when pi-web-access is enabled', () => {
+    const deploymentConfig = {pi: {enabledToolPackages: ['pi-web-access']}} as const;
+    const enabledToolNames = listEnabledHarnessTools('pi', deploymentConfig).map(
+      (tool) => tool.name,
+    );
+
+    expect(enabledToolNames).toEqual([...PI_BUILT_IN_TOOLS, ...PI_WEB_ACCESS_TOOLS]);
+    expect(harnessSupportsTool('pi', 'fetch_content', deploymentConfig)).toBe(true);
+    expect(harnessSupportsTool('pi', 'web_search', deploymentConfig)).toBe(true);
+    expect(harnessSupportsTool('pi', 'get_search_content', deploymentConfig)).toBe(true);
+  });
+
+  it('builds deployment defaults with pi web access and search enabled', () => {
+    expect(DEFAULT_HARNESS_TOOL_DEPLOYMENT_CONFIG).toEqual({
+      pi: {enabledToolPackages: ['pi-web-access'], webSearchEnabled: true},
+      claude: {enabledToolPackages: []},
+    });
+
+    const enabledToolNames = listEnabledHarnessTools(
+      'pi',
+      DEFAULT_HARNESS_TOOL_DEPLOYMENT_CONFIG,
+    ).map((tool) => tool.name);
+    expect(enabledToolNames).toEqual([...PI_BUILT_IN_TOOLS, ...PI_WEB_ACCESS_TOOLS]);
+  });
+
+  it('deduplicates comma-delimited Pi tool package names', () => {
+    const packageNames = parsePiEnabledToolPackages(' pi-web-access,pi-web-access ');
+
+    expect(packageNames).toEqual(['pi-web-access']);
+  });
+
+  it('allows an empty Pi tool package list', () => {
+    const packageNames = parsePiEnabledToolPackages('');
+
+    expect(packageNames).toEqual([]);
+  });
+
+  it('rejects unknown Pi tool package names with the env var name', () => {
+    expect(() => parsePiEnabledToolPackages('pi-web-access,unknown')).toThrow(
+      piToolPackagesEnvPattern,
+    );
+  });
+
+  it('keeps pi fetch content enabled when web search is disabled', () => {
+    const deploymentConfig = {
+      pi: {enabledToolPackages: ['pi-web-access'], webSearchEnabled: false},
+    } as const;
+    const enabledToolNames = listEnabledHarnessTools('pi', deploymentConfig).map(
+      (tool) => tool.name,
+    );
+
+    expect(enabledToolNames).toEqual([...PI_BUILT_IN_TOOLS, 'fetch_content']);
+    expect(harnessSupportsTool('pi', 'fetch_content', deploymentConfig)).toBe(true);
+    expect(harnessSupportsTool('pi', 'web_search', deploymentConfig)).toBe(false);
+    expect(harnessSupportsTool('pi', 'get_search_content', deploymentConfig)).toBe(false);
+  });
+
+  it('builds deployment config from explicit Pi package and search settings', () => {
+    const deploymentConfig = buildHarnessToolDeploymentConfig({
+      piEnabledToolPackages: 'pi-web-access, pi-web-access',
+      piWebSearchEnabled: false,
+    });
+
+    expect(deploymentConfig).toEqual({
+      pi: {enabledToolPackages: ['pi-web-access'], webSearchEnabled: false},
+      claude: {enabledToolPackages: []},
+    });
+  });
+
+  it('matches harness tool names case-sensitively', () => {
+    const piDeploymentConfig = {pi: {enabledToolPackages: ['pi-web-access']}} as const;
+
+    expect(getHarnessToolDescriptor('pi', 'WebSearch')).toBeUndefined();
+    expect(harnessSupportsTool('pi', 'WebSearch', piDeploymentConfig)).toBe(false);
+    expect(getHarnessToolDescriptor('claude', 'web_search')).toBeUndefined();
+    expect(harnessSupportsTool('claude', 'web_search')).toBe(false);
+    expect(harnessSupportsTool('claude', 'WebSearch')).toBe(true);
+  });
+});