@dataparade/cli 0.0.1

package/dist/src/ai-enrichment/providers/families/chat-completions-family.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatCompletionsFamilyProvider = void 0;
+const openai_proposals_response_schema_1 = require("../../openai-proposals-response.schema");
+const provider_enrichment_prompts_1 = require("../../prompts/provider-enrichment-prompts");
+const provider_contract_1 = require("../provider-contract");
+const provider_runtime_1 = require("../provider-runtime");
+const provider_pricing_1 = require("../provider-pricing");
+const provider_output_token_budget_1 = require("../provider-output-token-budget");
+const endpoint_resolution_1 = require("../endpoint-resolution");
+const fetch_with_timeout_1 = require("../fetch-with-timeout");
+const presets_1 = require("../presets");
+const resolve_provider_1 = require("../resolve-provider");
+function useOpenAiStructuredJsonSchema() {
+    const v = process.env.DATAPARADE_AI_OPENAI_JSON_SCHEMA?.trim().toLowerCase();
+    return v !== "0" && v !== "false" && v !== "no";
+}
+function openAiJsonSchemaStrictFromEnv() {
+    const v = process.env.DATAPARADE_AI_OPENAI_JSON_SCHEMA_STRICT?.trim().toLowerCase();
+    return v === "1" || v === "true" || v === "yes";
+}
+function sumUsage(parts) {
+    const inputTokens = parts.reduce((n, p) => n + Math.max(0, p.prompt ?? 0), 0);
+    const outputTokens = parts.reduce((n, p) => n + Math.max(0, p.completion ?? 0), 0);
+    const reportedTotal = parts.reduce((n, p) => n + Math.max(0, p.total ?? 0), 0);
+    return {
+        inputTokens,
+        outputTokens,
+        totalTokens: Math.max(inputTokens + outputTokens, reportedTotal),
+    };
+}
+function parseProposalArray(input) {
+    if (!Array.isArray(input))
+        return [];
+    return input;
+}
+async function inferViaHttpJsonShim(presetId, endpoint, request, apiKey) {
+    const response = await (0, fetch_with_timeout_1.fetchWithTimeout)(endpoint, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+            model: request.model,
+            prompt: request.prompt,
+            temperature: request.temperature ?? 0.1,
+            max_tokens: request.maxTokens ?? 1024,
+        }),
+    });
+    const payloadRaw = await (0, provider_runtime_1.readJsonOrWarn)(response, "Chat completions shim");
+    if (payloadRaw == null)
+        return { proposals: [] };
+    const payload = payloadRaw;
+    return {
+        proposals: parseProposalArray(payload.proposals ?? payload.data),
+        usage: payload.usage &&
+            typeof payload.usage.inputTokens === "number" &&
+            typeof payload.usage.outputTokens === "number"
+            ? {
+                inputTokens: Math.max(0, payload.usage.inputTokens),
+                outputTokens: Math.max(0, payload.usage.outputTokens),
+                totalTokens: Math.max(Math.max(0, payload.usage.inputTokens) +
+                    Math.max(0, payload.usage.outputTokens), typeof payload.usage.totalTokens === "number"
+                    ? Math.max(0, payload.usage.totalTokens)
+                    : 0),
+                estimatedCostUsd: typeof payload.usage.estimatedCostUsd === "number"
+                    ? Math.max(0, payload.usage.estimatedCostUsd)
+                    : undefined,
+            }
+            : undefined,
+    };
+}
+/**
+ * OpenAI-style Chat Completions API. Used by the `openai` preset; also supports a
+ * legacy `{ model, prompt, max_tokens }` shim when the endpoint is not chat-completions-shaped.
+ */
+class ChatCompletionsFamilyProvider {
+    constructor(resolved) {
+        this.resolved = resolved;
+        this.id = resolved.presetId;
+    }
+    async infer(request) {
+        const apiKey = (0, resolve_provider_1.resolveInferApiKey)(request, this.resolved);
+        if (!apiKey)
+            return { proposals: [] };
+        const presetDefault = (0, presets_1.getProviderPreset)(this.resolved.presetId).defaultEndpoint;
+        const url = (0, endpoint_resolution_1.resolveChatCompletionsEndpoint)(request.endpoint ?? this.resolved.endpoint, presetDefault);
+        if ((0, endpoint_resolution_1.shouldUseChatCompletionsJsonShim)(url)) {
+            return inferViaHttpJsonShim(this.resolved.presetId, url, request, apiKey);
+        }
+        const agent = (0, provider_contract_1.parseAgentFromPrompt)(request.prompt);
+        const model = request.model?.trim() || this.resolved.model;
+        const maxTokens = (0, provider_output_token_budget_1.clampStructuredJsonCompletionTokens)(request.maxTokens);
+        const responseFormat = useOpenAiStructuredJsonSchema()
+            ? {
+                type: "json_schema",
+                json_schema: (0, openai_proposals_response_schema_1.getOpenAiProposalsResponseJsonSchemaForApi)({
+                    strict: openAiJsonSchemaStrictFromEnv(),
+                }),
+            }
+            : { type: "json_object" };
+        const body = {
+            model,
+            messages: [
+                { role: "system", content: provider_enrichment_prompts_1.AI_PROVIDER_SYSTEM_PROMPT },
+                { role: "user", content: request.prompt },
+            ],
+            temperature: request.temperature ?? 0.1,
+            max_tokens: maxTokens,
+            response_format: responseFormat,
+        };
+        const response = await (0, fetch_with_timeout_1.fetchWithTimeout)(url, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify(body),
+        });
+        const payloadRaw = await (0, provider_runtime_1.readJsonOrWarn)(response, "OpenAI chat/completions");
+        if (payloadRaw == null)
+            return { proposals: [] };
+        const payload = payloadRaw;
+        const finishReason = payload.choices?.[0]?.finish_reason;
+        if (finishReason === "length") {
+            console.warn("[dataparade-ai] OpenAI finish_reason=length (output may be truncated). Raise DATAPARADE_AI_MAX_TOKENS or reduce prompt size.");
+        }
+        const message = payload.choices?.[0]?.message;
+        if (message?.refusal != null && String(message.refusal).trim() !== "") {
+            if ((0, provider_contract_1.aiDebugEnabled)()) {
+                console.warn("[dataparade-ai] OpenAI refusal:", String(message.refusal).slice(0, 500));
+            }
+            return { proposals: [] };
+        }
+        const content = message?.content;
+        if (!content || typeof content !== "string") {
+            if ((0, provider_contract_1.aiDebugEnabled)()) {
+                console.warn("[dataparade-ai] OpenAI response had no assistant message content.");
+            }
+            return { proposals: [] };
+        }
+        const parsed = (0, provider_runtime_1.parseJsonTextOrWarn)(content, {
+            providerLabel: "OpenAI",
+            finishReason,
+        });
+        if (parsed == null)
+            return { proposals: [] };
+        const out = (0, provider_contract_1.strictParseAndNormalizeProposals)(parsed, {
+            provider: this.resolved.presetId,
+            model,
+            agent,
+        }, { debugLabel: "OpenAI", userPrompt: request.prompt });
+        if (out.length === 0 && (0, provider_contract_1.aiDebugEnabled)()) {
+            console.warn("[dataparade-ai] OpenAI returned zero valid proposals after strict schema/normalization.");
+        }
+        const usageTotals = sumUsage([
+            {
+                prompt: payload.usage?.prompt_tokens,
+                completion: payload.usage?.completion_tokens,
+                total: payload.usage?.total_tokens,
+            },
+        ]);
+        const { inputTokens, outputTokens, totalTokens } = usageTotals;
+        const usage = inputTokens > 0 || outputTokens > 0 || totalTokens > 0
+            ? {
+                inputTokens,
+                outputTokens,
+                totalTokens,
+                estimatedCostUsd: (0, provider_pricing_1.estimateTokenCostUsd)({
+                    provider: this.resolved.presetId,
+                    model,
+                    inputTokens,
+                    outputTokens,
+                }),
+            }
+            : undefined;
+        return { proposals: out, usage };
+    }
+}
+exports.ChatCompletionsFamilyProvider = ChatCompletionsFamilyProvider;

package/dist/src/ai-enrichment/providers/families/generate-content-family.d.ts

@@ -0,0 +1,10 @@
+import type { AiProviderId } from "../../types";
+import { type ResolvedProviderConfig } from "../resolve-provider";
+import type { AiProvider, AiProviderRequest, AiProviderResult } from "../types";
+/** Google Gemini generateContent API. Used by the `gemini` preset. */
+export declare class GenerateContentFamilyProvider implements AiProvider {
+    private readonly resolved;
+    readonly id: AiProviderId;
+    constructor(resolved: ResolvedProviderConfig);
+    infer(request: AiProviderRequest): Promise<AiProviderResult>;
+}

package/dist/src/ai-enrichment/providers/families/generate-content-family.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateContentFamilyProvider = void 0;
+const provider_enrichment_prompts_1 = require("../../prompts/provider-enrichment-prompts");
+const provider_contract_1 = require("../provider-contract");
+const provider_json_parse_1 = require("../provider-json-parse");
+const provider_runtime_1 = require("../provider-runtime");
+const provider_pricing_1 = require("../provider-pricing");
+const provider_output_token_budget_1 = require("../provider-output-token-budget");
+const endpoint_resolution_1 = require("../endpoint-resolution");
+const fetch_with_timeout_1 = require("../fetch-with-timeout");
+const presets_1 = require("../presets");
+const resolve_provider_1 = require("../resolve-provider");
+/** Google Gemini generateContent API. Used by the `gemini` preset. */
+class GenerateContentFamilyProvider {
+    constructor(resolved) {
+        this.resolved = resolved;
+        this.id = resolved.presetId;
+    }
+    async infer(request) {
+        const model = request.model?.trim() || this.resolved.model;
+        const presetDefault = (0, presets_1.getProviderPreset)(this.resolved.presetId).defaultEndpoint;
+        const endpointUrl = (0, endpoint_resolution_1.resolveGeminiGenerateContentEndpoint)(request.endpoint ?? this.resolved.endpoint, model, presetDefault);
+        const apiKey = (0, resolve_provider_1.resolveInferApiKey)(request, this.resolved);
+        if (this.resolved.auth === "query-key" && !apiKey) {
+            return { proposals: [] };
+        }
+        const url = apiKey
+            ? `${endpointUrl}${endpointUrl.includes("?") ? "&" : "?"}key=${encodeURIComponent(apiKey)}`
+            : endpointUrl;
+        const response = await (0, fetch_with_timeout_1.fetchWithTimeout)(url, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({
+                systemInstruction: { parts: [{ text: provider_enrichment_prompts_1.AI_PROVIDER_SYSTEM_PROMPT }] },
+                contents: [
+                    {
+                        role: "user",
+                        parts: [{ text: request.prompt }],
+                    },
+                ],
+                generationConfig: {
+                    temperature: request.temperature ?? 0.1,
+                    maxOutputTokens: (0, provider_output_token_budget_1.clampStructuredJsonCompletionTokens)(request.maxTokens),
+                    responseMimeType: "application/json",
+                },
+            }),
+        });
+        const payloadRaw = await (0, provider_runtime_1.readJsonOrWarn)(response, "Gemini generateContent");
+        if (payloadRaw == null)
+            return { proposals: [] };
+        const payload = payloadRaw;
+        const content = (payload.candidates ?? [])
+            .flatMap((c) => c.content?.parts ?? [])
+            .map((part) => (typeof part.text === "string" ? part.text : ""))
+            .join("\n")
+            .trim();
+        if (!content)
+            return { proposals: [] };
+        const parsed = (0, provider_json_parse_1.parseProviderJsonContent)(content);
+        if (!parsed.ok) {
+            if ((0, provider_contract_1.aiDebugEnabled)()) {
+                console.warn("[dataparade-ai] Failed to parse Gemini JSON:", parsed.error);
+            }
+            return { proposals: [] };
+        }
+        const proposals = (0, provider_contract_1.strictParseAndNormalizeProposals)(parsed.value, {
+            provider: this.resolved.presetId,
+            model,
+            agent: (0, provider_contract_1.parseAgentFromPrompt)(request.prompt),
+        }, { debugLabel: "Gemini generateContent", userPrompt: request.prompt });
+        const inputTokens = Math.max(0, payload.usageMetadata?.promptTokenCount ?? 0);
+        const outputTokens = Math.max(0, payload.usageMetadata?.candidatesTokenCount ?? 0);
+        const totalTokens = Math.max(inputTokens + outputTokens, payload.usageMetadata?.totalTokenCount ?? 0);
+        const usage = totalTokens > 0
+            ? {
+                inputTokens,
+                outputTokens,
+                totalTokens,
+                estimatedCostUsd: (0, provider_pricing_1.estimateTokenCostUsd)({
+                    provider: this.resolved.presetId,
+                    model,
+                    inputTokens,
+                    outputTokens,
+                }),
+            }
+            : undefined;
+        return { proposals, usage };
+    }
+}
+exports.GenerateContentFamilyProvider = GenerateContentFamilyProvider;

package/dist/src/ai-enrichment/providers/families/messages-family.d.ts

@@ -0,0 +1,10 @@
+import type { AiProviderId } from "../../types";
+import { type ResolvedProviderConfig } from "../resolve-provider";
+import type { AiProvider, AiProviderRequest, AiProviderResult } from "../types";
+/** Anthropic Messages API. Used by the `anthropic` preset. */
+export declare class MessagesFamilyProvider implements AiProvider {
+    private readonly resolved;
+    readonly id: AiProviderId;
+    constructor(resolved: ResolvedProviderConfig);
+    infer(request: AiProviderRequest): Promise<AiProviderResult>;
+}

package/dist/src/ai-enrichment/providers/families/messages-family.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessagesFamilyProvider = void 0;
+const provider_enrichment_prompts_1 = require("../../prompts/provider-enrichment-prompts");
+const provider_contract_1 = require("../provider-contract");
+const provider_runtime_1 = require("../provider-runtime");
+const provider_pricing_1 = require("../provider-pricing");
+const provider_output_token_budget_1 = require("../provider-output-token-budget");
+const fetch_with_timeout_1 = require("../fetch-with-timeout");
+const resolve_provider_1 = require("../resolve-provider");
+const DEFAULT_ANTHROPIC_VERSION = "2023-06-01";
+/** Anthropic Messages API. Used by the `anthropic` preset. */
+class MessagesFamilyProvider {
+    constructor(resolved) {
+        this.resolved = resolved;
+        this.id = resolved.presetId;
+    }
+    async infer(request) {
+        const apiKey = (0, resolve_provider_1.resolveInferApiKey)(request, this.resolved);
+        if (!apiKey)
+            return { proposals: [] };
+        const model = request.model?.trim() || this.resolved.model;
+        const maxTokens = (0, provider_output_token_budget_1.clampStructuredJsonCompletionTokens)(request.maxTokens);
+        const endpoint = request.endpoint?.trim() || this.resolved.endpoint;
+        const response = await (0, fetch_with_timeout_1.fetchWithTimeout)(endpoint, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "x-api-key": apiKey,
+                "anthropic-version": DEFAULT_ANTHROPIC_VERSION,
+            },
+            body: JSON.stringify({
+                model,
+                max_tokens: maxTokens,
+                temperature: request.temperature ?? 0.1,
+                system: (0, provider_enrichment_prompts_1.buildAnthropicEnrichmentSystemPrompt)(),
+                messages: [{ role: "user", content: request.prompt }],
+            }),
+        });
+        const payloadRaw = await (0, provider_runtime_1.readJsonOrWarn)(response, "Anthropic messages");
+        if (payloadRaw == null)
+            return { proposals: [] };
+        const payload = payloadRaw;
+        const textContent = (0, provider_runtime_1.joinAnthropicTextBlocks)(payload.content);
+        const stopReason = payload.stop_reason;
+        const inputTokens = Math.max(0, payload.usage?.input_tokens ?? 0);
+        const outputTokens = Math.max(0, payload.usage?.output_tokens ?? 0);
+        const totalTokens = inputTokens + outputTokens;
+        const usage = totalTokens > 0
+            ? {
+                inputTokens,
+                outputTokens,
+                totalTokens,
+                estimatedCostUsd: (0, provider_pricing_1.estimateTokenCostUsd)({
+                    provider: this.resolved.presetId,
+                    model,
+                    inputTokens,
+                    outputTokens,
+                }),
+            }
+            : undefined;
+        if (stopReason === "max_tokens") {
+            console.warn("[dataparade-ai] Anthropic stop_reason=max_tokens (output may be truncated). Raise DATAPARADE_AI_MAX_TOKENS or reduce prompt size; incomplete JSON cannot be merged.");
+        }
+        if (!textContent) {
+            if ((0, provider_contract_1.aiDebugEnabled)()) {
+                console.warn("[dataparade-ai] Anthropic response had no text content blocks.");
+            }
+            return { proposals: [], usage };
+        }
+        const parsedValue = (0, provider_runtime_1.parseJsonTextOrWarn)(textContent, {
+            providerLabel: "Anthropic",
+            finishReason: stopReason,
+        });
+        if (parsedValue == null)
+            return { proposals: [], usage };
+        const agent = (0, provider_contract_1.parseAgentFromPrompt)(request.prompt);
+        const out = (0, provider_contract_1.strictParseAndNormalizeProposals)(parsedValue, {
+            provider: this.resolved.presetId,
+            model,
+            agent,
+        }, { debugLabel: "Anthropic", userPrompt: request.prompt });
+        return { proposals: out, usage };
+    }
+}
+exports.MessagesFamilyProvider = MessagesFamilyProvider;

package/dist/src/ai-enrichment/providers/families/ollama-generate-family.d.ts

@@ -0,0 +1,10 @@
+import type { AiProviderId } from "../../types";
+import type { ResolvedProviderConfig } from "../resolve-provider";
+import type { AiProvider, AiProviderRequest, AiProviderResult } from "../types";
+/** Ollama POST /api/generate. Used by the `local` preset. */
+export declare class OllamaGenerateFamilyProvider implements AiProvider {
+    private readonly resolved;
+    readonly id: AiProviderId;
+    constructor(resolved: ResolvedProviderConfig);
+    infer(request: AiProviderRequest): Promise<AiProviderResult>;
+}

package/dist/src/ai-enrichment/providers/families/ollama-generate-family.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaGenerateFamilyProvider = void 0;
+const provider_enrichment_prompts_1 = require("../../prompts/provider-enrichment-prompts");
+const provider_contract_1 = require("../provider-contract");
+const provider_json_parse_1 = require("../provider-json-parse");
+const provider_runtime_1 = require("../provider-runtime");
+const provider_output_token_budget_1 = require("../provider-output-token-budget");
+const fetch_with_timeout_1 = require("../fetch-with-timeout");
+/** Ollama POST /api/generate. Used by the `local` preset. */
+class OllamaGenerateFamilyProvider {
+    constructor(resolved) {
+        this.resolved = resolved;
+        this.id = resolved.presetId;
+    }
+    async infer(request) {
+        const endpoint = request.endpoint?.trim() || this.resolved.endpoint;
+        const model = request.model?.trim() || this.resolved.model;
+        const response = await (0, fetch_with_timeout_1.fetchWithTimeout)(endpoint, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({
+                model,
+                prompt: `${provider_enrichment_prompts_1.AI_PROVIDER_SYSTEM_PROMPT}\n\nUser payload:\n${request.prompt}`,
+                stream: false,
+                options: {
+                    temperature: request.temperature ?? 0.1,
+                    num_predict: (0, provider_output_token_budget_1.clampStructuredJsonCompletionTokens)(request.maxTokens),
+                },
+            }),
+        });
+        const payloadRaw = await (0, provider_runtime_1.readJsonOrWarn)(response, "Local/Ollama");
+        if (payloadRaw == null)
+            return { proposals: [] };
+        const payload = payloadRaw;
+        const text = typeof payload.response === "string" ? payload.response.trim() : "";
+        if (!text)
+            return { proposals: [] };
+        const parsed = (0, provider_json_parse_1.parseProviderJsonContent)(text);
+        if (!parsed.ok) {
+            if ((0, provider_contract_1.aiDebugEnabled)()) {
+                console.warn("[dataparade-ai] Failed to parse Local/Ollama JSON:", parsed.error);
+            }
+            return { proposals: [] };
+        }
+        const proposals = (0, provider_contract_1.strictParseAndNormalizeProposals)(parsed.value, {
+            provider: this.resolved.presetId,
+            model,
+            agent: (0, provider_contract_1.parseAgentFromPrompt)(request.prompt),
+        }, { debugLabel: "Local/Ollama generate", userPrompt: request.prompt });
+        const inputTokens = Math.max(0, payload.prompt_eval_count ?? 0);
+        const outputTokens = Math.max(0, payload.eval_count ?? 0);
+        const totalTokens = inputTokens + outputTokens;
+        return {
+            proposals,
+            usage: totalTokens > 0
+                ? {
+                    inputTokens,
+                    outputTokens,
+                    totalTokens,
+                    estimatedCostUsd: 0,
+                }
+                : undefined,
+        };
+    }
+}
+exports.OllamaGenerateFamilyProvider = OllamaGenerateFamilyProvider;

package/dist/src/ai-enrichment/providers/fetch-with-timeout.d.ts

@@ -0,0 +1,2 @@
+/** POST/GET to model APIs with an AbortSignal timeout (default 120s). */
+export declare function fetchWithTimeout(url: string, init: RequestInit, timeoutMs?: number): Promise<Response>;

package/dist/src/ai-enrichment/providers/fetch-with-timeout.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchWithTimeout = fetchWithTimeout;
+const DEFAULT_TIMEOUT_MS = 120_000;
+function parseTimeoutMs() {
+    const raw = process.env.DATAPARADE_AI_HTTP_TIMEOUT_MS?.trim();
+    if (!raw)
+        return DEFAULT_TIMEOUT_MS;
+    const n = Number(raw);
+    return Number.isFinite(n) && n > 0 ? Math.floor(n) : DEFAULT_TIMEOUT_MS;
+}
+/** POST/GET to model APIs with an AbortSignal timeout (default 120s). */
+async function fetchWithTimeout(url, init, timeoutMs = parseTimeoutMs()) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { ...init, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/src/ai-enrichment/providers/index.d.ts

@@ -0,0 +1,16 @@
+import { type ResolveProviderOverrides } from "./resolve-provider";
+import type { AiProvider } from "./types";
+import type { AiProviderId } from "../types";
+export interface CreateAiProviderOptions extends ResolveProviderOverrides {
+}
+/**
+ * Builds an {@link AiProvider} from a user-facing preset id (`openai`, `anthropic`, …).
+ * HTTP shape is selected by API family (see {@link resolveProviderConfig}), not per-vendor classes.
+ */
+export declare function createAiProvider(presetId: AiProviderId | string | undefined, options?: CreateAiProviderOptions): AiProvider;
+export type { AiProvider, AiProviderRequest } from "./types";
+export type { AiProviderId } from "../types";
+export { resolveProviderConfig, resolveInferApiKey } from "./resolve-provider";
+export { resolveChatCompletionsEndpoint, resolveGeminiGenerateContentEndpoint, shouldUseChatCompletionsJsonShim, } from "./endpoint-resolution";
+export { AI_PROVIDER_PRESETS, getProviderPreset } from "./presets";
+export type { AiApiFamily, AiProviderPresetDefinition } from "./presets";

package/dist/src/ai-enrichment/providers/index.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProviderPreset = exports.AI_PROVIDER_PRESETS = exports.shouldUseChatCompletionsJsonShim = exports.resolveGeminiGenerateContentEndpoint = exports.resolveChatCompletionsEndpoint = exports.resolveInferApiKey = exports.resolveProviderConfig = void 0;
+exports.createAiProvider = createAiProvider;
+const mock_1 = require("./mock");
+const resolve_provider_1 = require("./resolve-provider");
+const chat_completions_family_1 = require("./families/chat-completions-family");
+const messages_family_1 = require("./families/messages-family");
+const generate_content_family_1 = require("./families/generate-content-family");
+const ollama_generate_family_1 = require("./families/ollama-generate-family");
+/**
+ * Builds an {@link AiProvider} from a user-facing preset id (`openai`, `anthropic`, …).
+ * HTTP shape is selected by API family (see {@link resolveProviderConfig}), not per-vendor classes.
+ */
+function createAiProvider(presetId, options = {}) {
+    const resolved = (0, resolve_provider_1.resolveProviderConfig)(presetId, options);
+    switch (resolved.family) {
+        case "chat-completions":
+            return new chat_completions_family_1.ChatCompletionsFamilyProvider(resolved);
+        case "messages":
+            return new messages_family_1.MessagesFamilyProvider(resolved);
+        case "generate-content":
+            return new generate_content_family_1.GenerateContentFamilyProvider(resolved);
+        case "ollama-generate":
+            return new ollama_generate_family_1.OllamaGenerateFamilyProvider(resolved);
+        case "mock":
+        default:
+            return new mock_1.MockAiProvider();
+    }
+}
+var resolve_provider_2 = require("./resolve-provider");
+Object.defineProperty(exports, "resolveProviderConfig", { enumerable: true, get: function () { return resolve_provider_2.resolveProviderConfig; } });
+Object.defineProperty(exports, "resolveInferApiKey", { enumerable: true, get: function () { return resolve_provider_2.resolveInferApiKey; } });
+var endpoint_resolution_1 = require("./endpoint-resolution");
+Object.defineProperty(exports, "resolveChatCompletionsEndpoint", { enumerable: true, get: function () { return endpoint_resolution_1.resolveChatCompletionsEndpoint; } });
+Object.defineProperty(exports, "resolveGeminiGenerateContentEndpoint", { enumerable: true, get: function () { return endpoint_resolution_1.resolveGeminiGenerateContentEndpoint; } });
+Object.defineProperty(exports, "shouldUseChatCompletionsJsonShim", { enumerable: true, get: function () { return endpoint_resolution_1.shouldUseChatCompletionsJsonShim; } });
+var presets_1 = require("./presets");
+Object.defineProperty(exports, "AI_PROVIDER_PRESETS", { enumerable: true, get: function () { return presets_1.AI_PROVIDER_PRESETS; } });
+Object.defineProperty(exports, "getProviderPreset", { enumerable: true, get: function () { return presets_1.getProviderPreset; } });

package/dist/src/ai-enrichment/providers/mock.d.ts

@@ -0,0 +1,5 @@
+import type { AiProvider, AiProviderRequest, AiProviderResult } from "./types";
+export declare class MockAiProvider implements AiProvider {
+    id: "mock";
+    infer(_request: AiProviderRequest): Promise<AiProviderResult>;
+}

package/dist/src/ai-enrichment/providers/mock.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockAiProvider = void 0;
+class MockAiProvider {
+    constructor() {
+        this.id = "mock";
+    }
+    async infer(_request) {
+        return { proposals: [] };
+    }
+}
+exports.MockAiProvider = MockAiProvider;

package/dist/src/ai-enrichment/providers/platform-proxy-provider.d.ts

@@ -0,0 +1,20 @@
+import type { AiProvider, AiProviderRequest, AiProviderResult } from "./types";
+export type PlatformProxyProviderConfig = {
+    apiBaseUrl: string;
+    workspaceApiKey: string;
+    jobId: string;
+    /** Poll interval for async infer tasks (ms). */
+    pollIntervalMs?: number;
+    /** Max wait for a single infer task (ms). Default from SCAN_AI_HTTP_TIMEOUT_MS or 180000. */
+    pollTimeoutMs?: number;
+};
+export declare class PlatformProxyProvider implements AiProvider {
+    private readonly config;
+    readonly id: "openai";
+    constructor(config: PlatformProxyProviderConfig);
+    private authHeaders;
+    private apiBase;
+    private readErrorMessage;
+    private throwPlatformError;
+    infer(request: AiProviderRequest): Promise<AiProviderResult>;
+}