refactor: consolidate provider types to single source of truth

Eliminates triple-definition of ProviderConfigInfo/AWSCredentialStatus types
that existed in providerService.ts, Settings/types.ts, and the oRPC schema.
Now the Zod schema is the single source of truth, with TypeScript types
derived via z.infer.

Adds conformance tests that validate oRPC schemas preserve all fields when
parsing - this would have caught the missing couponCodeSet/aws fields bug.

Author: ThomasK33

src/browser/components/Settings/types.ts

@@ -1,28 +1,19 @@
 import type { ReactNode } from "react";
+import type {
+  AWSCredentialStatus,
+  ProviderConfigInfo,
+  ProvidersConfigMap,
+} from "@/common/orpc/types";
+
+// Re-export types for local usage
+export type { AWSCredentialStatus, ProvidersConfigMap };
+
+// Alias for backward compatibility (ProviderConfigDisplay was the old name)
+export type ProviderConfigDisplay = ProviderConfigInfo;
 
 export interface SettingsSection {
   id: string;
   label: string;
   icon: ReactNode;
   component: React.ComponentType;
 }
-
-/** AWS credential status for Bedrock provider */
-export interface AWSCredentialStatus {
-  region?: string;
-  bearerTokenSet: boolean;
-  accessKeyIdSet: boolean;
-  secretAccessKeySet: boolean;
-}
-
-export interface ProviderConfigDisplay {
-  apiKeySet: boolean;
-  baseUrl?: string;
-  models?: string[];
-  /** AWS-specific fields (only present for bedrock provider) */
-  aws?: AWSCredentialStatus;
-  /** Mux Gateway-specific fields */
-  couponCodeSet?: boolean;
-}
-
-export type ProvidersConfigMap = Record<string, ProviderConfigDisplay>;

src/common/orpc/schemas.ts

@@ -90,6 +90,7 @@ export {
 
 // API router schemas
 export {
+  AWSCredentialStatusSchema,
   general,
   menu,
   projects,

src/common/orpc/schemas/api.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, it } from "bun:test";
+import {
+  AWSCredentialStatusSchema,
+  ProviderConfigInfoSchema,
+  ProvidersConfigMapSchema,
+} from "./api";
+import type { AWSCredentialStatus, ProviderConfigInfo, ProvidersConfigMap } from "../types";
+
+/**
+ * Schema conformance tests for provider types.
+ *
+ * These tests ensure that the Zod schemas preserve all fields when parsing data.
+ * oRPC uses these schemas for output validation and strips fields not in the schema,
+ * so any field present in the TypeScript type MUST be present in the schema.
+ *
+ * If these tests fail, it means the schema is missing fields that the backend
+ * service returns, which would cause data loss when crossing the IPC boundary.
+ */
+describe("ProviderConfigInfoSchema conformance", () => {
+  it("preserves all AWSCredentialStatus fields", () => {
+    const full: AWSCredentialStatus = {
+      region: "us-east-1",
+      bearerTokenSet: true,
+      accessKeyIdSet: true,
+      secretAccessKeySet: false,
+    };
+
+    const parsed = AWSCredentialStatusSchema.parse(full);
+
+    // Verify no fields were stripped
+    expect(parsed).toEqual(full);
+    expect(Object.keys(parsed).sort()).toEqual(Object.keys(full).sort());
+  });
+
+  it("preserves all ProviderConfigInfo fields (base case)", () => {
+    const full: ProviderConfigInfo = {
+      apiKeySet: true,
+      baseUrl: "https://api.example.com",
+      models: ["model-a", "model-b"],
+    };
+
+    const parsed = ProviderConfigInfoSchema.parse(full);
+
+    expect(parsed).toEqual(full);
+    expect(Object.keys(parsed).sort()).toEqual(Object.keys(full).sort());
+  });
+
+  it("preserves all ProviderConfigInfo fields (with AWS/Bedrock)", () => {
+    const full: ProviderConfigInfo = {
+      apiKeySet: false,
+      baseUrl: undefined,
+      models: [],
+      aws: {
+        region: "eu-west-1",
+        bearerTokenSet: false,
+        accessKeyIdSet: true,
+        secretAccessKeySet: true,
+      },
+    };
+
+    const parsed = ProviderConfigInfoSchema.parse(full);
+
+    expect(parsed).toEqual(full);
+    // Check nested aws object is preserved
+    expect(parsed.aws).toEqual(full.aws);
+  });
+
+  it("preserves all ProviderConfigInfo fields (with couponCodeSet)", () => {
+    const full: ProviderConfigInfo = {
+      apiKeySet: true,
+      couponCodeSet: true,
+    };
+
+    const parsed = ProviderConfigInfoSchema.parse(full);
+
+    expect(parsed).toEqual(full);
+    expect(parsed.couponCodeSet).toBe(true);
+  });
+
+  it("preserves all ProviderConfigInfo fields (full object with all optional fields)", () => {
+    // This is the most comprehensive test - includes ALL possible fields
+    const full: ProviderConfigInfo = {
+      apiKeySet: true,
+      baseUrl: "https://custom.endpoint.com",
+      models: ["claude-3-opus", "claude-3-sonnet"],
+      aws: {
+        region: "ap-northeast-1",
+        bearerTokenSet: true,
+        accessKeyIdSet: true,
+        secretAccessKeySet: true,
+      },
+      couponCodeSet: true,
+    };
+
+    const parsed = ProviderConfigInfoSchema.parse(full);
+
+    // Deep equality check
+    expect(parsed).toEqual(full);
+
+    // Explicit field-by-field verification for clarity
+    expect(parsed.apiKeySet).toBe(full.apiKeySet);
+    expect(parsed.baseUrl).toBe(full.baseUrl);
+    expect(parsed.models).toEqual(full.models);
+    expect(parsed.aws).toEqual(full.aws);
+    expect(parsed.couponCodeSet).toBe(full.couponCodeSet);
+  });
+
+  it("preserves ProvidersConfigMap with multiple providers", () => {
+    const full: ProvidersConfigMap = {
+      anthropic: {
+        apiKeySet: true,
+        models: ["claude-3-opus"],
+      },
+      bedrock: {
+        apiKeySet: false,
+        aws: {
+          region: "us-west-2",
+          bearerTokenSet: false,
+          accessKeyIdSet: true,
+          secretAccessKeySet: true,
+        },
+      },
+      "mux-gateway": {
+        apiKeySet: false,
+        couponCodeSet: true,
+        models: ["anthropic/claude-sonnet-4-5"],
+      },
+    };
+
+    const parsed = ProvidersConfigMapSchema.parse(full);
+
+    expect(parsed).toEqual(full);
+    expect(Object.keys(parsed)).toEqual(Object.keys(full));
+  });
+});

src/common/orpc/types.ts

@@ -16,6 +16,11 @@ import type {
 
 export type BranchListResult = z.infer<typeof schemas.BranchListResultSchema>;
 export type SendMessageOptions = z.infer<typeof schemas.SendMessageOptionsSchema>;
+
+// Provider types (single source of truth - derived from schemas)
+export type AWSCredentialStatus = z.infer<typeof schemas.AWSCredentialStatusSchema>;
+export type ProviderConfigInfo = z.infer<typeof schemas.ProviderConfigInfoSchema>;
+export type ProvidersConfigMap = z.infer<typeof schemas.ProvidersConfigMapSchema>;
 export type ImagePart = z.infer<typeof schemas.ImagePartSchema>;
 export type WorkspaceChatMessage = z.infer<typeof schemas.WorkspaceChatMessageSchema>;
 export type CaughtUpMessage = z.infer<typeof schemas.CaughtUpMessageSchema>;

src/node/services/providerService.ts

@@ -2,26 +2,14 @@ import { EventEmitter } from "events";
 import type { Config } from "@/node/config";
 import { SUPPORTED_PROVIDERS } from "@/common/constants/providers";
 import type { Result } from "@/common/types/result";
-
-/** AWS credential status for Bedrock provider */
-export interface AWSCredentialStatus {
-  region?: string;
-  bearerTokenSet: boolean;
-  accessKeyIdSet: boolean;
-  secretAccessKeySet: boolean;
-}
-
-export interface ProviderConfigInfo {
-  apiKeySet: boolean;
-  baseUrl?: string;
-  models?: string[];
-  /** AWS-specific fields (only present for bedrock provider) */
-  aws?: AWSCredentialStatus;
-  /** Mux Gateway-specific fields */
-  couponCodeSet?: boolean;
-}
-
-export type ProvidersConfigMap = Record<string, ProviderConfigInfo>;
+import type {
+  AWSCredentialStatus,
+  ProviderConfigInfo,
+  ProvidersConfigMap,
+} from "@/common/orpc/types";
+
+// Re-export types for backward compatibility
+export type { AWSCredentialStatus, ProviderConfigInfo, ProvidersConfigMap };
 
 export class ProviderService {
   private readonly emitter = new EventEmitter();