fixes

Author: CLowbrow

.github/scripts/provider-type-update-workflow.test.mjs

@@ -60,3 +60,13 @@ test("protects AGENTS.md in planning, implementation, and path policy", () => {
   assert.match(workflow, /Do not edit `plan\.md`, `AGENTS\.md`/);
   assert.match(workflow, /':\(glob\)\*\*\/AGENTS\.md'/);
 });
+
+test("limits transform capture to providers with configured credentials", () => {
+  assert.match(
+    workflow,
+    /capture_providers=\(\).*ANTHROPIC_API_KEY.*AWS_BEARER_TOKEN_BEDROCK.*GOOGLE_API_KEY.*OPENAI_API_KEY/s
+  );
+  assert.match(workflow, /CAPTURE_PROVIDERS="\$capture_provider_list"/);
+  assert.doesNotMatch(workflow, /GOOGLE_APPLICATION_CREDENTIALS:/);
+  assert.doesNotMatch(workflow, /VERTEX_PROJECT:/);
+});

.github/workflows/update-provider-types.yml

@@ -891,7 +891,33 @@ jobs:
           CAPTURE_CASES: ${{ steps.capture_cases.outputs.cases }}
           GOOGLE_API_KEY: ${{ secrets.LINGUA_CAPTURE_GOOGLE_API_KEY }}
           OPENAI_API_KEY: ${{ secrets.LINGUA_CAPTURE_OPENAI_API_KEY }}
-        run: make capture-transforms CASES="$CAPTURE_CASES" FORCE=1
+        run: |
+          set -euo pipefail
+          capture_providers=()
+          if [ -n "${ANTHROPIC_API_KEY:-}" ]; then
+            capture_providers+=(anthropic)
+          fi
+          if [ -n "${AWS_BEARER_TOKEN_BEDROCK:-}" ]; then
+            capture_providers+=(bedrock)
+          fi
+          if [ -n "${GOOGLE_API_KEY:-}" ]; then
+            capture_providers+=(google)
+          fi
+          if [ -n "${OPENAI_API_KEY:-}" ]; then
+            capture_providers+=(chat-completions responses)
+          fi
+
+          if [ "${#capture_providers[@]}" -eq 0 ]; then
+            echo "No transform capture credentials are configured; skipping transform capture."
+            exit 0
+          fi
+
+          capture_provider_list=$(IFS=,; echo "${capture_providers[*]}")
+          echo "Capturing transforms with credentialed providers: $capture_provider_list"
+          make capture-transforms \
+            CASES="$CAPTURE_CASES" \
+            CAPTURE_PROVIDERS="$capture_provider_list" \
+            FORCE=1
 
       - name: Verify payload fixture sync
         id: payload_sync

Makefile

@@ -102,7 +102,7 @@ capture: lingua-wasm ## Capture payloads (snapshots + transforms + vitest snapsh
 	cd payloads && pnpm capture $(if $(FILTER),--filter $(FILTER)) $(if $(CASES),--cases $(CASES)) $(if $(FORCE),--force)
 
 capture-transforms: lingua-wasm ## Re-capture only transforms (e.g. make capture-transforms CASES=streamParam,toolsParam FORCE=1)
-	cd payloads && pnpm tsx scripts/transforms/capture-transforms.ts $(if $(FILTER),$(FILTER)) $(if $(CASES),--cases $(CASES)) $(if $(PAIR),--pair $(PAIR)) $(if $(FORCE),--force)
+	cd payloads && pnpm tsx scripts/transforms/capture-transforms.ts $(if $(FILTER),$(FILTER)) $(if $(CASES),--cases $(CASES)) $(if $(PAIR),--pair $(PAIR)) $(if $(CAPTURE_PROVIDERS),--capture-providers $(CAPTURE_PROVIDERS)) $(if $(FORCE),--force)
 
 update-snapshots: lingua-wasm ## Update vitest snapshots without recapturing
 	cd payloads && pnpm vitest run scripts/transforms -u

payloads/scripts/capture.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, test } from "vitest";
+import { findUnmatchedRequestedCases } from "./capture";
+
+describe("requested capture case validation", () => {
+  test("rejects every requested case omitted by provider selection", () => {
+    expect(
+      findUnmatchedRequestedCases(
+        ["supportedCase", "incompatibleCase", "misspelledCase"],
+        ["supportedCase"]
+      )
+    ).toEqual(["incompatibleCase", "misspelledCase"]);
+  });
+
+  test("accepts requested cases matched by at least one selected provider", () => {
+    expect(
+      findUnmatchedRequestedCases(
+        ["sharedCase", "providerCase"],
+        ["sharedCase", "sharedCase", "providerCase"]
+      )
+    ).toEqual([]);
+  });
+
+  test("does not require explicit cases for unfiltered captures", () => {
+    expect(findUnmatchedRequestedCases(undefined, [])).toEqual([]);
+  });
+});

payloads/scripts/capture.ts

@@ -149,6 +149,20 @@ function getAllCases(options: CaptureOptions): CaseToRun[] {
   return cases;
 }
 
+export function findUnmatchedRequestedCases(
+  requestedCases: string[] | undefined,
+  matchedCaseNames: Iterable<string>
+): string[] {
+  if (!requestedCases) {
+    return [];
+  }
+
+  const matched = new Set(matchedCaseNames);
+  return [...new Set(requestedCases)].filter(
+    (caseName) => !matched.has(caseName)
+  );
+}
+
 async function captureProviderSnapshots(
   cases: CaseToRun[],
   options: CaptureOptions
@@ -269,9 +283,13 @@ async function main() {
     }
     return;
   }
-  if (options.cases && allCases.length === 0) {
+  const unmatchedRequestedCases = findUnmatchedRequestedCases(
+    options.cases,
+    allCases.map((case_) => case_.caseName)
+  );
+  if (unmatchedRequestedCases.length > 0) {
     throw new Error(
-      `None of the requested cases matched the selected providers: ${options.cases.join(",")}`
+      `Requested cases did not match the selected providers: ${unmatchedRequestedCases.join(",")}`
     );
   }
 

payloads/scripts/transforms/capture-transforms.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "vitest";
 import {
+  isCaptureProviderSelected,
   parseCaptureTransformArgs,
   selectRequestedCases,
 } from "./capture-transforms";
@@ -11,6 +12,7 @@ describe("capture transform arguments", () => {
       force: true,
       pair: undefined,
       cases: undefined,
+      captureProviders: undefined,
     });
   });
 
@@ -27,6 +29,7 @@ describe("capture transform arguments", () => {
       force: true,
       pair: { source: "anthropic", target: "responses" },
       cases: undefined,
+      captureProviders: undefined,
     });
   });
 
@@ -42,8 +45,55 @@ describe("capture transform arguments", () => {
       force: true,
       pair: undefined,
       cases: ["streamParam", "streamOptionsParam"],
+      captureProviders: undefined,
     });
   });
+
+  test("parses credentialed capture providers without treating them as a filter", () => {
+    expect(
+      parseCaptureTransformArgs([
+        "--capture-providers",
+        "anthropic,chat-completions,responses,google",
+        "--cases",
+        "streamParam",
+        "--force",
+      ])
+    ).toEqual({
+      filter: undefined,
+      force: true,
+      pair: undefined,
+      cases: ["streamParam"],
+      captureProviders: [
+        "anthropic",
+        "chat-completions",
+        "responses",
+        "google",
+      ],
+    });
+  });
+});
+
+describe("capture provider selection", () => {
+  test("keeps pairs whose actual capture provider is credentialed", () => {
+    expect(
+      isCaptureProviderSelected({ target: "anthropic" }, [
+        "anthropic",
+        "google",
+      ])
+    ).toBe(true);
+    expect(
+      isCaptureProviderSelected(
+        { target: "anthropic", captureProvider: "baseten" },
+        ["anthropic", "google"]
+      )
+    ).toBe(false);
+  });
+
+  test("keeps every pair when no credential filter is provided", () => {
+    expect(isCaptureProviderSelected({ target: "vertex-anthropic" })).toBe(
+      true
+    );
+  });
 });
 
 describe("capture transform case selection", () => {

payloads/scripts/transforms/capture-transforms.ts

@@ -21,6 +21,7 @@ import {
   getResponsePath,
   getStreamingResponsePath,
   type SourceFormat,
+  type TransformPair,
 } from "./helpers";
 
 const GOOGLE_API_BASE = "https://generativelanguage.googleapis.com/v1beta";
@@ -218,7 +219,8 @@ export async function captureTransforms(
   filter?: string,
   force?: boolean,
   requestedPair?: { source: string; target: string },
-  requestedCases?: string[]
+  requestedCases?: string[],
+  requestedCaptureProviders?: string[]
 ): Promise<{ captured: number; skipped: number; failed: number }> {
   mkdirSync(TRANSFORMS_DIR, { recursive: true });
 
@@ -229,6 +231,9 @@ export async function captureTransforms(
   const nonStreamingTasks: (() => Promise<void>)[] = [];
 
   for (const p of TRANSFORM_PAIRS) {
+    if (!isCaptureProviderSelected(p, requestedCaptureProviders)) {
+      continue;
+    }
     if (
       requestedPair &&
       (p.source !== requestedPair.source || p.target !== requestedPair.target)
@@ -293,6 +298,9 @@ export async function captureTransforms(
   const streamingTasks: (() => Promise<void>)[] = [];
 
   for (const streamingPair of STREAMING_PAIRS) {
+    if (!isCaptureProviderSelected(streamingPair, requestedCaptureProviders)) {
+      continue;
+    }
     if (
       requestedPair &&
       (streamingPair.source !== requestedPair.source ||
@@ -391,6 +399,18 @@ export async function captureTransforms(
   return { captured, skipped, failed };
 }
 
+export function isCaptureProviderSelected(
+  pair: Pick<TransformPair, "target" | "captureProvider">,
+  requestedCaptureProviders?: string[]
+): boolean {
+  if (!requestedCaptureProviders) {
+    return true;
+  }
+
+  const captureProvider = pair.captureProvider ?? pair.target;
+  return requestedCaptureProviders.includes(captureProvider);
+}
+
 export function selectRequestedCases(
   caseNames: string[],
   requestedCases?: string[]
@@ -408,6 +428,7 @@ export function parseCaptureTransformArgs(args: string[]): {
   force: boolean;
   pair: { source: string; target: string } | undefined;
   cases: string[] | undefined;
+  captureProviders: string[] | undefined;
 } {
   const force = args.includes("--force");
   const pairIdx = args.indexOf("--pair");
@@ -420,22 +441,34 @@ export function parseCaptureTransformArgs(args: string[]): {
   const cases = casesArg
     ? casesArg.split(",").filter((caseName) => caseName.length > 0)
     : undefined;
+  const captureProvidersIdx = args.indexOf("--capture-providers");
+  const captureProvidersArg =
+    captureProvidersIdx !== -1 ? args[captureProvidersIdx + 1] : undefined;
+  const captureProviders = captureProvidersArg
+    ? captureProvidersArg.split(",").filter((provider) => provider.length > 0)
+    : undefined;
   const filter = args.find(
     (arg, index) =>
       !arg.startsWith("--") &&
       (pairIdx === -1 || index !== pairIdx + 1) &&
-      (casesIdx === -1 || index !== casesIdx + 1)
+      (casesIdx === -1 || index !== casesIdx + 1) &&
+      (captureProvidersIdx === -1 || index !== captureProvidersIdx + 1)
   );
 
-  return { filter, force, pair, cases };
+  return { filter, force, pair, cases, captureProviders };
 }
 
 async function main() {
-  const { filter, force, pair, cases } = parseCaptureTransformArgs(
-    process.argv.slice(2)
+  const { filter, force, pair, cases, captureProviders } =
+    parseCaptureTransformArgs(process.argv.slice(2));
+
+  const { failed } = await captureTransforms(
+    filter,
+    force,
+    pair,
+    cases,
+    captureProviders
   );
-
-  const { failed } = await captureTransforms(filter, force, pair, cases);
   process.exit(failed > 0 ? 1 : 0);
 }