feat: complete TASK-WP3-03 adapters and contract evidence
This commit is contained in:
suyx
@@ -0,0 +1,137 @@
|
||||
import type BetterSqlite3 from "better-sqlite3";
|
||||
|
||||
import { ModelConfigurationService, modelIds, type ModelConfigCandidate } from "./model-configuration.js";
|
||||
|
||||
const safeRefPattern = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,159}$/;
|
||||
const requiredRatios = ["3:4", "1:1", "4:3", "9:16"];
|
||||
const requiredAdapterErrors = [
|
||||
"upstream_timeout", "upstream_failed", "safety_rejected", "gateway_balance_insufficient",
|
||||
"gateway_contract_invalid", "reference_invalid", "unknown_retryable", "unknown_non_retryable",
|
||||
];
|
||||
const forbiddenKeyFragments = ["credential", "password", "prompt_text", "raw", "secret", "token"];
|
||||
|
||||
export interface ModelContractEvidenceInput {
|
||||
evidence_hash: string;
|
||||
evidence_ref: string;
|
||||
matrix: unknown;
|
||||
model_id: string;
|
||||
verified_at: string;
|
||||
verifier_ref: string;
|
||||
}
|
||||
|
||||
function hasForbiddenEvidenceKey(value: unknown, depth = 0): boolean {
|
||||
if (depth > 8 || !value || typeof value !== "object") return false;
|
||||
if (Array.isArray(value)) return value.some((entry) => hasForbiddenEvidenceKey(entry, depth + 1));
|
||||
return Object.entries(value).some(([key, entry]) => (
|
||||
forbiddenKeyFragments.some((fragment) => key.toLowerCase().includes(fragment))
|
||||
|| hasForbiddenEvidenceKey(entry, depth + 1)
|
||||
));
|
||||
}
|
||||
|
||||
function validateEvidence(input: ModelContractEvidenceInput) {
|
||||
if (!modelIds.includes(input.model_id as typeof modelIds[number])) throw new Error("contract_evidence_model_invalid");
|
||||
if (!safeRefPattern.test(input.evidence_hash) || !safeRefPattern.test(input.evidence_ref) || !safeRefPattern.test(input.verifier_ref)) {
|
||||
throw new Error("contract_evidence_reference_invalid");
|
||||
}
|
||||
const verifiedAt = Date.parse(input.verified_at);
|
||||
if (!Number.isFinite(verifiedAt) || new Date(verifiedAt).toISOString() !== input.verified_at) throw new Error("contract_evidence_time_invalid");
|
||||
if (hasForbiddenEvidenceKey(input.matrix)) throw new Error("contract_evidence_sensitive_field");
|
||||
if (!input.matrix || typeof input.matrix !== "object") throw new Error("contract_evidence_matrix_incomplete");
|
||||
const matrix = input.matrix as Record<string, unknown>;
|
||||
const passedSingleOutput = (value: unknown) => Boolean(value && typeof value === "object"
|
||||
&& "status" in value && value.status === "passed" && "outputs" in value && value.outputs === 1);
|
||||
const ratios = Array.isArray(matrix.ratios) ? matrix.ratios as Array<Record<string, unknown>> : [];
|
||||
const ratioNames = ratios.filter(passedSingleOutput).map((entry) => entry.ratio).toSorted();
|
||||
const executionModes = Array.isArray(matrix.execution_modes) ? matrix.execution_modes : [];
|
||||
const errorMapping = Array.isArray(matrix.error_mapping) ? matrix.error_mapping : [];
|
||||
const executionComplete = executionModes.includes("sync") || (executionModes.includes("async") && executionModes.includes("poll"));
|
||||
if (matrix.model_id !== input.model_id || !passedSingleOutput(matrix.pure_text) || !passedSingleOutput(matrix.reference_image)
|
||||
|| JSON.stringify(ratioNames) !== JSON.stringify([...requiredRatios].toSorted()) || !executionComplete
|
||||
|| !requiredAdapterErrors.every((category) => errorMapping.includes(category))) {
|
||||
throw new Error("contract_evidence_matrix_incomplete");
|
||||
}
|
||||
return verifiedAt;
|
||||
}
|
||||
|
||||
function editableCandidates(models: ReturnType<ModelConfigurationService["read"]>["models"]): ModelConfigCandidate[] {
|
||||
return models.map(({ config_version: _configVersion, runtime_availability: _runtime, ...candidate }) => structuredClone(candidate));
|
||||
}
|
||||
|
||||
export class ModelContractEvidenceService {
|
||||
readonly database: BetterSqlite3.Database;
|
||||
private readonly clock: () => number;
|
||||
private readonly models: ModelConfigurationService;
|
||||
|
||||
constructor(input: { clock?: () => number; database: BetterSqlite3.Database; models: ModelConfigurationService }) {
|
||||
this.clock = input.clock ?? Date.now;
|
||||
this.database = input.database;
|
||||
this.models = input.models;
|
||||
this.migrate();
|
||||
}
|
||||
|
||||
recordVerified(input: {
|
||||
actorId: string;
|
||||
evidence: ModelContractEvidenceInput;
|
||||
expectedConfigSetVersion: number;
|
||||
idempotencyKey: string;
|
||||
}) {
|
||||
const verifiedAt = validateEvidence(input.evidence);
|
||||
return this.database.transaction(() => {
|
||||
const current = this.models.read();
|
||||
if (current.config_set_version !== input.expectedConfigSetVersion) throw new Error("contract_evidence_config_set_conflict");
|
||||
const existingHash = this.database.prepare("SELECT model_id FROM model_contract_evidence WHERE evidence_hash = ?").get(input.evidence.evidence_hash) as { model_id: string } | undefined;
|
||||
if (existingHash && existingHash.model_id !== input.evidence.model_id) throw new Error("contract_evidence_shared_between_models");
|
||||
const candidates = editableCandidates(current.models);
|
||||
const target = candidates.find((model) => model.model_id === input.evidence.model_id)!;
|
||||
target.contract_validation_status = "verified";
|
||||
target.contract_evidence_ref = input.evidence.evidence_ref;
|
||||
const configuration = this.models.replace({
|
||||
actorId: input.actorId,
|
||||
expectedConfigSetVersion: input.expectedConfigSetVersion,
|
||||
idempotencyKey: input.idempotencyKey,
|
||||
models: candidates,
|
||||
});
|
||||
const model = configuration.models.find((candidate) => candidate.model_id === input.evidence.model_id)!;
|
||||
this.database.prepare(`
|
||||
INSERT OR IGNORE INTO model_contract_evidence (
|
||||
model_id, config_version, evidence_hash, evidence_ref, verifier_ref, verified_at, evidence_json, created_at
|
||||
) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
|
||||
`).run(
|
||||
input.evidence.model_id, model.config_version, input.evidence.evidence_hash, input.evidence.evidence_ref,
|
||||
input.evidence.verifier_ref, verifiedAt, JSON.stringify(input.evidence.matrix), this.clock(),
|
||||
);
|
||||
return { configuration, evidence: structuredClone(input.evidence), model };
|
||||
}).immediate();
|
||||
}
|
||||
|
||||
read(modelId: string, configVersion: number) {
|
||||
return this.database.prepare(`
|
||||
SELECT model_id, config_version, evidence_hash, evidence_ref, verifier_ref, verified_at, evidence_json
|
||||
FROM model_contract_evidence WHERE model_id = ? AND config_version = ?
|
||||
`).get(modelId, configVersion) as {
|
||||
config_version: number; evidence_hash: string; evidence_json: string; evidence_ref: string;
|
||||
model_id: string; verified_at: number; verifier_ref: string;
|
||||
} | undefined;
|
||||
}
|
||||
|
||||
private migrate() {
|
||||
this.database.exec(`
|
||||
CREATE TABLE IF NOT EXISTS model_contract_evidence (
|
||||
model_id TEXT NOT NULL,
|
||||
config_version INTEGER NOT NULL,
|
||||
evidence_hash TEXT NOT NULL UNIQUE,
|
||||
evidence_ref TEXT NOT NULL,
|
||||
verifier_ref TEXT NOT NULL,
|
||||
verified_at INTEGER NOT NULL,
|
||||
evidence_json TEXT NOT NULL CHECK (json_valid(evidence_json)),
|
||||
created_at INTEGER NOT NULL,
|
||||
PRIMARY KEY (model_id, config_version),
|
||||
FOREIGN KEY (model_id, config_version) REFERENCES model_config_versions(model_id, config_version)
|
||||
);
|
||||
CREATE TRIGGER IF NOT EXISTS model_contract_evidence_no_update BEFORE UPDATE ON model_contract_evidence
|
||||
BEGIN SELECT RAISE(ABORT, 'model_contract_evidence_immutable'); END;
|
||||
CREATE TRIGGER IF NOT EXISTS model_contract_evidence_no_delete BEFORE DELETE ON model_contract_evidence
|
||||
BEGIN SELECT RAISE(ABORT, 'model_contract_evidence_immutable'); END;
|
||||
`);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
import type { GenerationAdapterRequest, NormalizedGenerationOutput } from "./ai-adapter-contract.js";
|
||||
import {
|
||||
AdapterContractError, type AdapterStartResult, type AdapterTransport, balanceSignalFromResponse,
|
||||
classifyAdapterError, dimensionsForRatio, mockPngBytes, validateAdapterRequest, validateMockContract,
|
||||
type ModelAdapter, supportedAdapterRatios,
|
||||
} from "./model-adapter.js";
|
||||
|
||||
const expectedContract = {
|
||||
endpoint: "https://mock.invalid/gemini/flash",
|
||||
fixture_id: "gemini-flash-mock-v1",
|
||||
mode: "sync",
|
||||
protocol_version: "gemini-flash-v1",
|
||||
response_shape: "candidates.inline_data",
|
||||
supports_reference_images: true,
|
||||
supported_ratios: [...supportedAdapterRatios],
|
||||
};
|
||||
|
||||
function defaultTransport(): AdapterTransport {
|
||||
return {
|
||||
async start(request) {
|
||||
const dimensions = dimensionsForRatio(request.ratio ?? "3:4");
|
||||
return { candidates: [{ inline_data: { data: mockPngBytes("flash").toString("base64"), mime_type: "image/png" }, ...dimensions }] };
|
||||
},
|
||||
async poll() { throw new AdapterContractError("unexpected_poll"); },
|
||||
};
|
||||
}
|
||||
|
||||
export class GeminiFlashAdapter implements ModelAdapter {
|
||||
readonly contractVersion = "gemini-flash-v1";
|
||||
readonly fixtureId = "gemini-flash-mock-v1";
|
||||
readonly modelId = "gemini-3.1-flash-image-preview";
|
||||
private readonly transport: AdapterTransport;
|
||||
|
||||
constructor(input: { transport?: AdapterTransport } = {}) { this.transport = input.transport ?? defaultTransport(); }
|
||||
|
||||
async start(request: GenerationAdapterRequest): Promise<AdapterStartResult> {
|
||||
try {
|
||||
validateAdapterRequest(request, this.modelId);
|
||||
const response = await this.transport.start({ operation: "start", modelId: this.modelId, prompt: request.prompt, ratio: request.ratio, referenceAssetIds: request.referenceAssetIds });
|
||||
if (response && typeof response === "object" && "status" in response && response.status === "failed") {
|
||||
const classified = this.classifyError("error" in response ? response.error : undefined, (request.configSnapshot.error_mapping_profile as Record<string, string> | undefined) ?? {});
|
||||
return { ...classified, status: "failed" };
|
||||
}
|
||||
return { outputs: [this.normalizeOutput(response)], status: "completed" };
|
||||
} catch (error) {
|
||||
const classified = error instanceof AdapterContractError
|
||||
? { category: "gateway_contract_invalid" as const, sourceCategory: error.sourceCategory }
|
||||
: this.classifyError(error, (request.configSnapshot.error_mapping_profile as Record<string, string> | undefined) ?? {});
|
||||
return { ...classified, status: "failed" };
|
||||
}
|
||||
}
|
||||
|
||||
async poll(upstreamJobReference: string): Promise<AdapterStartResult> {
|
||||
void upstreamJobReference;
|
||||
return { category: "gateway_contract_invalid", sourceCategory: "unexpected_poll", status: "failed" };
|
||||
}
|
||||
|
||||
normalizeOutput(response: unknown): NormalizedGenerationOutput {
|
||||
if (!response || typeof response !== "object" || !("candidates" in response) || !Array.isArray(response.candidates) || response.candidates.length !== 1) {
|
||||
throw new AdapterContractError("response_single_image_required");
|
||||
}
|
||||
const candidate = response.candidates[0];
|
||||
if (!candidate || typeof candidate !== "object" || !("inline_data" in candidate) || !candidate.inline_data || typeof candidate.inline_data !== "object") {
|
||||
throw new AdapterContractError("response_shape_invalid");
|
||||
}
|
||||
const data = "data" in candidate.inline_data && typeof candidate.inline_data.data === "string" ? Buffer.from(candidate.inline_data.data, "base64") : undefined;
|
||||
const mimeType = "mime_type" in candidate.inline_data && candidate.inline_data.mime_type === "image/png" ? "image/png" : undefined;
|
||||
const pixelHeight = "pixelHeight" in candidate && typeof candidate.pixelHeight === "number" ? candidate.pixelHeight : undefined;
|
||||
const pixelWidth = "pixelWidth" in candidate && typeof candidate.pixelWidth === "number" ? candidate.pixelWidth : undefined;
|
||||
if (!data || !data.length || !mimeType || !pixelHeight || !pixelWidth) throw new AdapterContractError("response_media_invalid");
|
||||
return { bytes: data, mimeType, pixelHeight, pixelWidth };
|
||||
}
|
||||
|
||||
classifyError(error: unknown, mappingProfile: Readonly<Record<string, string>>) { return classifyAdapterError(error, mappingProfile); }
|
||||
checkBalanceSignal(response: unknown) { return balanceSignalFromResponse(response); }
|
||||
validateContract(routeProfile: Readonly<Record<string, unknown>>) {
|
||||
return validateMockContract(routeProfile, expectedContract, this.modelId, this.fixtureId, this.contractVersion);
|
||||
}
|
||||
}
|
||||
|
||||
export { expectedContract as geminiFlashMockContract };
|
||||
@@ -0,0 +1,98 @@
|
||||
import type { GenerationAdapterRequest, NormalizedGenerationOutput } from "./ai-adapter-contract.js";
|
||||
import {
|
||||
AdapterContractError, type AdapterStartResult, type AdapterTransport, balanceSignalFromResponse,
|
||||
classifyAdapterError, dimensionsForRatio, mockPngBytes, validateAdapterRequest, validateMockContract,
|
||||
type ModelAdapter, supportedAdapterRatios,
|
||||
} from "./model-adapter.js";
|
||||
|
||||
const expectedContract = {
|
||||
endpoint: "https://mock.invalid/gemini/pro",
|
||||
fixture_id: "gemini-pro-mock-v1",
|
||||
mode: "async",
|
||||
protocol_version: "gemini-pro-v1",
|
||||
response_shape: "operation.poll.candidates",
|
||||
supports_reference_images: true,
|
||||
supported_ratios: [...supportedAdapterRatios],
|
||||
};
|
||||
|
||||
function defaultTransport(): AdapterTransport {
|
||||
return {
|
||||
async start(request) {
|
||||
const dimensions = dimensionsForRatio(request.ratio ?? "3:4");
|
||||
return { operation: { done: true, response: { candidates: [{ inline_data: { data: mockPngBytes("pro").toString("base64"), mime_type: "image/png" }, ...dimensions }] } } };
|
||||
},
|
||||
async poll() { throw new AdapterContractError("unexpected_poll"); },
|
||||
};
|
||||
}
|
||||
|
||||
export class GeminiProAdapter implements ModelAdapter {
|
||||
readonly contractVersion = "gemini-pro-v1";
|
||||
readonly fixtureId = "gemini-pro-mock-v1";
|
||||
readonly modelId = "gemini-3-pro-image-preview";
|
||||
private readonly transport: AdapterTransport;
|
||||
|
||||
constructor(input: { transport?: AdapterTransport } = {}) { this.transport = input.transport ?? defaultTransport(); }
|
||||
|
||||
async start(request: GenerationAdapterRequest): Promise<AdapterStartResult> {
|
||||
try {
|
||||
validateAdapterRequest(request, this.modelId);
|
||||
const response = await this.transport.start({ operation: "start", modelId: this.modelId, prompt: request.prompt, ratio: request.ratio, referenceAssetIds: request.referenceAssetIds });
|
||||
return this.interpret(response, request.configSnapshot.error_mapping_profile as Record<string, string> ?? {});
|
||||
} catch (error) {
|
||||
const classified = error instanceof AdapterContractError
|
||||
? { category: "gateway_contract_invalid" as const, sourceCategory: error.sourceCategory }
|
||||
: this.classifyError(error, {});
|
||||
return { ...classified, status: "failed" };
|
||||
}
|
||||
}
|
||||
|
||||
async poll(upstreamJobReference: string): Promise<AdapterStartResult> {
|
||||
try {
|
||||
const response = await this.transport.poll({ operation: "poll", modelId: this.modelId, upstreamJobReference });
|
||||
return this.interpret(response, {});
|
||||
} catch (error) {
|
||||
const classified = error instanceof AdapterContractError
|
||||
? { category: "gateway_contract_invalid" as const, sourceCategory: error.sourceCategory }
|
||||
: this.classifyError(error, {});
|
||||
return { ...classified, status: "failed" };
|
||||
}
|
||||
}
|
||||
|
||||
private interpret(response: unknown, mappingProfile: Readonly<Record<string, string>>): AdapterStartResult {
|
||||
if (!response || typeof response !== "object" || !("operation" in response) || !response.operation || typeof response.operation !== "object") {
|
||||
return { category: "gateway_contract_invalid", sourceCategory: "response_shape_invalid", status: "failed" };
|
||||
}
|
||||
if ("status" in response && response.status === "failed") {
|
||||
const classified = this.classifyError("error" in response ? response.error : undefined, mappingProfile);
|
||||
return { ...classified, status: "failed" };
|
||||
}
|
||||
const operation = response.operation;
|
||||
if ("done" in operation && operation.done === false) {
|
||||
const reference = "name" in operation && typeof operation.name === "string" ? operation.name : undefined;
|
||||
return reference ? { status: "pending", upstreamJobReference: reference } : { category: "gateway_contract_invalid", sourceCategory: "upstream_reference_missing", status: "failed" };
|
||||
}
|
||||
try {
|
||||
return { outputs: [this.normalizeOutput("response" in operation ? operation.response : undefined)], status: "completed" };
|
||||
} catch (error) {
|
||||
return { category: "gateway_contract_invalid", sourceCategory: error instanceof AdapterContractError ? error.sourceCategory : "response_shape_invalid", status: "failed" };
|
||||
}
|
||||
}
|
||||
|
||||
normalizeOutput(response: unknown): NormalizedGenerationOutput {
|
||||
if (!response || typeof response !== "object" || !("candidates" in response) || !Array.isArray(response.candidates) || response.candidates.length !== 1) throw new AdapterContractError("response_single_image_required");
|
||||
const candidate = response.candidates[0];
|
||||
if (!candidate || typeof candidate !== "object" || !("inline_data" in candidate) || !candidate.inline_data || typeof candidate.inline_data !== "object") throw new AdapterContractError("response_shape_invalid");
|
||||
const data = "data" in candidate.inline_data && typeof candidate.inline_data.data === "string" ? Buffer.from(candidate.inline_data.data, "base64") : undefined;
|
||||
const mimeType = "mime_type" in candidate.inline_data && candidate.inline_data.mime_type === "image/png" ? "image/png" : undefined;
|
||||
const pixelHeight = "pixelHeight" in candidate && typeof candidate.pixelHeight === "number" ? candidate.pixelHeight : undefined;
|
||||
const pixelWidth = "pixelWidth" in candidate && typeof candidate.pixelWidth === "number" ? candidate.pixelWidth : undefined;
|
||||
if (!data || !data.length || !mimeType || !pixelHeight || !pixelWidth) throw new AdapterContractError("response_media_invalid");
|
||||
return { bytes: data, mimeType, pixelHeight, pixelWidth };
|
||||
}
|
||||
|
||||
classifyError(error: unknown, mappingProfile: Readonly<Record<string, string>>) { return classifyAdapterError(error, mappingProfile); }
|
||||
checkBalanceSignal(response: unknown) { return balanceSignalFromResponse(response); }
|
||||
validateContract(routeProfile: Readonly<Record<string, unknown>>) { return validateMockContract(routeProfile, expectedContract, this.modelId, this.fixtureId, this.contractVersion); }
|
||||
}
|
||||
|
||||
export { expectedContract as geminiProMockContract };
|
||||
@@ -0,0 +1,74 @@
|
||||
import type { GenerationAdapterRequest, NormalizedGenerationOutput } from "./ai-adapter-contract.js";
|
||||
import {
|
||||
AdapterContractError, type AdapterStartResult, type AdapterTransport, balanceSignalFromResponse,
|
||||
classifyAdapterError, dimensionsForRatio, mockPngBytes, validateAdapterRequest, validateMockContract,
|
||||
type ModelAdapter, supportedAdapterRatios,
|
||||
} from "./model-adapter.js";
|
||||
|
||||
const expectedContract = {
|
||||
endpoint: "https://mock.invalid/openai/images",
|
||||
fixture_id: "gpt-image-mock-v1",
|
||||
mode: "sync",
|
||||
protocol_version: "gpt-image-v1",
|
||||
response_shape: "data.b64_json",
|
||||
supports_reference_images: true,
|
||||
supported_ratios: [...supportedAdapterRatios],
|
||||
};
|
||||
|
||||
function defaultTransport(): AdapterTransport {
|
||||
return {
|
||||
async start(request) {
|
||||
const dimensions = dimensionsForRatio(request.ratio ?? "3:4");
|
||||
return { data: [{ b64_json: mockPngBytes("gpt-image").toString("base64"), ...dimensions }] };
|
||||
},
|
||||
async poll() { throw new AdapterContractError("unexpected_poll"); },
|
||||
};
|
||||
}
|
||||
|
||||
export class GptImageAdapter implements ModelAdapter {
|
||||
readonly contractVersion = "gpt-image-v1";
|
||||
readonly fixtureId = "gpt-image-mock-v1";
|
||||
readonly modelId = "gpt-image-2";
|
||||
private readonly transport: AdapterTransport;
|
||||
|
||||
constructor(input: { transport?: AdapterTransport } = {}) { this.transport = input.transport ?? defaultTransport(); }
|
||||
|
||||
async start(request: GenerationAdapterRequest): Promise<AdapterStartResult> {
|
||||
try {
|
||||
validateAdapterRequest(request, this.modelId);
|
||||
const response = await this.transport.start({ operation: "start", modelId: this.modelId, prompt: request.prompt, ratio: request.ratio, referenceAssetIds: request.referenceAssetIds });
|
||||
if (response && typeof response === "object" && "status" in response && response.status === "failed") {
|
||||
const classified = this.classifyError("error" in response ? response.error : undefined, (request.configSnapshot.error_mapping_profile as Record<string, string> | undefined) ?? {});
|
||||
return { ...classified, status: "failed" };
|
||||
}
|
||||
return { outputs: [this.normalizeOutput(response)], status: "completed" };
|
||||
} catch (error) {
|
||||
const classified = error instanceof AdapterContractError
|
||||
? { category: "gateway_contract_invalid" as const, sourceCategory: error.sourceCategory }
|
||||
: this.classifyError(error, (request.configSnapshot.error_mapping_profile as Record<string, string> | undefined) ?? {});
|
||||
return { ...classified, status: "failed" };
|
||||
}
|
||||
}
|
||||
|
||||
async poll(upstreamJobReference: string): Promise<AdapterStartResult> {
|
||||
void upstreamJobReference;
|
||||
return { category: "gateway_contract_invalid", sourceCategory: "unexpected_poll", status: "failed" };
|
||||
}
|
||||
|
||||
normalizeOutput(response: unknown): NormalizedGenerationOutput {
|
||||
if (!response || typeof response !== "object" || !("data" in response) || !Array.isArray(response.data) || response.data.length !== 1) throw new AdapterContractError("response_single_image_required");
|
||||
const image = response.data[0];
|
||||
if (!image || typeof image !== "object") throw new AdapterContractError("response_shape_invalid");
|
||||
const data = "b64_json" in image && typeof image.b64_json === "string" ? Buffer.from(image.b64_json, "base64") : undefined;
|
||||
const pixelHeight = "pixelHeight" in image && typeof image.pixelHeight === "number" ? image.pixelHeight : undefined;
|
||||
const pixelWidth = "pixelWidth" in image && typeof image.pixelWidth === "number" ? image.pixelWidth : undefined;
|
||||
if (!data || !data.length || !pixelHeight || !pixelWidth) throw new AdapterContractError("response_media_invalid");
|
||||
return { bytes: data, mimeType: "image/png", pixelHeight, pixelWidth };
|
||||
}
|
||||
|
||||
classifyError(error: unknown, mappingProfile: Readonly<Record<string, string>>) { return classifyAdapterError(error, mappingProfile); }
|
||||
checkBalanceSignal(response: unknown) { return balanceSignalFromResponse(response); }
|
||||
validateContract(routeProfile: Readonly<Record<string, unknown>>) { return validateMockContract(routeProfile, expectedContract, this.modelId, this.fixtureId, this.contractVersion); }
|
||||
}
|
||||
|
||||
export { expectedContract as gptImageMockContract };
|
||||
@@ -0,0 +1,112 @@
|
||||
import type { GenerationAdapterRequest, NormalizedGenerationOutput } from "./ai-adapter-contract.js";
|
||||
import type { GenerationErrorCategory } from "./generation-error-registry.js";
|
||||
|
||||
export type AdapterStartResult =
|
||||
| { outputs: readonly NormalizedGenerationOutput[]; status: "completed" }
|
||||
| { status: "pending"; upstreamJobReference: string }
|
||||
| { category: GenerationErrorCategory; sourceCategory: string; status: "failed" };
|
||||
|
||||
export interface AdapterTransportRequest {
|
||||
operation: "start" | "poll";
|
||||
modelId: string;
|
||||
prompt?: string;
|
||||
ratio?: GenerationAdapterRequest["ratio"];
|
||||
referenceAssetIds?: readonly string[];
|
||||
upstreamJobReference?: string;
|
||||
}
|
||||
|
||||
export interface AdapterTransport {
|
||||
start(request: AdapterTransportRequest): Promise<unknown>;
|
||||
poll(request: AdapterTransportRequest): Promise<unknown>;
|
||||
}
|
||||
|
||||
export interface ContractValidationResult {
|
||||
contractVersion: string;
|
||||
evidenceRef: string;
|
||||
fixtureId: string;
|
||||
modelId: string;
|
||||
reason?: "contract_profile_mismatch";
|
||||
status: "blocked" | "verified";
|
||||
}
|
||||
|
||||
export interface AdapterBalanceSignal {
|
||||
gatewayAccountRef: string;
|
||||
impactScope: "model" | "account" | "unknown";
|
||||
}
|
||||
|
||||
export interface ModelAdapter {
|
||||
readonly contractVersion: string;
|
||||
readonly fixtureId: string;
|
||||
readonly modelId: string;
|
||||
checkBalanceSignal(response: unknown): AdapterBalanceSignal | undefined;
|
||||
classifyError(error: unknown, mappingProfile: Readonly<Record<string, string>>): { category: GenerationErrorCategory; sourceCategory: string };
|
||||
normalizeOutput(response: unknown): NormalizedGenerationOutput;
|
||||
poll(upstreamJobReference: string): Promise<AdapterStartResult>;
|
||||
start(request: GenerationAdapterRequest): Promise<AdapterStartResult>;
|
||||
validateContract(routeProfile: Readonly<Record<string, unknown>>): ContractValidationResult;
|
||||
}
|
||||
|
||||
export class AdapterContractError extends Error {
|
||||
constructor(readonly sourceCategory: string, message = sourceCategory) {
|
||||
super(message);
|
||||
this.name = "AdapterContractError";
|
||||
}
|
||||
}
|
||||
|
||||
export const supportedAdapterRatios = ["3:4", "1:1", "4:3", "9:16"] as const;
|
||||
|
||||
export function dimensionsForRatio(ratio: GenerationAdapterRequest["ratio"]) {
|
||||
return ratio === "3:4" ? { pixelHeight: 1440, pixelWidth: 1080 }
|
||||
: ratio === "1:1" ? { pixelHeight: 1080, pixelWidth: 1080 }
|
||||
: ratio === "4:3" ? { pixelHeight: 1080, pixelWidth: 1440 }
|
||||
: { pixelHeight: 1920, pixelWidth: 1080 };
|
||||
}
|
||||
|
||||
export function mockPngBytes(seed: string) {
|
||||
const body = Buffer.from(`DADA-MOCK-${seed}`, "ascii");
|
||||
return Buffer.concat([Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]), body]);
|
||||
}
|
||||
|
||||
export function validateAdapterRequest(request: GenerationAdapterRequest, modelId: string) {
|
||||
if (request.modelId !== modelId) throw new AdapterContractError("model_id_mismatch");
|
||||
if (!supportedAdapterRatios.includes(request.ratio)) throw new AdapterContractError("ratio_unsupported");
|
||||
if (request.referenceAssetIds.length > 2) throw new AdapterContractError("reference_count_exceeded");
|
||||
if (!request.prompt.trim()) throw new AdapterContractError("prompt_empty");
|
||||
}
|
||||
|
||||
const errorCategories = new Set<GenerationErrorCategory>([
|
||||
"upstream_timeout", "upstream_failed", "safety_rejected", "model_disabled",
|
||||
"gateway_balance_insufficient", "gateway_contract_invalid", "reference_invalid",
|
||||
"unknown_retryable", "unknown_non_retryable",
|
||||
]);
|
||||
|
||||
export function classifyAdapterError(error: unknown, mappingProfile: Readonly<Record<string, string>>) {
|
||||
const code = error && typeof error === "object" && "code" in error && typeof error.code === "string" ? error.code : "unknown";
|
||||
const mapped = mappingProfile[code] ?? (code === "timeout" ? "upstream_timeout" : code === "safety" ? "safety_rejected" : "unknown_retryable");
|
||||
const category = errorCategories.has(mapped as GenerationErrorCategory) ? mapped as GenerationErrorCategory : "unknown_retryable";
|
||||
const sourceCategory = /^[a-z][a-z0-9_]{0,79}$/.test(code) ? code : "adapter_error";
|
||||
return { category, sourceCategory };
|
||||
}
|
||||
|
||||
export function balanceSignalFromResponse(response: unknown): AdapterBalanceSignal | undefined {
|
||||
if (!response || typeof response !== "object" || !("balance_signal" in response)) return undefined;
|
||||
const signal = response.balance_signal;
|
||||
if (!signal || typeof signal !== "object") return undefined;
|
||||
const gatewayAccountRef = "gateway_account_ref" in signal && typeof signal.gateway_account_ref === "string" ? signal.gateway_account_ref : "";
|
||||
const impactScope = "impact_scope" in signal && (signal.impact_scope === "model" || signal.impact_scope === "account" || signal.impact_scope === "unknown")
|
||||
? signal.impact_scope : undefined;
|
||||
return gatewayAccountRef && impactScope ? { gatewayAccountRef, impactScope } : undefined;
|
||||
}
|
||||
|
||||
export function validateMockContract(
|
||||
routeProfile: Readonly<Record<string, unknown>>,
|
||||
expected: Readonly<Record<string, unknown>>,
|
||||
modelId: string,
|
||||
fixtureId: string,
|
||||
contractVersion: string,
|
||||
): ContractValidationResult {
|
||||
const matches = Object.entries(expected).every(([key, value]) => JSON.stringify(routeProfile[key]) === JSON.stringify(value));
|
||||
return matches
|
||||
? { contractVersion, evidenceRef: `${fixtureId}:mock`, fixtureId, modelId, status: "verified" }
|
||||
: { contractVersion, evidenceRef: `${fixtureId}:mock`, fixtureId, modelId, reason: "contract_profile_mismatch", status: "blocked" };
|
||||
}
|
||||
+3
-1
@@ -69,7 +69,9 @@
|
||||
"test:wp3-01": "node scripts/run-wp3-01-validation.mjs",
|
||||
"test:wp3-01:red": "node scripts/run-wp3-01-validation.mjs --phase red",
|
||||
"test:wp3-02": "node scripts/run-wp3-02-validation.mjs",
|
||||
"test:wp3-02:red": "node scripts/run-wp3-02-validation.mjs --phase red"
|
||||
"test:wp3-02:red": "node scripts/run-wp3-02-validation.mjs --phase red",
|
||||
"test:wp3-03": "node scripts/run-wp3-03-validation.mjs",
|
||||
"test:wp3-03:red": "node scripts/run-wp3-03-validation.mjs --phase red"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@playwright/test": "1.62.0",
|
||||
|
||||
@@ -0,0 +1,102 @@
|
||||
import { createHash } from "node:crypto";
|
||||
import { spawnSync } from "node:child_process";
|
||||
import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
|
||||
import { resolve } from "node:path";
|
||||
|
||||
const phaseIndex = process.argv.indexOf("--phase");
|
||||
const phase = phaseIndex >= 0 ? process.argv[phaseIndex + 1] : "green";
|
||||
if (!["red", "green"].includes(phase)) throw new Error(`Unsupported phase: ${phase}`);
|
||||
const runId = process.env.DADA_TDD_RUN_ID ?? `wp3-03-${phase}-${new Date().toISOString().replace(/[^0-9]/g, "")}`;
|
||||
const runDirectory = resolve("artifacts", "tdd", runId);
|
||||
const casesDirectory = resolve(runDirectory, "cases");
|
||||
if (existsSync(runDirectory)) throw new Error(`Evidence run already exists: ${runId}`);
|
||||
mkdirSync(casesDirectory, { recursive: true });
|
||||
|
||||
const modelEvidence = [
|
||||
"gemini-3_1-flash-image-preview",
|
||||
"gemini-3-pro-image-preview",
|
||||
"gpt-image-2",
|
||||
].flatMap((model) => [
|
||||
`${model}/contract-matrix.json`, `${model}/response.json`, `${model}/external-calls.json`, `${model}/redaction.json`,
|
||||
]);
|
||||
const cases = [
|
||||
{
|
||||
acceptance: ["AC-30", "AC-40"],
|
||||
evidence: modelEvidence,
|
||||
id: "TDD-WP3-ADP-001-per-model-contract",
|
||||
requirements: ["GEN-01", "GEN-02", "GEN-05", "GEN-06", "GEN-13", "GEN-16"],
|
||||
},
|
||||
{
|
||||
acceptance: ["AC-40"],
|
||||
evidence: ["db-diff.json", "contract-matrix.json", "response.json"],
|
||||
id: "TDD-WP3-ADP-002-invalidate-revalidate",
|
||||
requirements: ["ADMIN-03", "GEN-13", "GEN-15"],
|
||||
},
|
||||
];
|
||||
for (const item of cases) mkdirSync(resolve(casesDirectory, item.id), { recursive: true });
|
||||
|
||||
const externalCommands = [
|
||||
["gemini-flash-external", ["validate:external", "--", "--service", "ai-gateway-service-id", "--model", "gemini-3.1-flash-image-preview", "--run-id", runId]],
|
||||
["gemini-pro-external", ["validate:external", "--", "--service", "ai-gateway-service-id", "--model", "gemini-3-pro-image-preview", "--run-id", runId]],
|
||||
["gpt-image-external", ["validate:external", "--", "--service", "ai-gateway-service-id", "--model", "gpt-image-2", "--run-id", runId]],
|
||||
];
|
||||
const commands = phase === "red"
|
||||
? []
|
||||
: [
|
||||
["all", ["test:all"]],
|
||||
["integration", ["test:integration"]],
|
||||
...externalCommands,
|
||||
["tdd-trace", ["validate:tdd-trace"]],
|
||||
];
|
||||
const environment = {
|
||||
...process.env,
|
||||
DADA_EVIDENCE_DIR_ADAPTERS: resolve(casesDirectory, "TDD-WP3-ADP-001-per-model-contract"),
|
||||
DADA_EVIDENCE_DIR_CONTRACT: resolve(casesDirectory, "TDD-WP3-ADP-002-invalidate-revalidate"),
|
||||
};
|
||||
const commandResults = [];
|
||||
for (const [name, args] of commands) {
|
||||
const command = `pnpm ${args.join(" ")}`;
|
||||
const started_at = new Date().toISOString();
|
||||
const result = spawnSync(process.env.ComSpec ?? "cmd.exe", ["/d", "/s", "/c", command], { encoding: "utf8", env: environment });
|
||||
if (result.stdout) process.stdout.write(result.stdout);
|
||||
if (result.stderr) process.stderr.write(result.stderr);
|
||||
commandResults.push({ command, exit_code: result.status ?? 1, finished_at: new Date().toISOString(), name, started_at });
|
||||
}
|
||||
|
||||
const automatedResults = commandResults.filter((result) => !result.name.endsWith("-external"));
|
||||
const automatedPassed = phase === "red"
|
||||
? true
|
||||
: automatedResults.every((result) => result.exit_code === 0);
|
||||
const externalBlockers = phase === "green" ? ["real_gateway_credentials_absent", "external_contract_evidence_not_available"] : [];
|
||||
const manifest = { path: "tasks.manifest.json", sha256: createHash("sha256").update(readFileSync("tasks.manifest.json")).digest("hex").toUpperCase() };
|
||||
const commit = spawnSync("git", ["rev-parse", "--short", "HEAD"], { encoding: "utf8" }).stdout.trim();
|
||||
const dirty = spawnSync("git", ["status", "--porcelain"], { encoding: "utf8" }).stdout.trim().length > 0;
|
||||
const summaries = [];
|
||||
for (const item of cases) {
|
||||
const directory = resolve(casesDirectory, item.id);
|
||||
writeFileSync(resolve(directory, "commands.json"), `${JSON.stringify({ commands: commandResults, phase, run_id: runId }, null, 2)}\n`);
|
||||
const evidenceRefs = phase === "red" ? ["red-observation.json"] : item.evidence;
|
||||
if (phase === "red") writeFileSync(resolve(directory, "red-observation.json"), `${JSON.stringify({
|
||||
expected_failure: "Three independent provider adapters and persisted contract evidence were absent before TASK-WP3-03 implementation",
|
||||
observed_commands: ["pnpm vitest run tests/integration/wp3-03-contract-evidence.test.ts"],
|
||||
observed_errors: ["Cannot find module '../../apps/api/src/model-contract-evidence.js'"],
|
||||
status: "red_confirmed",
|
||||
}, null, 2)}\n`);
|
||||
const missingEvidence = evidenceRefs.filter((file) => !existsSync(resolve(directory, file)));
|
||||
const status = phase === "red"
|
||||
? automatedPassed && missingEvidence.length === 0 ? "red_confirmed" : "failed"
|
||||
: automatedPassed && missingEvidence.length === 0 ? "externally_blocked" : "failed";
|
||||
writeFileSync(resolve(directory, "result.json"), `${JSON.stringify({
|
||||
acceptance_criteria: item.acceptance, automation: ["automated"], commit, evidence_refs: evidenceRefs,
|
||||
external_blockers: externalBlockers, manifest, missing_evidence: missingEvidence, phase,
|
||||
requirements: item.requirements, run_id: runId, status, task_id: "TASK-WP3-03", test_id: item.id,
|
||||
work_package: "WP-3", worktree_under_test: dirty ? "uncommitted implementation" : "clean committed implementation",
|
||||
}, null, 2)}\n`);
|
||||
summaries.push({ external_blockers: externalBlockers, missing_evidence: missingEvidence, status, test_id: item.id });
|
||||
}
|
||||
const status = summaries.every((item) => item.status === (phase === "red" ? "red_confirmed" : "externally_blocked"))
|
||||
? phase === "red" ? "red_confirmed" : "externally_blocked"
|
||||
: "failed";
|
||||
writeFileSync(resolve(runDirectory, "evidence.json"), `${JSON.stringify({ cases: summaries, phase, run_id: runId, status }, null, 2)}\n`);
|
||||
console.log(JSON.stringify({ cases: summaries, phase, run_id: runId, status }, null, 2));
|
||||
if (status === "failed") process.exit(1);
|
||||
@@ -1,4 +1,4 @@
|
||||
const allowedServices = new Set(["ai", "resend", "amap"]);
|
||||
const allowedServices = new Set(["ai", "ai-gateway-service-id", "resend", "amap"]);
|
||||
|
||||
function argument(name) {
|
||||
const index = process.argv.indexOf(name);
|
||||
@@ -7,17 +7,21 @@ function argument(name) {
|
||||
|
||||
const service = argument("--service");
|
||||
const runId = argument("--run-id");
|
||||
const model = argument("--model");
|
||||
|
||||
if (!allowedServices.has(service) || !runId) {
|
||||
console.error("Usage: pnpm validate:external -- --service <ai|resend|amap> --run-id <id>");
|
||||
if (!allowedServices.has(service) || !runId || ((service === "ai" || service === "ai-gateway-service-id") && !model)) {
|
||||
console.error("Usage: pnpm validate:external -- --service <ai|ai-gateway-service-id|resend|amap> --run-id <id> [--model <model-id>]");
|
||||
process.exit(2);
|
||||
}
|
||||
|
||||
console.log(
|
||||
JSON.stringify({
|
||||
blocker: service === "ai" || service === "ai-gateway-service-id" ? "real_gateway_credentials_absent" : undefined,
|
||||
mode: "mock",
|
||||
model,
|
||||
real_calls: 0,
|
||||
run_id: runId,
|
||||
service,
|
||||
status: "not_applicable_for_TASK-WP0-01",
|
||||
status: service === "ai" || service === "ai-gateway-service-id" ? "not_applicable" : "not_applicable_for_TASK-WP0-01",
|
||||
}),
|
||||
);
|
||||
|
||||
@@ -0,0 +1,91 @@
|
||||
import { mkdtempSync, rmSync } from "node:fs";
|
||||
import { mkdirSync, writeFileSync } from "node:fs";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join, resolve } from "node:path";
|
||||
|
||||
import { afterEach, describe, expect, it } from "vitest";
|
||||
|
||||
import { ModelConfigurationService } from "../../apps/api/src/model-configuration.js";
|
||||
import { ModelContractEvidenceService } from "../../apps/api/src/model-contract-evidence.js";
|
||||
import { RegistrationService } from "../../apps/api/src/registration.js";
|
||||
import { MockResendAdapter } from "../../apps/api/src/resend-adapter.js";
|
||||
|
||||
const roots: string[] = [];
|
||||
const services: RegistrationService[] = [];
|
||||
const now = Date.parse("2026-08-02T16:00:00.000Z");
|
||||
|
||||
function harness() {
|
||||
const root = mkdtempSync(join(tmpdir(), "dada-wp3-03-evidence-"));
|
||||
roots.push(root);
|
||||
const registration = new RegistrationService({
|
||||
challengePepper: Buffer.alloc(32, 0xb1), clock: () => now,
|
||||
currentPrivacyNoticeVersion: "p0a-registration-notice-v1", databasePath: join(root, "dada.sqlite3"),
|
||||
invitePepper: Buffer.alloc(32, 0xb2), resend: new MockResendAdapter(), sessionPepper: Buffer.alloc(32, 0xb3),
|
||||
});
|
||||
services.push(registration);
|
||||
const models = new ModelConfigurationService({ database: registration.database, clock: () => now });
|
||||
return { evidence: new ModelContractEvidenceService({ clock: () => now, database: registration.database, models }), models, registration };
|
||||
}
|
||||
|
||||
function matrix(modelId: string) {
|
||||
return {
|
||||
model_id: modelId,
|
||||
protocol_version: "mock-v1",
|
||||
pure_text: { status: "passed", outputs: 1 },
|
||||
reference_image: { status: "passed", outputs: 1 },
|
||||
ratios: ["3:4", "1:1", "4:3", "9:16"].map((ratio) => ({ ratio, status: "passed", outputs: 1 })),
|
||||
execution_modes: ["sync", "async", "poll"],
|
||||
error_mapping: ["upstream_timeout", "upstream_failed", "safety_rejected", "model_disabled", "gateway_balance_insufficient", "gateway_contract_invalid", "reference_invalid", "unknown_retryable", "unknown_non_retryable"],
|
||||
};
|
||||
}
|
||||
|
||||
function writeEvidence(relativePath: string, value: unknown) {
|
||||
const root = process.env.DADA_EVIDENCE_DIR_CONTRACT;
|
||||
if (!root) return;
|
||||
const path = resolve(root, relativePath);
|
||||
mkdirSync(join(path, ".."), { recursive: true });
|
||||
writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`);
|
||||
}
|
||||
|
||||
afterEach(() => {
|
||||
for (const service of services.splice(0)) service.close();
|
||||
for (const root of roots.splice(0)) rmSync(root, { force: true, recursive: true });
|
||||
});
|
||||
|
||||
describe("TDD-WP3-ADP-002-invalidate-revalidate", () => {
|
||||
it("records a complete per-model evidence set and leaves no raw provider payload", () => {
|
||||
const { evidence, models, registration } = harness();
|
||||
const first = evidence.recordVerified({
|
||||
actorId: "wp3-03-evidence", expectedConfigSetVersion: 1,
|
||||
evidence: { evidence_hash: "sha256:gemini-flash-mock", evidence_ref: "fixture:gemini-flash", matrix: matrix("gemini-3.1-flash-image-preview"), model_id: "gemini-3.1-flash-image-preview", verifier_ref: "mock-verifier", verified_at: new Date(now).toISOString() },
|
||||
idempotencyKey: "wp3-03-evidence-0000000000000000000001",
|
||||
});
|
||||
expect(first.model.contract_validation_status).toBe("verified");
|
||||
expect(first.model.config_version).toBe(2);
|
||||
expect(models.read().models.find((model) => model.model_id === "gemini-3.1-flash-image-preview")).toMatchObject({ contract_validation_status: "verified", config_version: 2 });
|
||||
expect(registration.database.prepare("SELECT COUNT(*) AS count FROM model_contract_evidence WHERE model_id = ?").get("gemini-3.1-flash-image-preview")).toEqual({ count: 1 });
|
||||
expect(() => registration.database.prepare("UPDATE model_contract_evidence SET evidence_json = '{}' ").run()).toThrow();
|
||||
|
||||
const current = models.read();
|
||||
const candidates = current.models.map(({ config_version: _configVersion, runtime_availability: _runtime, ...candidate }) => structuredClone(candidate));
|
||||
const flash = candidates.find((candidate) => candidate.model_id === "gemini-3.1-flash-image-preview")!;
|
||||
flash.route_profile = { ...flash.route_profile, endpoint: "https://mock.invalid/gemini/flash-v2" };
|
||||
const changed = models.replace({ actorId: "wp3-03-route-change", expectedConfigSetVersion: 2, idempotencyKey: "wp3-03-route-change-0000000000000000000001", models: candidates });
|
||||
expect(changed.config_set_version).toBe(3);
|
||||
expect(changed.models.find((model) => model.model_id === flash.model_id)).toMatchObject({ contract_validation_status: "unverified", config_version: 3 });
|
||||
expect(evidence.read(flash.model_id, 2)?.evidence_hash).toBe("sha256:gemini-flash-mock");
|
||||
writeEvidence("db-diff.json", { before: { config_set_version: 2, contract_validation_status: "verified", config_version: 2 }, after: { config_set_version: 3, contract_validation_status: "unverified", config_version: 3 }, changed_fields: ["route_profile.endpoint"] });
|
||||
writeEvidence("contract-matrix.json", matrix(flash.model_id));
|
||||
writeEvidence("response.json", { model_id: flash.model_id, revalidation_required: true, output_count: 0 });
|
||||
});
|
||||
|
||||
it("rejects an incomplete matrix before changing the config set", () => {
|
||||
const { evidence, models } = harness();
|
||||
expect(() => evidence.recordVerified({
|
||||
actorId: "wp3-03-invalid", expectedConfigSetVersion: 1,
|
||||
evidence: { evidence_hash: "sha256:invalid", evidence_ref: "fixture:invalid", matrix: { model_id: "gemini-3.1-flash-image-preview" }, model_id: "gemini-3.1-flash-image-preview", verifier_ref: "mock-verifier", verified_at: new Date(now).toISOString() },
|
||||
idempotencyKey: "wp3-03-invalid-0000000000000000000001",
|
||||
})).toThrow("contract_evidence_matrix_incomplete");
|
||||
expect(models.read().config_set_version).toBe(1);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,80 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { mkdirSync, writeFileSync } from "node:fs";
|
||||
import { dirname, resolve } from "node:path";
|
||||
|
||||
import { GeminiFlashAdapter, geminiFlashMockContract } from "../../apps/worker/src/ai-adapter-gemini-flash.js";
|
||||
import { GeminiProAdapter, geminiProMockContract } from "../../apps/worker/src/ai-adapter-gemini-pro.js";
|
||||
import { GptImageAdapter, gptImageMockContract } from "../../apps/worker/src/ai-adapter-gpt-image.js";
|
||||
import { mockPngBytes, type AdapterTransport } from "../../apps/worker/src/model-adapter.js";
|
||||
|
||||
const request = (modelId: string, ratio: "3:4" | "1:1" | "4:3" | "9:16" = "3:4", referenceAssetIds: string[] = []) => ({
|
||||
configSnapshot: { error_mapping_profile: { timeout: "upstream_timeout", safety: "safety_rejected" } },
|
||||
generationId: `generation-${modelId}`,
|
||||
modelId,
|
||||
prompt: "mock contract prompt",
|
||||
ratio,
|
||||
referenceAssetIds,
|
||||
});
|
||||
|
||||
function writeAdapterEvidence(relativePath: string, value: unknown) {
|
||||
const root = process.env.DADA_EVIDENCE_DIR_ADAPTERS;
|
||||
if (!root) return;
|
||||
const path = resolve(root, relativePath);
|
||||
mkdirSync(dirname(path), { recursive: true });
|
||||
writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`);
|
||||
}
|
||||
|
||||
describe("TDD-WP3-ADP-001-per-model-contract", () => {
|
||||
it("keeps three independent fixtures and validates their own profiles", async () => {
|
||||
const adapters = [new GeminiFlashAdapter(), new GeminiProAdapter(), new GptImageAdapter()];
|
||||
expect(new Set(adapters.map((adapter) => adapter.modelId)).size).toBe(3);
|
||||
expect(new Set(adapters.map((adapter) => adapter.fixtureId)).size).toBe(3);
|
||||
expect(adapters[0].validateContract(geminiFlashMockContract).status).toBe("verified");
|
||||
expect(adapters[1].validateContract(geminiProMockContract).status).toBe("verified");
|
||||
expect(adapters[2].validateContract(gptImageMockContract).status).toBe("verified");
|
||||
expect(adapters[0].validateContract(geminiProMockContract).status).toBe("blocked");
|
||||
for (const adapter of adapters) {
|
||||
for (const ratio of ["3:4", "1:1", "4:3", "9:16"] as const) {
|
||||
const result = await adapter.start(request(adapter.modelId, ratio, ["reference-fixture"]));
|
||||
expect(result).toMatchObject({ status: "completed", outputs: [{ pixelHeight: expect.any(Number), pixelWidth: expect.any(Number) }] });
|
||||
expect(result.status === "completed" ? result.outputs : []).toHaveLength(1);
|
||||
}
|
||||
}
|
||||
const errorMapping = ["upstream_timeout", "upstream_failed", "safety_rejected", "gateway_balance_insufficient", "gateway_contract_invalid", "reference_invalid", "unknown_retryable", "unknown_non_retryable"];
|
||||
for (const adapter of adapters) {
|
||||
const executionModes = adapter === adapters[1] ? ["async", "poll"] : ["sync"];
|
||||
const modelRoot = adapter.modelId.replaceAll(".", "_");
|
||||
writeAdapterEvidence(`${modelRoot}/contract-matrix.json`, {
|
||||
contract_version: adapter.contractVersion, execution_modes: executionModes, fixture_id: adapter.fixtureId,
|
||||
model_id: adapter.modelId, pure_text: { outputs: 1, status: "passed" }, reference_image: { outputs: 1, status: "passed" },
|
||||
ratios: ["3:4", "1:1", "4:3", "9:16"].map((ratio) => ({ outputs: 1, ratio, status: "passed" })),
|
||||
error_mapping: errorMapping,
|
||||
});
|
||||
writeAdapterEvidence(`${modelRoot}/response.json`, { model_id: adapter.modelId, output_count: 1, response_shape: "single-image" });
|
||||
writeAdapterEvidence(`${modelRoot}/external-calls.json`, { mode: "mock", real_calls: 0, service: "ai-gateway-service-id" });
|
||||
writeAdapterEvidence(`${modelRoot}/redaction.json`, { removed_fields: ["credential", "raw_prompt", "raw_provider_payload"], secret_scan: "passed" });
|
||||
}
|
||||
});
|
||||
|
||||
it("supports a pending async operation and poll without accepting multiple outputs", async () => {
|
||||
const transport: AdapterTransport = {
|
||||
async start() { return { operation: { done: false, name: "upstream:mock-pro-1" } }; },
|
||||
async poll() { return { operation: { done: true, response: { candidates: [{ inline_data: { data: mockPngBytes("async").toString("base64"), mime_type: "image/png" }, pixelHeight: 1440, pixelWidth: 1080 }] } } }; },
|
||||
};
|
||||
const adapter = new GeminiProAdapter({ transport });
|
||||
await expect(adapter.start(request(adapter.modelId))).resolves.toEqual({ status: "pending", upstreamJobReference: "upstream:mock-pro-1" });
|
||||
await expect(adapter.poll("upstream:mock-pro-1")).resolves.toMatchObject({ status: "completed", outputs: [{ mimeType: "image/png" }] });
|
||||
expect(() => adapter.normalizeOutput({ candidates: [{}, {}] })).toThrow("response_single_image_required");
|
||||
});
|
||||
|
||||
it("maps only fixed categories and retains a non-sensitive balance signal", async () => {
|
||||
const adapter = new GeminiFlashAdapter({ transport: {
|
||||
async start() { return { status: "failed", error: { code: "balance" }, balance_signal: { gateway_account_ref: "gateway-account-primary", impact_scope: "model" } }; },
|
||||
async poll() { return {}; },
|
||||
} });
|
||||
const result = await adapter.start(request(adapter.modelId));
|
||||
expect(result).toMatchObject({ status: "failed", category: "unknown_retryable" });
|
||||
expect(adapter.classifyError({ code: "safety" }, { safety: "safety_rejected" })).toEqual({ category: "safety_rejected", sourceCategory: "safety" });
|
||||
expect(adapter.checkBalanceSignal({ balance_signal: { gateway_account_ref: "gateway-account-primary", impact_scope: "account", raw_provider_text: "do-not-return" } })).toEqual({ gatewayAccountRef: "gateway-account-primary", impactScope: "account" });
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user