@proofhound/core 0.1.6

package/dist/server/modules/model/model.service.js

@@ -0,0 +1,643 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelService = void 0;
+const node_buffer_1 = require("node:buffer");
+const node_crypto_1 = require("node:crypto");
+const common_1 = require("@nestjs/common");
+const limiter_1 = require("@proofhound/limiter");
+const llm_client_1 = require("@proofhound/llm-client");
+const logger_1 = require("@proofhound/logger");
+const shared_1 = require("@proofhound/shared");
+const access_control_1 = require("../../common/access-control");
+const access_control_service_1 = require("../../common/contracts/access-control.service");
+const limiter_key_strategy_1 = require("../../common/contracts/limiter-key.strategy");
+const quota_policy_hook_1 = require("../../common/contracts/quota-policy.hook");
+const runtime_limits_provider_1 = require("../../common/contracts/runtime-limits.provider");
+const workflow_authorization_hook_1 = require("../../common/contracts/workflow-authorization.hook");
+const db_error_1 = require("../../common/errors/db-error");
+const crypto_service_1 = require("../../../shared/crypto/crypto.service");
+const redis_constants_1 = require("../../../shared/redis/redis.constants");
+const runtime_limits_1 = require("../../../shared/llm/runtime-limits");
+const model_repository_1 = require("./model.repository");
+const MODEL_USAGE_SNAPSHOT_TIMEOUT_MS = 1_000;
+let ModelService = class ModelService {
+    constructor(repo, crypto, limiter, accessControl, limiterKeyStrategy, runtimeLimitsProvider, workflowAuth, quotaPolicy) {
+        this.repo = repo;
+        this.crypto = crypto;
+        this.limiter = limiter;
+        this.accessControl = accessControl;
+        this.limiterKeyStrategy = limiterKeyStrategy;
+        this.runtimeLimitsProvider = runtimeLimitsProvider;
+        this.workflowAuth = workflowAuth;
+        this.quotaPolicy = quotaPolicy;
+        this.logger = (0, logger_1.createLogger)('model.service', { service: 'server' });
+    }
+    // -------------------------------------------------------------------------
+    // Local in-process model
+    // -------------------------------------------------------------------------
+    // orgId on the project-scoped read methods (SaaS-only; undefined in OSS) is sourced from the resolved
+    // ProjectContext — the project's org is the rate-limit bucket (SPEC 08 §3.7). It is threaded into
+    // toProjectModelListItem → fetchUsageSnapshot so the usage-snapshot READ key matches the worker's WRITE
+    // key under a SaaS strategy; OSS leaves it undefined so the key stays `model:<id>`.
+    async listProjectModels(projectId, actor, orgId) {
+        await this.getAccessibleProject(projectId, actor);
+        const rows = await this.repo.listProjectModels(projectId);
+        const data = await Promise.all(rows.map((row) => this.toProjectModelListItem(row, orgId)));
+        return { data, total: data.length };
+    }
+    // Quick-start option listing is not project-scoped (no @CurrentProject at the endpoint), so no org is
+    // threaded — usage is read with undefined org (key stays project/model-scoped). OSS-identical.
+    async listQuickStartModelOptions(_actor) {
+        const rows = await this.repo.listQuickStartGlobalModels();
+        const data = await Promise.all(rows.map((row) => this.toProjectModelListItem(row)));
+        return { data, total: data.length };
+    }
+    async getQuickStartModelOption(modelId, _actor) {
+        const row = await this.repo.findModelById(modelId);
+        if (!row) {
+            throw new common_1.NotFoundException(`Model ${modelId} not found`);
+        }
+        return this.toProjectModelListItem(row);
+    }
+    async getProjectModelDetail(projectId, modelId, actor, orgId) {
+        await this.getAccessibleProject(projectId, actor);
+        const row = await this.repo.findModelAccessibleToProject(projectId, modelId);
+        if (!row)
+            throw new common_1.NotFoundException(`Model ${modelId} not found`);
+        return this.toProjectModelListItem(row, orgId);
+    }
+    // For sibling services that have already done project access checks (such as ExperimentService) to query model visibility directly,
+    // without re-running actor authorization; if authorization is needed, go through getProjectModelDetail
+    async findModelAccessibleToProject(projectId, modelId) {
+        return this.repo.findModelAccessibleToProject(projectId, modelId);
+    }
+    async createProjectModel(projectId, dto, actor, source = 'api', orgId) {
+        void source;
+        await this.getWritableProject(projectId, actor);
+        const modelId = (0, node_crypto_1.randomUUID)();
+        const insert = this.buildInsertRow(projectId, modelId, dto, actor.sub);
+        const created = await this.createModelOrThrowNameConflict(insert);
+        return this.getProjectModelDetail(projectId, created.id, actor, orgId);
+    }
+    async probeDraftProjectModel(projectId, dto, actor, source = 'api', orgId) {
+        void source;
+        await this.getWritableProject(projectId, actor);
+        await this.assertProbeWorkflowStart({ projectId, orgId, source: 'local' }, actor);
+        const modelId = (0, node_crypto_1.randomUUID)();
+        const model = {
+            id: modelId,
+            providerType: dto.providerType.trim(),
+            providerModelId: dto.providerModelId.trim(),
+            endpoint: dto.endpoint.trim(),
+            apiKey: dto.apiKey,
+            capabilities: dto.capabilities,
+            rpmLimit: dto.rpm.limit,
+            tpmLimit: dto.tpm.limit,
+            concurrencyLimit: dto.concurrency.limit,
+            autoConcurrency: dto.autoConcurrency,
+            inputTokenPricePerMillion: String(dto.pricing.inputPerMillion),
+            outputTokenPricePerMillion: String(dto.pricing.outputPerMillion),
+            extraBody: dto.extraBody ?? {},
+        };
+        const result = await this.runConnectivityProbe(
+        // orgId (SaaS-only; undefined in OSS) sourced from the resolved ProjectContext — the project's org
+        // is the rate-limit bucket (SPEC 08 §3.7), not the actor's org.
+        { projectId, orgId, source: 'local' }, model, `probe-draft-${modelId}`);
+        const probedAt = new Date(result.checkedAt);
+        const probeError = result.ok ? null : (result.errorMessage ?? result.errorClass ?? 'unknown');
+        return {
+            modelId,
+            status: result.ok ? 'success' : 'failed',
+            probedAt: probedAt.toISOString(),
+            durationMs: result.durationMs,
+            error: probeError,
+        };
+    }
+    async probeQuickStartDraftModel(dto, actor, source = 'api') {
+        void source;
+        await this.assertProbeWorkflowStart(shared_1.LOCAL_PROJECT_CONTEXT, actor);
+        const modelId = (0, node_crypto_1.randomUUID)();
+        const model = {
+            id: modelId,
+            providerType: dto.providerType.trim(),
+            providerModelId: dto.providerModelId.trim(),
+            endpoint: dto.endpoint.trim(),
+            apiKey: dto.apiKey,
+            capabilities: dto.capabilities,
+            rpmLimit: dto.rpm.limit,
+            tpmLimit: dto.tpm.limit,
+            concurrencyLimit: dto.concurrency.limit,
+            autoConcurrency: dto.autoConcurrency,
+            inputTokenPricePerMillion: String(dto.pricing.inputPerMillion),
+            outputTokenPricePerMillion: String(dto.pricing.outputPerMillion),
+            extraBody: dto.extraBody ?? {},
+        };
+        // Quick-start probe is not project-scoped (no @CurrentProject at the endpoint), so there is no project
+        // org to source — the rate-limit bucket is LOCAL_PROJECT_CONTEXT with undefined org. OSS-identical.
+        const result = await this.runConnectivityProbe(shared_1.LOCAL_PROJECT_CONTEXT, model, `probe-quick-start-draft-${modelId}`);
+        const probedAt = new Date(result.checkedAt);
+        const probeError = result.ok ? null : (result.errorMessage ?? result.errorClass ?? 'unknown');
+        return {
+            modelId,
+            status: result.ok ? 'success' : 'failed',
+            probedAt: probedAt.toISOString(),
+            durationMs: result.durationMs,
+            error: probeError,
+        };
+    }
+    async updateProjectModel(projectId, modelId, dto, actor, source = 'api', orgId) {
+        void source;
+        await this.getWritableProject(projectId, actor);
+        const existing = await this.repo.findModelById(modelId);
+        if (!existing) {
+            throw new common_1.NotFoundException(`Model ${modelId} not found`);
+        }
+        const patch = this.buildUpdateRow(dto, existing);
+        await this.updateModelOrThrowNameConflict(modelId, patch);
+        return this.getProjectModelDetail(projectId, modelId, actor, orgId);
+    }
+    async deleteProjectModel(projectId, modelId, query, actor, source = 'api') {
+        void query;
+        void source;
+        await this.getWritableProject(projectId, actor);
+        const existing = await this.repo.findModelById(modelId);
+        if (!existing) {
+            throw new common_1.NotFoundException(`Model ${modelId} not found`);
+        }
+        await this.assertNotActivelyReferenced(modelId);
+        await this.repo.softDeleteModel(modelId);
+    }
+    async duplicateProjectModel(projectId, sourceModelId, actor, source = 'api', orgId) {
+        void source;
+        await this.getWritableProject(projectId, actor);
+        const sourceRow = await this.repo.findModelAccessibleToProject(projectId, sourceModelId);
+        if (!sourceRow)
+            throw new common_1.NotFoundException(`Model ${sourceModelId} not found`);
+        const apiKeyPlain = this.crypto.decryptApiKey(sourceRow.apiKeyEncrypted);
+        const modelId = (0, node_crypto_1.randomUUID)();
+        const insert = {
+            id: modelId,
+            projectId,
+            name: `${sourceRow.name} 副本`,
+            providerType: sourceRow.providerType,
+            providerModelId: sourceRow.providerModelId,
+            endpoint: sourceRow.endpoint,
+            apiKeyEncrypted: this.crypto.encryptApiKey(apiKeyPlain),
+            contextWindowTokens: sourceRow.contextWindowTokens,
+            rpmLimit: sourceRow.rpmLimit,
+            tpmLimit: sourceRow.tpmLimit,
+            concurrencyLimit: sourceRow.concurrencyLimit,
+            autoConcurrency: sourceRow.autoConcurrency,
+            inputTokenPricePerMillion: sourceRow.inputTokenPricePerMillion,
+            outputTokenPricePerMillion: sourceRow.outputTokenPricePerMillion,
+            capabilities: sourceRow.capabilities,
+            extraBody: sourceRow.extraBody,
+            isActive: true,
+            lastProbedAt: null,
+            lastProbeError: null,
+            createdBy: actor.sub,
+        };
+        const created = await this.createModelOrThrowNameConflict(insert);
+        return this.getProjectModelDetail(projectId, created.id, actor, orgId);
+    }
+    async revealProjectApiKey(projectId, modelId, actor, source = 'api') {
+        void source;
+        await this.getAccessibleProject(projectId, actor);
+        const row = await this.repo.findModelAccessibleToProject(projectId, modelId);
+        if (!row)
+            throw new common_1.NotFoundException(`Model ${modelId} not found`);
+        const apiKey = this.crypto.decryptApiKey(row.apiKeyEncrypted);
+        return { modelId, apiKey };
+    }
+    async probeProjectModel(projectId, modelId, actor, source = 'api', orgId) {
+        await this.getAccessibleProject(projectId, actor);
+        const row = await this.repo.findModelAccessibleToProject(projectId, modelId);
+        if (!row)
+            throw new common_1.NotFoundException(`Model ${modelId} not found`);
+        await this.assertProbeWorkflowStart({ projectId, orgId, source: 'local' }, actor);
+        // orgId (SaaS-only; undefined in OSS) sourced from the resolved ProjectContext — the project's org
+        // is the rate-limit bucket (SPEC 08 §3.7), not the actor's org.
+        return this.probeAndRecord({ projectId, orgId, source: 'local' }, row, actor.sub, source, 'local');
+    }
+    async probeQuickStartExistingModel(modelId, actor, source = 'api') {
+        const row = await this.repo.findModelById(modelId);
+        if (!row) {
+            throw new common_1.NotFoundException(`Model ${modelId} not found`);
+        }
+        await this.assertProbeWorkflowStart(shared_1.LOCAL_PROJECT_CONTEXT, actor);
+        // Quick-start probe is not project-scoped (no @CurrentProject at the endpoint), so there is no project
+        // org to source — the rate-limit bucket is LOCAL_PROJECT_CONTEXT with undefined org. OSS-identical.
+        return this.probeAndRecord(shared_1.LOCAL_PROJECT_CONTEXT, row, actor.sub, source, 'quick_start');
+    }
+    async getProjectModelReferences(projectId, modelId, actor) {
+        await this.getAccessibleProject(projectId, actor);
+        const row = await this.repo.findModelAccessibleToProject(projectId, modelId);
+        if (!row)
+            throw new common_1.NotFoundException(`Model ${modelId} not found`);
+        return this.toReferencesDto(await this.repo.getActiveReferenceCounts(modelId));
+    }
+    async exportProjectModelsCsv(projectId, actor, orgId) {
+        const { data } = await this.listProjectModels(projectId, actor, orgId);
+        const content = this.toProjectCsv(data);
+        const buffer = node_buffer_1.Buffer.from(content, 'utf8');
+        return {
+            buffer,
+            byteLength: buffer.byteLength,
+            contentType: 'text/csv; charset=utf-8',
+            fileName: `models-${new Date().toISOString().slice(0, 10)}.csv`,
+        };
+    }
+    // -------------------------------------------------------------------------
+    // Model context dictionary (behavior preserved)
+    // -------------------------------------------------------------------------
+    async listContextWindows(query) {
+        const data = (await this.repo.findContextWindows(query)).map((row) => this.toContextWindowResponse(row));
+        return { data, total: data.length };
+    }
+    async lookupContextWindow(providerModelId) {
+        const row = await this.repo.findContextWindowByProviderModelId(providerModelId);
+        return row ? this.toContextWindowResponse(row) : null;
+    }
+    async upsertContextWindow(dto, actorUserId, source = 'api') {
+        void source;
+        const row = await this.repo.upsertContextWindow(dto, actorUserId);
+        return this.toContextWindowResponse(row);
+    }
+    // =========================================================================
+    // Private helpers
+    // =========================================================================
+    async getAccessibleProject(projectId, actor) {
+        await this.accessControl.assertCan((0, access_control_1.toActorContext)(actor), { projectId, source: 'local' }, 'project_read');
+        const project = await this.repo.findProjectAccess(actor.sub, projectId, actor.isSuperAdmin);
+        if (!project)
+            throw new common_1.NotFoundException(`Local workspace ${projectId} not found`);
+        return project;
+    }
+    async getWritableProject(projectId, actor) {
+        await this.accessControl.assertCan((0, access_control_1.toActorContext)(actor), { projectId, source: 'local' }, 'project_write');
+        return this.getAccessibleProject(projectId, actor);
+    }
+    async assertProbeWorkflowStart(project, actor) {
+        await this.workflowAuth.assertCanStart((0, access_control_1.toActorContext)(actor), project, 'probe');
+    }
+    async assertNotActivelyReferenced(modelId) {
+        const counts = await this.repo.getActiveReferenceCounts(modelId);
+        const total = counts.experiments + counts.optimizations + counts.canaryReleases + counts.productionReleases;
+        if (total > 0) {
+            throw new common_1.ConflictException(`model_referenced_active:${total}`);
+        }
+    }
+    buildInsertRow(projectId, modelId, dto, actorUserId) {
+        return {
+            id: modelId,
+            projectId,
+            name: dto.name.trim(),
+            providerType: dto.providerType.trim(),
+            providerModelId: dto.providerModelId.trim(),
+            endpoint: dto.endpoint.trim(),
+            apiKeyEncrypted: this.crypto.encryptApiKey(dto.apiKey),
+            contextWindowTokens: dto.contextWindowTokens ?? null,
+            rpmLimit: dto.rpm.limit,
+            tpmLimit: dto.tpm.limit,
+            concurrencyLimit: dto.concurrency.limit,
+            autoConcurrency: dto.autoConcurrency,
+            inputTokenPricePerMillion: String(dto.pricing.inputPerMillion),
+            outputTokenPricePerMillion: String(dto.pricing.outputPerMillion),
+            capabilities: dto.capabilities,
+            extraBody: dto.extraBody ?? {},
+            isActive: dto.status !== 'disabled',
+            lastProbedAt: dto.initialProbe ? new Date(dto.initialProbe.probedAt) : null,
+            lastProbeError: dto.initialProbe
+                ? dto.initialProbe.status === 'success'
+                    ? null
+                    : (dto.initialProbe.error ?? 'unknown')
+                : null,
+            createdBy: actorUserId,
+        };
+    }
+    buildUpdateRow(dto, existing) {
+        const patch = {};
+        if (dto.name !== undefined)
+            patch.name = dto.name.trim();
+        if (dto.providerType !== undefined)
+            patch.providerType = dto.providerType.trim();
+        if (dto.providerModelId !== undefined)
+            patch.providerModelId = dto.providerModelId.trim();
+        if (dto.endpoint !== undefined)
+            patch.endpoint = dto.endpoint.trim();
+        if (dto.apiKey !== undefined)
+            patch.apiKeyEncrypted = this.crypto.encryptApiKey(dto.apiKey);
+        if (dto.contextWindowTokens !== undefined)
+            patch.contextWindowTokens = dto.contextWindowTokens ?? null;
+        if (dto.rpm?.limit !== undefined)
+            patch.rpmLimit = dto.rpm.limit;
+        if (dto.tpm?.limit !== undefined)
+            patch.tpmLimit = dto.tpm.limit;
+        if (dto.concurrency?.limit !== undefined)
+            patch.concurrencyLimit = dto.concurrency.limit;
+        if (dto.autoConcurrency !== undefined)
+            patch.autoConcurrency = dto.autoConcurrency;
+        if (dto.pricing?.inputPerMillion !== undefined)
+            patch.inputTokenPricePerMillion = String(dto.pricing.inputPerMillion);
+        if (dto.pricing?.outputPerMillion !== undefined)
+            patch.outputTokenPricePerMillion = String(dto.pricing.outputPerMillion);
+        if (dto.capabilities !== undefined)
+            patch.capabilities = dto.capabilities;
+        if (dto.extraBody !== undefined)
+            patch.extraBody = dto.extraBody;
+        if (dto.status !== undefined)
+            patch.isActive = dto.status !== 'disabled';
+        void existing;
+        return patch;
+    }
+    async createModelOrThrowNameConflict(insert) {
+        try {
+            return await this.repo.createModel(insert);
+        }
+        catch (error) {
+            if (isModelNameUniqueViolation(error)) {
+                throw new common_1.ConflictException('model_name_taken');
+            }
+            throw error;
+        }
+    }
+    async updateModelOrThrowNameConflict(modelId, patch) {
+        try {
+            return await this.repo.updateModel(modelId, patch);
+        }
+        catch (error) {
+            if (isModelNameUniqueViolation(error)) {
+                throw new common_1.ConflictException('model_name_taken');
+            }
+            throw error;
+        }
+    }
+    async probeAndRecord(project, row, actorUserId, source, scope) {
+        void actorUserId;
+        void source;
+        void scope;
+        const apiKey = this.crypto.decryptApiKey(row.apiKeyEncrypted);
+        const model = {
+            id: row.id,
+            providerType: row.providerType,
+            providerModelId: row.providerModelId,
+            endpoint: row.endpoint,
+            apiKey,
+            capabilities: this.toModelCapabilities(row.capabilities),
+            rpmLimit: row.rpmLimit,
+            tpmLimit: row.tpmLimit,
+            concurrencyLimit: row.concurrencyLimit,
+            autoConcurrency: row.autoConcurrency,
+            inputTokenPricePerMillion: row.inputTokenPricePerMillion,
+            outputTokenPricePerMillion: row.outputTokenPricePerMillion,
+            extraBody: this.toExtraBody(row.extraBody),
+        };
+        const result = await this.runConnectivityProbe(project, model, `probe-${row.id}`);
+        const probedAt = new Date(result.checkedAt);
+        const probeError = result.ok ? null : (result.errorMessage ?? result.errorClass ?? 'unknown');
+        await this.repo.updateProbeOutcome(row.id, probedAt, probeError);
+        return {
+            modelId: row.id,
+            status: result.ok ? 'success' : 'failed',
+            probedAt: probedAt.toISOString(),
+            durationMs: result.durationMs,
+            error: probeError,
+        };
+    }
+    async runConnectivityProbe(project, model, requestId) {
+        const mergedLimits = await this.runtimeLimitsProvider.mergeLlmLimits({
+            project,
+            modelId: model.id,
+            source: 'probe',
+        });
+        const effectiveModel = (0, runtime_limits_1.applyRuntimeLimits)(model, mergedLimits);
+        return this.quotaPolicy.withExecutionSlot({ project, source: 'probe', modelId: model.id, requestId }, () => (0, llm_client_1.testModelConnectivity)({
+            model: effectiveModel,
+            limiterKey: this.limiterKeyStrategy.buildModelKey(project, model.id),
+            requestId,
+            timeoutMs: 30_000,
+        }, {
+            limiter: this.limiter,
+            logger: this.logger,
+        }));
+    }
+    // -------------------------------------------------------------------------
+    // Mapping: DB row → DTO
+    // -------------------------------------------------------------------------
+    // orgId (SaaS-only; undefined in OSS) is the resolved project's org — the rate-limit bucket (SPEC 08
+    // §3.7). It is carried into the usage-snapshot READ key so it matches the worker's WRITE key under a
+    // SaaS strategy; OSS leaves it undefined so the key stays `model:<id>`.
+    async toProjectModelListItem(row, orgId) {
+        const project = row.projectId
+            ? { projectId: row.projectId, source: 'local', orgId }
+            : shared_1.LOCAL_PROJECT_CONTEXT;
+        const usage = await this.fetchUsageSnapshot(row.id, project);
+        const refs = await this.repo.getTotalReferenceCounts(row.id);
+        return {
+            id: row.id,
+            projectId: row.projectId,
+            name: row.name,
+            providerType: row.providerType,
+            providerModelId: row.providerModelId,
+            endpoint: row.endpoint,
+            contextWindowTokens: row.contextWindowTokens,
+            credentialTail: this.crypto.getCredentialTail(this.crypto.decryptApiKey(row.apiKeyEncrypted)),
+            status: this.deriveStatus(row.isActive),
+            probeStatus: this.deriveProbeStatus(row.lastProbedAt, row.lastProbeError),
+            lastProbedAt: row.lastProbedAt?.toISOString() ?? null,
+            lastProbeError: row.lastProbeError ?? null,
+            rpm: this.toModelLimit(row.rpmLimit, 'rpm', usage),
+            tpm: this.toModelLimit(row.tpmLimit, 'tpm', usage),
+            concurrency: this.toConcurrencyLimit(row, usage),
+            autoConcurrency: row.autoConcurrency,
+            pricing: this.toModelPricing(row),
+            capabilities: this.toModelCapabilities(row.capabilities),
+            extraBody: this.toExtraBody(row.extraBody),
+            createdAt: row.createdAt.toISOString(),
+            updatedAt: row.updatedAt.toISOString(),
+            createdBy: row.createdBy,
+            createdByDisplayName: row.createdByDisplayName ?? null,
+            references: this.sumReferences(refs),
+        };
+    }
+    async fetchUsageSnapshot(modelId, project = shared_1.LOCAL_PROJECT_CONTEXT) {
+        if (!this.limiter.getUsage)
+            return null;
+        try {
+            // Query the same key the worker counts against (§3.7) so usage reflects real rate-limit state.
+            const key = this.limiterKeyStrategy.buildModelKey(project, modelId);
+            return await withTimeout(this.limiter.getUsage(key), MODEL_USAGE_SNAPSHOT_TIMEOUT_MS, `limiter_getUsage_timeout:${modelId}`);
+        }
+        catch (error) {
+            this.logger.warn({ msg: 'limiter_getUsage_failed', modelId, error: error.message });
+            return null;
+        }
+    }
+    deriveStatus(isActive) {
+        return isActive ? 'enabled' : 'disabled';
+    }
+    deriveProbeStatus(lastProbedAt, lastProbeError) {
+        if (!lastProbedAt)
+            return 'pending';
+        return lastProbeError ? 'failed' : 'success';
+    }
+    toModelLimit(limit, kind, usage) {
+        const current = usage
+            ? kind === 'rpm'
+                ? usage.rpmUsed
+                : kind === 'tpm'
+                    ? usage.tpmUsed
+                    : usage.concurrencyInUse
+            : 0;
+        const ratio = limit > 0 ? Math.min(100, Math.round((current / limit) * 100)) : 0;
+        return { limit, usage: ratio, current };
+    }
+    // Concurrency display: surface the system-derived effective cap when autoConcurrency is on and the
+    // model has accumulated autostate (latency EWMA). See docs/specs/21-models.md §6.1
+    toConcurrencyLimit(row, usage) {
+        const base = this.toModelLimit(row.concurrencyLimit, 'concurrency', usage);
+        if (!row.autoConcurrency || !usage || usage.latencyEwmaMs === undefined)
+            return base;
+        const effective = (0, limiter_1.deriveEffectiveConcurrency)({
+            rpmLimit: row.rpmLimit,
+            tpmLimit: row.tpmLimit,
+            ceiling: row.concurrencyLimit,
+            latencyEwmaMs: usage.latencyEwmaMs,
+            tokensEwma: usage.tokensEwma ?? 1,
+            backoffFactor: usage.backoffFactor ?? 1,
+        });
+        return { ...base, effective };
+    }
+    toModelPricing(row) {
+        return {
+            inputPerMillion: Number(row.inputTokenPricePerMillion ?? 0),
+            outputPerMillion: Number(row.outputTokenPricePerMillion ?? 0),
+        };
+    }
+    toModelCapabilities(raw) {
+        if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+            const image = raw.image;
+            if (typeof image === 'string' && ['none', 'url', 'base64', 'both'].includes(image)) {
+                return { image: image };
+            }
+        }
+        return { image: 'none' };
+    }
+    toExtraBody(raw) {
+        if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+            return { ...raw };
+        }
+        return {};
+    }
+    toActiveUsage(counts) {
+        return {
+            experiments: counts.experiments,
+            optimizations: counts.optimizations,
+            canaryReleases: counts.canaryReleases,
+            productionReleases: counts.productionReleases,
+        };
+    }
+    toReferencesDto(counts) {
+        return { ...this.toActiveUsage(counts), total: this.sumReferences(counts) };
+    }
+    sumReferences(counts) {
+        return counts.experiments + counts.optimizations + counts.canaryReleases + counts.productionReleases;
+    }
+    toContextWindowResponse(row) {
+        return {
+            providerModelId: row.providerModelId,
+            contextWindowTokens: row.contextWindowTokens,
+            updatedBy: row.updatedBy ?? null,
+            updatedAt: row.updatedAt.toISOString(),
+        };
+    }
+    // -------------------------------------------------------------------------
+    // CSV export
+    // -------------------------------------------------------------------------
+    toProjectCsv(rows) {
+        const header = [
+            'id',
+            'name',
+            'providerType',
+            'providerModelId',
+            'endpoint',
+            'status',
+            'probeStatus',
+            'rpmLimit',
+            'tpmLimit',
+            'concurrencyLimit',
+            'autoConcurrency',
+            'inputPerMillion',
+            'outputPerMillion',
+            'references',
+            'lastProbedAt',
+        ];
+        const lines = rows.map((r) => [
+            r.id,
+            r.name,
+            r.providerType,
+            r.providerModelId,
+            r.endpoint,
+            r.status,
+            r.probeStatus,
+            r.rpm.limit,
+            r.tpm.limit,
+            r.concurrency.limit,
+            r.autoConcurrency,
+            r.pricing.inputPerMillion,
+            r.pricing.outputPerMillion,
+            r.references,
+            r.lastProbedAt ?? '',
+        ]
+            .map((v) => this.toCsvCell(v))
+            .join(','));
+        return `\uFEFF${[header.join(','), ...lines].join('\n')}\n`;
+    }
+    toCsvCell(value) {
+        const text = value === undefined || value === null
+            ? ''
+            : typeof value === 'object'
+                ? (JSON.stringify(value) ?? '')
+                : String(value);
+        if (!/[",\n\r]/u.test(text))
+            return text;
+        return `"${text.replaceAll('"', '""')}"`;
+    }
+};
+exports.ModelService = ModelService;
+exports.ModelService = ModelService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(2, (0, common_1.Inject)(redis_constants_1.REDIS_LIMITER)),
+    __metadata("design:paramtypes", [model_repository_1.ModelRepository,
+        crypto_service_1.CryptoService, Object, access_control_service_1.AccessControlService,
+        limiter_key_strategy_1.LimiterKeyStrategy,
+        runtime_limits_provider_1.RuntimeLimitsProvider,
+        workflow_authorization_hook_1.WorkflowAuthorizationHook,
+        quota_policy_hook_1.QuotaPolicyHook])
+], ModelService);
+function withTimeout(promise, timeoutMs, message) {
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+    });
+    return Promise.race([promise, timeout]).finally(() => {
+        if (timer)
+            clearTimeout(timer);
+    });
+}
+function isModelNameUniqueViolation(error) {
+    return (0, db_error_1.isUniqueViolation)(error, /idx_models_project_name_active/);
+}
+//# sourceMappingURL=model.service.js.map