@modelprofile.com/flexharness-providers 7.0.0

package/dist_ts_openai_auth/smartai.middleware.openai.js

@@ -0,0 +1,47 @@
+const isNonEmptyString = (value) => typeof value === 'string' && value.trim().length > 0;
+const getSystemInstructions = (prompt) => {
+    const instructions = prompt
+        .filter((message) => message.role === 'system')
+        .map((message) => message.content)
+        .filter(isNonEmptyString);
+    return instructions.length > 0 ? instructions.join('\n') : undefined;
+};
+const hasUnsupportedChatGptCacheRetention = (options) => {
+    return options.promptCacheRetention !== undefined || options.prompt_cache_retention !== undefined;
+};
+/**
+ * ChatGPT's Codex backend requires top-level Responses API instructions.
+ * The standard OpenAI provider otherwise serializes system prompts as input items.
+ */
+export function createOpenAiChatGptInstructionsMiddleware() {
+    return {
+        specificationVersion: 'v4',
+        transformParams: async ({ params }) => {
+            const instructions = getSystemInstructions(params.prompt);
+            const providerOptions = params.providerOptions ?? {};
+            const openAiProviderOptions = providerOptions.openai ?? {};
+            const shouldApplyInstructions = !!instructions && !isNonEmptyString(openAiProviderOptions.instructions);
+            const shouldStripCacheRetention = hasUnsupportedChatGptCacheRetention(openAiProviderOptions);
+            if (!shouldApplyInstructions && !shouldStripCacheRetention) {
+                return params;
+            }
+            const nextOpenAiProviderOptions = { ...openAiProviderOptions };
+            delete nextOpenAiProviderOptions.promptCacheRetention;
+            delete nextOpenAiProviderOptions.prompt_cache_retention;
+            if (shouldApplyInstructions) {
+                nextOpenAiProviderOptions.instructions = instructions;
+            }
+            return {
+                ...params,
+                prompt: shouldApplyInstructions
+                    ? params.prompt.filter((message) => message.role !== 'system')
+                    : params.prompt,
+                providerOptions: {
+                    ...providerOptions,
+                    openai: nextOpenAiProviderOptions,
+                },
+            };
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_openai_auth_files/index.d.ts

@@ -0,0 +1,43 @@
+import type { IOpenAiChatGptAuthOptions, IOpenAiChatGptTokenData } from '@modelprofile.com/flexharness-providers/auth';
+export type TOpenAiChatGptAuthSource = 'smartai' | 'opencode' | 'codex';
+export type TOpenAiChatGptAuthFileFormat = TOpenAiChatGptAuthSource | 'auto';
+export interface IOpenAiChatGptAuthSourceConfig {
+    source: TOpenAiChatGptAuthSource;
+    filePath?: string;
+    format?: TOpenAiChatGptAuthFileFormat;
+    writeBack?: boolean;
+}
+export interface IOpenAiChatGptAuthSourceInspection {
+    source: TOpenAiChatGptAuthSource;
+    filePath: string;
+    exists: boolean;
+    usable: boolean;
+    expired?: boolean;
+    accountId?: string;
+    email?: string;
+    plan?: string;
+    expiresAt?: string;
+    error?: string;
+}
+export interface IInspectOpenAiChatGptAuthSourcesOptions {
+    sources?: Array<TOpenAiChatGptAuthSource | IOpenAiChatGptAuthSourceConfig>;
+    homeDir?: string;
+    now?: Date;
+}
+export interface IResolveOpenAiChatGptAuthOptions extends IInspectOpenAiChatGptAuthSourcesOptions {
+    refresh?: 'ifNeeded' | false;
+    writeBack?: Partial<Record<TOpenAiChatGptAuthSource, boolean>>;
+    authOptions?: IOpenAiChatGptAuthOptions;
+}
+export interface IResolvedOpenAiChatGptAuth {
+    source: TOpenAiChatGptAuthSource;
+    filePath: string;
+    tokenData: IOpenAiChatGptTokenData;
+    refreshed: boolean;
+}
+export declare const getDefaultOpenAiChatGptAuthPath: (source: TOpenAiChatGptAuthSource, homeDir?: string) => string;
+export declare const normalizeOpenAiChatGptAuth: (input: unknown, format?: TOpenAiChatGptAuthFileFormat) => IOpenAiChatGptTokenData | undefined;
+export declare const readOpenAiChatGptAuthFile: (filePath: string, format?: TOpenAiChatGptAuthFileFormat) => Promise<IOpenAiChatGptTokenData | undefined>;
+export declare const inspectOpenAiChatGptAuthSources: (options?: IInspectOpenAiChatGptAuthSourcesOptions) => Promise<IOpenAiChatGptAuthSourceInspection[]>;
+export declare const resolveOpenAiChatGptAuth: (options?: IResolveOpenAiChatGptAuthOptions) => Promise<IResolvedOpenAiChatGptAuth | undefined>;
+export declare const writeOpenAiChatGptAuthFile: (filePath: string, tokenData: IOpenAiChatGptTokenData, format?: TOpenAiChatGptAuthFileFormat) => Promise<void>;

package/dist_ts_openai_auth_files/index.js

@@ -0,0 +1,377 @@
+import * as plugins from './plugins.js';
+import { parseOpenAiChatGptTokenInfo, refreshOpenAiChatGptTokenData, } from '@modelprofile.com/flexharness-providers/auth';
+const defaultSources = ['smartai', 'opencode', 'codex'];
+const refreshWindowMs = 5 * 60 * 1000;
+const lockWaitTimeoutMs = 30_000;
+const lockStaleMs = 60_000;
+const maximumAuthFileBytes = 1024 * 1024;
+const inProcessFileLocks = new Map();
+const canonicalizeFilePath = async (filePathArg) => {
+    const resolvedPath = plugins.path.resolve(filePathArg);
+    await plugins.fs.mkdir(plugins.path.dirname(resolvedPath), { recursive: true, mode: 0o700 });
+    try {
+        return await plugins.fs.realpath(resolvedPath);
+    }
+    catch (errorArg) {
+        if (errorArg.code !== 'ENOENT')
+            throw errorArg;
+        const parentPath = await plugins.fs.realpath(plugins.path.dirname(resolvedPath));
+        return plugins.path.join(parentPath, plugins.path.basename(resolvedPath));
+    }
+};
+const acquireCrossProcessFileLock = async (filePathArg) => plugins.properLockfile.lock(filePathArg, {
+    lockfilePath: `${filePathArg}.smartai.lock`,
+    realpath: false,
+    stale: lockStaleMs,
+    update: 10_000,
+    retries: {
+        retries: Math.ceil(lockWaitTimeoutMs / 50),
+        factor: 1,
+        minTimeout: 50,
+        maxTimeout: 50,
+        randomize: false,
+    },
+});
+const withAuthFileLock = async (filePathArg, taskArg) => {
+    const canonicalFilePath = await canonicalizeFilePath(filePathArg);
+    const previous = inProcessFileLocks.get(canonicalFilePath) ?? Promise.resolve();
+    let releaseInProcess;
+    const current = new Promise((resolve) => {
+        releaseInProcess = resolve;
+    });
+    const tail = previous.then(() => current);
+    inProcessFileLocks.set(canonicalFilePath, tail);
+    await previous;
+    try {
+        const releaseCrossProcess = await acquireCrossProcessFileLock(canonicalFilePath);
+        try {
+            return await taskArg(canonicalFilePath);
+        }
+        finally {
+            await releaseCrossProcess();
+        }
+    }
+    finally {
+        releaseInProcess();
+        if (inProcessFileLocks.get(canonicalFilePath) === tail) {
+            inProcessFileLocks.delete(canonicalFilePath);
+        }
+    }
+};
+export const getDefaultOpenAiChatGptAuthPath = (source, homeDir = plugins.os.homedir()) => {
+    switch (source) {
+        case 'smartai':
+            return plugins.path.join(homeDir, '.git.zone', 'ide', 'openai-chatgpt-auth.json');
+        case 'opencode':
+            return plugins.path.join(homeDir, '.local', 'share', 'opencode', 'auth.json');
+        case 'codex':
+            return plugins.path.join(homeDir, '.codex', 'auth.json');
+        default:
+            throw new Error(`Unsupported OpenAI ChatGPT auth source: ${source}`);
+    }
+};
+export const normalizeOpenAiChatGptAuth = (input, format = 'auto') => {
+    if (format === 'auto') {
+        return normalizeOpenAiChatGptAuth(input, 'smartai')
+            ?? normalizeOpenAiChatGptAuth(input, 'opencode')
+            ?? normalizeOpenAiChatGptAuth(input, 'codex');
+    }
+    if (!isRecord(input))
+        return undefined;
+    if (format === 'opencode') {
+        return normalizeOpenCodeAuth(input);
+    }
+    return normalizeTokenObject(isRecord(input.tokens) ? input.tokens : input);
+};
+const readBoundedAuthFileText = async (filePathArg) => {
+    const canonicalFilePath = await plugins.fs.realpath(filePathArg);
+    let handle;
+    try {
+        handle = await plugins.fs.open(canonicalFilePath, plugins.fsConstants.O_RDONLY | plugins.fsConstants.O_NONBLOCK);
+        const stat = await handle.stat();
+        if (!stat.isFile() || stat.size > maximumAuthFileBytes) {
+            throw new Error('Authentication file is not a bounded regular file.');
+        }
+        const bytes = new Uint8Array(maximumAuthFileBytes + 1);
+        let offset = 0;
+        while (offset < bytes.byteLength) {
+            const result = await handle.read(bytes, offset, bytes.byteLength - offset, offset);
+            if (result.bytesRead === 0)
+                break;
+            offset += result.bytesRead;
+        }
+        if (offset > maximumAuthFileBytes) {
+            throw new Error('Authentication file exceeds its size limit.');
+        }
+        return new TextDecoder().decode(bytes.subarray(0, offset));
+    }
+    finally {
+        await handle?.close();
+    }
+};
+const readBoundedAuthJson = async (filePathArg) => JSON.parse(await readBoundedAuthFileText(filePathArg));
+export const readOpenAiChatGptAuthFile = async (filePath, format = 'auto') => {
+    const parsed = await readBoundedAuthJson(filePath);
+    return normalizeOpenAiChatGptAuth(parsed, format);
+};
+export const inspectOpenAiChatGptAuthSources = async (options = {}) => {
+    const now = options.now ?? new Date();
+    const sourceConfigs = normalizeSourceConfigs(options.sources, options.homeDir);
+    return Promise.all(sourceConfigs.map(async (sourceConfig) => {
+        try {
+            const tokenData = await readOpenAiChatGptAuthFile(sourceConfig.filePath, sourceConfig.format ?? sourceConfig.source);
+            if (!tokenData) {
+                return {
+                    source: sourceConfig.source,
+                    filePath: sourceConfig.filePath,
+                    exists: true,
+                    usable: false,
+                    error: 'No OpenAI ChatGPT auth token found in file.',
+                };
+            }
+            return toInspection(sourceConfig.source, sourceConfig.filePath, tokenData, now);
+        }
+        catch (error) {
+            const nodeError = error;
+            return {
+                source: sourceConfig.source,
+                filePath: sourceConfig.filePath,
+                exists: nodeError.code !== 'ENOENT',
+                usable: false,
+                error: nodeError.code === 'ENOENT' ? undefined : 'Authentication file could not be read.',
+            };
+        }
+    }));
+};
+export const resolveOpenAiChatGptAuth = async (options = {}) => {
+    const now = options.now ?? new Date();
+    const sourceConfigs = normalizeSourceConfigs(options.sources, options.homeDir);
+    const refresh = options.refresh ?? 'ifNeeded';
+    for (const sourceConfig of sourceConfigs) {
+        let tokenData;
+        try {
+            tokenData = await readOpenAiChatGptAuthFile(sourceConfig.filePath, sourceConfig.format ?? sourceConfig.source);
+        }
+        catch (error) {
+            const nodeError = error;
+            if (nodeError.code === 'ENOENT')
+                continue;
+            continue;
+        }
+        if (!tokenData)
+            continue;
+        const shouldRefresh = refresh === 'ifNeeded' && shouldRefreshToken(tokenData, now);
+        const writeBack = sourceConfig.writeBack ?? options.writeBack?.[sourceConfig.source] ?? sourceConfig.source === 'smartai';
+        if (writeBack && sourceConfig.format === 'auto') {
+            throw new Error('The auto auth-file format cannot be used for write-back.');
+        }
+        if (!shouldRefresh) {
+            return { source: sourceConfig.source, filePath: sourceConfig.filePath, tokenData, refreshed: false };
+        }
+        if (!writeBack) {
+            if (!isExpired(tokenData, now)) {
+                return { source: sourceConfig.source, filePath: sourceConfig.filePath, tokenData, refreshed: false };
+            }
+            continue;
+        }
+        try {
+            const resolved = await withAuthFileLock(sourceConfig.filePath, async (canonicalFilePath) => {
+                const latestTokenData = await readOpenAiChatGptAuthFile(canonicalFilePath, sourceConfig.format ?? sourceConfig.source);
+                if (!latestTokenData)
+                    return undefined;
+                if (!shouldRefreshToken(latestTokenData, now)) {
+                    return {
+                        source: sourceConfig.source,
+                        filePath: sourceConfig.filePath,
+                        tokenData: latestTokenData,
+                        refreshed: false,
+                    };
+                }
+                const refreshed = await refreshOpenAiChatGptTokenData(latestTokenData, options.authOptions ?? {});
+                await writeOpenAiChatGptAuthFileUnlocked(canonicalFilePath, refreshed, sourceConfig.format ?? sourceConfig.source);
+                return {
+                    source: sourceConfig.source,
+                    filePath: sourceConfig.filePath,
+                    tokenData: refreshed,
+                    refreshed: true,
+                };
+            });
+            if (resolved)
+                return resolved;
+        }
+        catch {
+            continue;
+        }
+    }
+    return undefined;
+};
+export const writeOpenAiChatGptAuthFile = async (filePath, tokenData, format = 'smartai') => {
+    if (format === 'auto')
+        throw new Error('The auto auth-file format cannot be written.');
+    return withAuthFileLock(filePath, async (canonicalFilePath) => {
+        await writeOpenAiChatGptAuthFileUnlocked(canonicalFilePath, tokenData, format);
+    });
+};
+const writeOpenAiChatGptAuthFileUnlocked = async (filePath, tokenData, format) => {
+    const current = await readJsonFileIfExists(filePath);
+    const payload = format === 'opencode'
+        ? toOpenCodeAuthFile(current, tokenData)
+        : format === 'codex'
+            ? toCodexAuthFile(current, tokenData)
+            : toSmartAiAuthFile(tokenData);
+    await writeJsonAtomic(filePath, payload);
+};
+const normalizeSourceConfigs = (sources, homeDir = plugins.os.homedir()) => {
+    return (sources ?? defaultSources).map((sourceInput) => {
+        const sourceConfig = typeof sourceInput === 'string' ? { source: sourceInput } : sourceInput;
+        return {
+            source: sourceConfig.source,
+            filePath: sourceConfig.filePath ?? getDefaultOpenAiChatGptAuthPath(sourceConfig.source, homeDir),
+            format: sourceConfig.format ?? sourceConfig.source,
+            writeBack: sourceConfig.writeBack,
+        };
+    });
+};
+const toInspection = (source, filePath, tokenData, now) => {
+    const expired = isExpired(tokenData, now);
+    return {
+        source,
+        filePath,
+        exists: true,
+        usable: !expired,
+        expired,
+        accountId: tokenData.accountId ?? tokenData.tokenInfo.chatgptAccountId,
+        email: tokenData.tokenInfo.email,
+        plan: tokenData.tokenInfo.chatgptPlanType,
+        expiresAt: tokenData.tokenInfo.expiresAt,
+    };
+};
+const normalizeTokenObject = (input) => {
+    const accessToken = stringValue(input.accessToken) ?? stringValue(input.access_token);
+    const refreshToken = stringValue(input.refreshToken) ?? stringValue(input.refresh_token);
+    const idToken = stringValue(input.idToken) ?? stringValue(input.id_token);
+    const accountId = stringValue(input.accountId) ?? stringValue(input.account_id);
+    return createTokenDataFromValues({ accessToken, refreshToken, idToken, accountId });
+};
+const normalizeOpenCodeAuth = (input) => {
+    if (!isRecord(input.openai))
+        return undefined;
+    const accessToken = stringValue(input.openai.access);
+    const refreshToken = stringValue(input.openai.refresh);
+    const accountId = stringValue(input.openai.accountId);
+    const expiresAt = typeof input.openai.expires === 'number' ? new Date(input.openai.expires).toISOString() : undefined;
+    return createTokenDataFromValues({ accessToken, refreshToken, accountId, fallbackExpiresAt: expiresAt });
+};
+const createTokenDataFromValues = (input) => {
+    if (!input.accessToken || !input.refreshToken)
+        return undefined;
+    const parseToken = input.idToken ?? input.accessToken;
+    const tokenInfo = parseTokenInfo(parseToken, input.accountId, input.fallbackExpiresAt);
+    if (input.accountId !== undefined
+        && tokenInfo.chatgptAccountId !== undefined
+        && input.accountId !== tokenInfo.chatgptAccountId) {
+        return undefined;
+    }
+    const accountId = tokenInfo.chatgptAccountId ?? input.accountId;
+    return {
+        accessToken: input.accessToken,
+        refreshToken: input.refreshToken,
+        idToken: input.idToken,
+        accountId,
+        tokenInfo: { ...tokenInfo, chatgptAccountId: accountId },
+    };
+};
+const parseTokenInfo = (token, accountId, fallbackExpiresAt) => {
+    try {
+        const tokenInfo = parseOpenAiChatGptTokenInfo(token);
+        return {
+            ...tokenInfo,
+            chatgptAccountId: tokenInfo.chatgptAccountId ?? accountId,
+            expiresAt: tokenInfo.expiresAt ?? fallbackExpiresAt,
+        };
+    }
+    catch {
+        return {
+            chatgptAccountId: accountId,
+            chatgptAccountIsFedramp: false,
+            expiresAt: fallbackExpiresAt,
+            rawJwt: token,
+        };
+    }
+};
+const toSmartAiAuthFile = (tokenData) => ({
+    accessToken: tokenData.accessToken,
+    refreshToken: tokenData.refreshToken,
+    idToken: tokenData.idToken,
+    accountId: tokenData.accountId,
+    tokenInfo: tokenData.tokenInfo,
+});
+const toCodexAuthFile = (current, tokenData) => ({
+    ...current,
+    OPENAI_API_KEY: current.OPENAI_API_KEY ?? null,
+    tokens: {
+        ...(isRecord(current.tokens) ? current.tokens : {}),
+        id_token: tokenData.idToken,
+        access_token: tokenData.accessToken,
+        refresh_token: tokenData.refreshToken,
+        account_id: tokenData.accountId ?? tokenData.tokenInfo.chatgptAccountId,
+    },
+    last_refresh: new Date().toISOString(),
+});
+const toOpenCodeAuthFile = (current, tokenData) => ({
+    ...current,
+    openai: {
+        ...(isRecord(current.openai) ? current.openai : {}),
+        type: 'oauth',
+        refresh: tokenData.refreshToken,
+        access: tokenData.accessToken,
+        expires: tokenData.tokenInfo.expiresAt ? Date.parse(tokenData.tokenInfo.expiresAt) : undefined,
+        accountId: tokenData.accountId ?? tokenData.tokenInfo.chatgptAccountId,
+    },
+});
+const shouldRefreshToken = (tokenData, now) => {
+    if (!tokenData.tokenInfo.expiresAt)
+        return false;
+    return Date.parse(tokenData.tokenInfo.expiresAt) - now.getTime() < refreshWindowMs;
+};
+const isExpired = (tokenData, now) => {
+    if (!tokenData.tokenInfo.expiresAt)
+        return false;
+    return Date.parse(tokenData.tokenInfo.expiresAt) <= now.getTime();
+};
+const readJsonFileIfExists = async (filePath) => {
+    try {
+        const parsed = await readBoundedAuthJson(filePath);
+        return isRecord(parsed) ? parsed : {};
+    }
+    catch (error) {
+        const nodeError = error;
+        if (nodeError.code === 'ENOENT')
+            return {};
+        throw error;
+    }
+};
+const writeJsonAtomic = async (filePath, payload) => {
+    const tempPath = `${filePath}.${plugins.crypto.randomUUID()}.tmp`;
+    await plugins.fs.mkdir(plugins.path.dirname(filePath), { recursive: true, mode: 0o700 });
+    try {
+        await plugins.fs.writeFile(tempPath, `${JSON.stringify(payload, undefined, 2)}\n`, {
+            flag: 'wx',
+            mode: 0o600,
+        });
+        await plugins.fs.rename(tempPath, filePath);
+    }
+    finally {
+        await plugins.fs.unlink(tempPath).catch((errorArg) => {
+            if (errorArg.code !== 'ENOENT')
+                throw errorArg;
+        });
+    }
+};
+const isRecord = (value) => {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+};
+const stringValue = (value) => {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts_openai_auth_files/index.ts"],"names":[],"mappings":"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"}

package/dist_ts_openai_auth_files/plugins.d.ts

@@ -0,0 +1,9 @@
+import * as crypto from 'node:crypto';
+import { constants as fsConstants } from 'node:fs';
+import * as fs from 'node:fs/promises';
+import type { FileHandle } from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as properLockfile from 'proper-lockfile';
+export { crypto, fs, fsConstants, os, path, properLockfile };
+export type { FileHandle };

package/dist_ts_openai_auth_files/plugins.js

@@ -0,0 +1,10 @@
+// node native scope
+import * as crypto from 'node:crypto';
+import { constants as fsConstants } from 'node:fs';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+// third-party scope
+import * as properLockfile from 'proper-lockfile';
+export { crypto, fs, fsConstants, os, path, properLockfile };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX29wZW5haV9hdXRoX2ZpbGVzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBQ3RDLE9BQU8sRUFBRSxTQUFTLElBQUksV0FBVyxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQ25ELE9BQU8sS0FBSyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFdkMsT0FBTyxLQUFLLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFDOUIsT0FBTyxLQUFLLElBQUksTUFBTSxXQUFXLENBQUM7QUFFbEMsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxjQUFjLE1BQU0saUJBQWlCLENBQUM7QUFFbEQsT0FBTyxFQUFFLE1BQU0sRUFBRSxFQUFFLEVBQUUsV0FBVyxFQUFFLEVBQUUsRUFBRSxJQUFJLEVBQUUsY0FBYyxFQUFFLENBQUMifQ==

package/dist_ts_providers/anthropic/index.d.ts

@@ -0,0 +1,8 @@
+import * as plugins from './plugins.js';
+import { createAnthropicCachingMiddleware } from './smartai.middleware.anthropic.js';
+export interface IAnthropicModelOptions extends plugins.ISmartAiOptions {
+    provider: 'anthropic';
+    promptCaching?: boolean | plugins.ISmartAiCacheOptions;
+}
+export declare const createAnthropicModelProvider: () => plugins.IModelProvider<IAnthropicModelOptions>;
+export { createAnthropicCachingMiddleware };

package/dist_ts_providers/anthropic/index.js

@@ -0,0 +1,13 @@
+import * as plugins from './plugins.js';
+import { createAnthropicCachingMiddleware } from './smartai.middleware.anthropic.js';
+export const createAnthropicModelProvider = () => ({
+    id: 'anthropic',
+    getModel: (options) => {
+        const model = plugins.createAnthropic({ apiKey: options.apiKey })(options.model);
+        if (options.promptCaching === false)
+            return model;
+        return plugins.wrapLanguageModel({ model, middleware: createAnthropicCachingMiddleware(typeof options.promptCaching === 'object' ? options.promptCaching : undefined) });
+    },
+});
+export { createAnthropicCachingMiddleware };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90c19wcm92aWRlcnMvYW50aHJvcGljL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBQ3hDLE9BQU8sRUFBRSxnQ0FBZ0MsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBT3JGLE1BQU0sQ0FBQyxNQUFNLDRCQUE0QixHQUFHLEdBQW1ELEVBQUUsQ0FBQyxDQUFDO0lBQ2pHLEVBQUUsRUFBRSxXQUFXO0lBQ2YsUUFBUSxFQUFFLENBQUMsT0FBTyxFQUFFLEVBQUU7UUFDcEIsTUFBTSxLQUFLLEdBQUcsT0FBTyxDQUFDLGVBQWUsQ0FBQyxFQUFFLE1BQU0sRUFBRSxPQUFPLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDakYsSUFBSSxPQUFPLENBQUMsYUFBYSxLQUFLLEtBQUs7WUFBRSxPQUFPLEtBQUssQ0FBQztRQUNsRCxPQUFPLE9BQU8sQ0FBQyxpQkFBaUIsQ0FBQyxFQUFFLEtBQUssRUFBRSxVQUFVLEVBQUUsZ0NBQWdDLENBQ3BGLE9BQU8sT0FBTyxDQUFDLGFBQWEsS0FBSyxRQUFRLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxhQUFhLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FDOUUsRUFBRSxDQUFDLENBQUM7SUFDUCxDQUFDO0NBQ0YsQ0FBQyxDQUFDO0FBRUgsT0FBTyxFQUFFLGdDQUFnQyxFQUFFLENBQUMifQ==

package/dist_ts_providers/anthropic/plugins.d.ts

@@ -0,0 +1,4 @@
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { wrapLanguageModel } from 'ai';
+export { createAnthropic, wrapLanguageModel };
+export type { IModelProvider, ISmartAiOptions, ISmartAiCacheOptions } from '@modelprofile.com/flexharness-models';

package/dist_ts_providers/anthropic/plugins.js

@@ -0,0 +1,4 @@
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { wrapLanguageModel } from 'ai';
+export { createAnthropic, wrapLanguageModel };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzX3Byb3ZpZGVycy9hbnRocm9waWMvcGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDcEQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3ZDLE9BQU8sRUFBRSxlQUFlLEVBQUUsaUJBQWlCLEVBQUUsQ0FBQyJ9

package/dist_ts_providers/anthropic/smartai.middleware.anthropic.d.ts

@@ -0,0 +1,8 @@
+import type { LanguageModelV4Middleware } from '@ai-sdk/provider';
+import type { ISmartAiCacheOptions } from '@modelprofile.com/flexharness-models';
+/**
+ * Creates middleware that adds Anthropic prompt caching directives.
+ * Marks the last system message and last user message with ephemeral cache control,
+ * reducing input token cost and latency on repeated calls.
+ */
+export declare function createAnthropicCachingMiddleware(options?: ISmartAiCacheOptions): LanguageModelV4Middleware;

package/dist_ts_providers/anthropic/smartai.middleware.anthropic.js

@@ -0,0 +1,10 @@
+import { createSmartAiCachingMiddleware } from '@modelprofile.com/flexharness-models';
+/**
+ * Creates middleware that adds Anthropic prompt caching directives.
+ * Marks the last system message and last user message with ephemeral cache control,
+ * reducing input token cost and latency on repeated calls.
+ */
+export function createAnthropicCachingMiddleware(options = {}) {
+    return createSmartAiCachingMiddleware({ ...options, provider: 'anthropic' });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRhaS5taWRkbGV3YXJlLmFudGhyb3BpYy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzX3Byb3ZpZGVycy9hbnRocm9waWMvc21hcnRhaS5taWRkbGV3YXJlLmFudGhyb3BpYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsOEJBQThCLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUd0Rjs7OztHQUlHO0FBQ0gsTUFBTSxVQUFVLGdDQUFnQyxDQUFDLFVBQWdDLEVBQUU7SUFDakYsT0FBTyw4QkFBOEIsQ0FBQyxFQUFFLEdBQUcsT0FBTyxFQUFFLFFBQVEsRUFBRSxXQUFXLEVBQUUsQ0FBQyxDQUFDO0FBQy9FLENBQUMifQ==

package/dist_ts_providers/google/index.d.ts

@@ -0,0 +1,5 @@
+import * as plugins from './plugins.js';
+export interface IGoogleModelOptions extends plugins.ISmartAiOptions {
+    provider: 'google';
+}
+export declare const createGoogleModelProvider: () => plugins.IModelProvider<IGoogleModelOptions>;

package/dist_ts_providers/google/index.js

@@ -0,0 +1,6 @@
+import * as plugins from './plugins.js';
+export const createGoogleModelProvider = () => ({
+    id: 'google',
+    getModel: (options) => plugins.createGoogle({ apiKey: options.apiKey })(options.model),
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90c19wcm92aWRlcnMvZ29vZ2xlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBSXhDLE1BQU0sQ0FBQyxNQUFNLHlCQUF5QixHQUFHLEdBQWdELEVBQUUsQ0FBQyxDQUFDO0lBQzNGLEVBQUUsRUFBRSxRQUFRO0lBQ1osUUFBUSxFQUFFLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQyxPQUFPLENBQUMsWUFBWSxDQUFDLEVBQUUsTUFBTSxFQUFFLE9BQU8sQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUM7Q0FDdkYsQ0FBQyxDQUFDIn0=

package/dist_ts_providers/google/plugins.d.ts

@@ -0,0 +1,3 @@
+import { createGoogle } from '@ai-sdk/google';
+export { createGoogle };
+export type { IModelProvider, ISmartAiOptions } from '@modelprofile.com/flexharness-models';

package/dist_ts_providers/google/plugins.js

@@ -0,0 +1,3 @@
+import { createGoogle } from '@ai-sdk/google';
+export { createGoogle };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzX3Byb3ZpZGVycy9nb29nbGUvcGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDOUMsT0FBTyxFQUFFLFlBQVksRUFBRSxDQUFDIn0=

package/dist_ts_providers/groq/index.d.ts

@@ -0,0 +1,5 @@
+import * as plugins from './plugins.js';
+export interface IGroqModelOptions extends plugins.ISmartAiOptions {
+    provider: 'groq';
+}
+export declare const createGroqModelProvider: () => plugins.IModelProvider<IGroqModelOptions>;

package/dist_ts_providers/groq/index.js

@@ -0,0 +1,6 @@
+import * as plugins from './plugins.js';
+export const createGroqModelProvider = () => ({
+    id: 'groq',
+    getModel: (options) => plugins.createGroq({ apiKey: options.apiKey })(options.model),
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90c19wcm92aWRlcnMvZ3JvcS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUl4QyxNQUFNLENBQUMsTUFBTSx1QkFBdUIsR0FBRyxHQUE4QyxFQUFFLENBQUMsQ0FBQztJQUN2RixFQUFFLEVBQUUsTUFBTTtJQUNWLFFBQVEsRUFBRSxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxFQUFFLE1BQU0sRUFBRSxPQUFPLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDO0NBQ3JGLENBQUMsQ0FBQyJ9

package/dist_ts_providers/groq/plugins.d.ts

@@ -0,0 +1,3 @@
+import { createGroq } from '@ai-sdk/groq';
+export { createGroq };
+export type { IModelProvider, ISmartAiOptions } from '@modelprofile.com/flexharness-models';

package/dist_ts_providers/groq/plugins.js

@@ -0,0 +1,3 @@
+import { createGroq } from '@ai-sdk/groq';
+export { createGroq };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzX3Byb3ZpZGVycy9ncm9xL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUMxQyxPQUFPLEVBQUUsVUFBVSxFQUFFLENBQUMifQ==