@push.rocks/smartai 2.0.1 → 2.3.0

package/.smartconfig.json

@@ -11,12 +11,17 @@
       "projectDomain": "push.rocks"
     },
     "release": {
-      "registries": [
-        "https://verdaccio.lossless.digital",
-        "https://registry.npmjs.org"
-      ],
-      "accessLevel": "public"
-    }
+      "targets": {
+        "npm": {
+          "registries": [
+            "https://verdaccio.lossless.digital",
+            "https://registry.npmjs.org"
+          ],
+          "accessLevel": "public"
+        }
+      }
+    },
+    "schemaVersion": 2
   },
   "@git.zone/tsdoc": {
     "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
@@ -24,4 +29,4 @@
   "@ship.zone/szci": {
     "npmGlobalTools": []
   }
-}
+}

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartai',
-    version: '2.0.1',
+    version: '2.3.0',
     description: 'Provider registry and capability utilities for ai-sdk (Vercel AI SDK). Core export returns LanguageModel; subpath exports provide vision, audio, image, document and research capabilities.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxxQkFBcUI7SUFDM0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDZMQUE2TDtDQUMzTSxDQUFBIn0=

package/dist_ts/index.d.ts

@@ -1,6 +1,10 @@
-export { getModel } from './smartai.classes.smartai.js';
-export type { ISmartAiOptions, TProvider, IOllamaModelOptions, LanguageModelV3 } from './smartai.interfaces.js';
+export { getModel, getModelSetup } from './smartai.classes.smartai.js';
+export type { IOpenAiProviderOptions, IOpenAiMaxAuthCredentials, IOpenAiMaxAuthOptions, IOpenAiMaxCompleteDeviceCodeOptions, IOpenAiMaxDeviceCode, IOpenAiMaxDeviceCodePollOptions, IOpenAiMaxIdTokenInfo, IOpenAiMaxTokenData, ISmartAiModelSetup, ISmartAiOptions, TOpenAiReasoningEffort, TOpenAiTextVerbosity, TProvider, TSmartAiProviderOptions, IOllamaModelOptions, LanguageModelV3, LanguageModelV3Prompt, } from './smartai.interfaces.js';
 export { createAnthropicCachingMiddleware } from './smartai.middleware.anthropic.js';
+export { applySmartAiCacheProviderOptions, applySmartAiPromptCaching, createSmartAiCachingMiddleware, getSmartAiCacheProviderOptions, getSmartAiMessageCacheProviderOptions, mergeSmartAiProviderOptions, resolveSmartAiCacheProvider, } from './smartai.cache.js';
+export type { ISmartAiCacheOptions, TSmartAiCacheRetention, TSmartAiCacheSetting, TSmartAiMessageCacheProvider, } from './smartai.cache.js';
 export { createOllamaModel } from './smartai.provider.ollama.js';
+export { OPENAI_MAX_AUTH_ISSUER, OPENAI_MAX_CLIENT_ID, OPENAI_MAX_CODEX_BASE_URL, OPENAI_MAX_DEFAULT_ORIGINATOR, OpenAiMaxAuthError, completeOpenAiMaxDeviceCodeLogin, createOpenAiMaxProviderSettings, ensureOpenAiMaxWorkspaceAllowed, exchangeOpenAiMaxAuthorizationCode, parseOpenAiMaxIdToken, pollOpenAiMaxDeviceCode, refreshOpenAiMaxTokenData, requestOpenAiMaxDeviceCode, } from './smartai.auth.openai.js';
+export type { IOpenAiMaxAuthorizationCode } from './smartai.auth.openai.js';
 export { generateText, streamText, tool, jsonSchema } from 'ai';
 export type { ModelMessage, ToolSet, StreamTextResult } from 'ai';

package/dist_ts/index.js

@@ -1,6 +1,8 @@
-export { getModel } from './smartai.classes.smartai.js';
+export { getModel, getModelSetup } from './smartai.classes.smartai.js';
 export { createAnthropicCachingMiddleware } from './smartai.middleware.anthropic.js';
+export { applySmartAiCacheProviderOptions, applySmartAiPromptCaching, createSmartAiCachingMiddleware, getSmartAiCacheProviderOptions, getSmartAiMessageCacheProviderOptions, mergeSmartAiProviderOptions, resolveSmartAiCacheProvider, } from './smartai.cache.js';
 export { createOllamaModel } from './smartai.provider.ollama.js';
+export { OPENAI_MAX_AUTH_ISSUER, OPENAI_MAX_CLIENT_ID, OPENAI_MAX_CODEX_BASE_URL, OPENAI_MAX_DEFAULT_ORIGINATOR, OpenAiMaxAuthError, completeOpenAiMaxDeviceCodeLogin, createOpenAiMaxProviderSettings, ensureOpenAiMaxWorkspaceAllowed, exchangeOpenAiMaxAuthorizationCode, parseOpenAiMaxIdToken, pollOpenAiMaxDeviceCode, refreshOpenAiMaxTokenData, requestOpenAiMaxDeviceCode, } from './smartai.auth.openai.js';
 // Re-export commonly used ai-sdk functions for consumer convenience
 export { generateText, streamText, tool, jsonSchema } from 'ai';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFeEQsT0FBTyxFQUFFLGdDQUFnQyxFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFDckYsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFakUsb0VBQW9FO0FBQ3BFLE9BQU8sRUFBRSxZQUFZLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRSxVQUFVLEVBQUUsTUFBTSxJQUFJLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLGFBQWEsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBb0J2RSxPQUFPLEVBQUUsZ0NBQWdDLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUNyRixPQUFPLEVBQ0wsZ0NBQWdDLEVBQ2hDLHlCQUF5QixFQUN6Qiw4QkFBOEIsRUFDOUIsOEJBQThCLEVBQzlCLHFDQUFxQyxFQUNyQywyQkFBMkIsRUFDM0IsMkJBQTJCLEdBQzVCLE1BQU0sb0JBQW9CLENBQUM7QUFPNUIsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDakUsT0FBTyxFQUNMLHNCQUFzQixFQUN0QixvQkFBb0IsRUFDcEIseUJBQXlCLEVBQ3pCLDZCQUE2QixFQUM3QixrQkFBa0IsRUFDbEIsZ0NBQWdDLEVBQ2hDLCtCQUErQixFQUMvQiwrQkFBK0IsRUFDL0Isa0NBQWtDLEVBQ2xDLHFCQUFxQixFQUNyQix1QkFBdUIsRUFDdkIseUJBQXlCLEVBQ3pCLDBCQUEwQixHQUMzQixNQUFNLDBCQUEwQixDQUFDO0FBR2xDLG9FQUFvRTtBQUNwRSxPQUFPLEVBQUUsWUFBWSxFQUFFLFVBQVUsRUFBRSxJQUFJLEVBQUUsVUFBVSxFQUFFLE1BQU0sSUFBSSxDQUFDIn0=

package/dist_ts/smartai.auth.openai.d.ts

@@ -0,0 +1,30 @@
+import type { IOpenAiMaxAuthCredentials, IOpenAiMaxAuthOptions, IOpenAiMaxCompleteDeviceCodeOptions, IOpenAiMaxDeviceCode, IOpenAiMaxDeviceCodePollOptions, IOpenAiMaxIdTokenInfo, IOpenAiMaxTokenData } from './smartai.interfaces.js';
+export declare const OPENAI_MAX_AUTH_ISSUER = "https://auth.openai.com";
+export declare const OPENAI_MAX_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+export declare const OPENAI_MAX_CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex";
+export declare const OPENAI_MAX_DEFAULT_ORIGINATOR = "smartai";
+export declare class OpenAiMaxAuthError extends Error {
+    status?: number;
+    body?: string;
+    constructor(message: string, options?: {
+        status?: number;
+        body?: string;
+    });
+}
+export interface IOpenAiMaxAuthorizationCode {
+    authorizationCode: string;
+    codeChallenge: string;
+    codeVerifier: string;
+}
+export declare function parseOpenAiMaxIdToken(idToken: string): IOpenAiMaxIdTokenInfo;
+export declare function requestOpenAiMaxDeviceCode(options?: IOpenAiMaxAuthOptions): Promise<IOpenAiMaxDeviceCode>;
+export declare function pollOpenAiMaxDeviceCode(deviceCode: IOpenAiMaxDeviceCode, options?: IOpenAiMaxDeviceCodePollOptions): Promise<IOpenAiMaxAuthorizationCode>;
+export declare function exchangeOpenAiMaxAuthorizationCode(authorizationCode: IOpenAiMaxAuthorizationCode, options?: IOpenAiMaxAuthOptions): Promise<IOpenAiMaxTokenData>;
+export declare function ensureOpenAiMaxWorkspaceAllowed(tokenData: IOpenAiMaxTokenData, forcedChatGptWorkspaceId?: string): void;
+export declare function completeOpenAiMaxDeviceCodeLogin(deviceCode: IOpenAiMaxDeviceCode, options?: IOpenAiMaxCompleteDeviceCodeOptions): Promise<IOpenAiMaxTokenData>;
+export declare function refreshOpenAiMaxTokenData(tokenData: IOpenAiMaxTokenData, options?: IOpenAiMaxAuthOptions): Promise<IOpenAiMaxTokenData>;
+export declare function createOpenAiMaxProviderSettings(credentials: IOpenAiMaxAuthCredentials): {
+    apiKey: string;
+    baseURL: string;
+    headers: Record<string, string>;
+};

package/dist_ts/smartai.auth.openai.js

@@ -0,0 +1,224 @@
+export const OPENAI_MAX_AUTH_ISSUER = 'https://auth.openai.com';
+export const OPENAI_MAX_CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
+export const OPENAI_MAX_CODEX_BASE_URL = 'https://chatgpt.com/backend-api/codex';
+export const OPENAI_MAX_DEFAULT_ORIGINATOR = 'smartai';
+const DEVICE_CODE_TIMEOUT_MS = 15 * 60 * 1000;
+export class OpenAiMaxAuthError extends Error {
+    constructor(message, options = {}) {
+        super(message);
+        this.name = 'OpenAiMaxAuthError';
+        this.status = options.status;
+        this.body = options.body;
+    }
+}
+function getFetch(options) {
+    const fetchFunction = options.fetch ?? globalThis.fetch;
+    if (!fetchFunction) {
+        throw new OpenAiMaxAuthError('fetch is not available for OpenAI Max authentication.');
+    }
+    return fetchFunction;
+}
+function getIssuer(options) {
+    return (options.issuer ?? OPENAI_MAX_AUTH_ISSUER).replace(/\/+$/, '');
+}
+function getClientId(options) {
+    return options.clientId ?? OPENAI_MAX_CLIENT_ID;
+}
+function asString(value, name) {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new OpenAiMaxAuthError(`OpenAI Max auth response is missing ${name}.`);
+    }
+    return value;
+}
+function asOptionalString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function asIntervalSeconds(value) {
+    const interval = typeof value === 'number' ? value : Number.parseInt(String(value ?? ''), 10);
+    if (!Number.isFinite(interval) || interval <= 0) {
+        throw new OpenAiMaxAuthError('OpenAI Max device-code response has an invalid interval.');
+    }
+    return interval;
+}
+async function readJson(response, context) {
+    const body = await response.text();
+    if (!response.ok) {
+        throw new OpenAiMaxAuthError(`${context} failed with status ${response.status}.`, {
+            status: response.status,
+            body,
+        });
+    }
+    try {
+        return body ? JSON.parse(body) : {};
+    }
+    catch (error) {
+        throw new OpenAiMaxAuthError(`${context} returned invalid JSON: ${error.message}`, {
+            status: response.status,
+            body,
+        });
+    }
+}
+async function postJson(url, body, options) {
+    const response = await getFetch(options)(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    return readJson(response, `POST ${url}`);
+}
+async function postForm(url, body, options) {
+    const response = await getFetch(options)(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: body.toString(),
+    });
+    return readJson(response, `POST ${url}`);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseJwtPayload(jwt) {
+    const parts = jwt.split('.');
+    if (parts.length !== 3 || !parts[1]) {
+        throw new OpenAiMaxAuthError('OpenAI Max auth returned an invalid ID token.');
+    }
+    try {
+        return JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf8'));
+    }
+    catch (error) {
+        throw new OpenAiMaxAuthError(`OpenAI Max ID token could not be parsed: ${error.message}`);
+    }
+}
+export function parseOpenAiMaxIdToken(idToken) {
+    const claims = parseJwtPayload(idToken);
+    const profile = claims['https://api.openai.com/profile'];
+    const auth = claims['https://api.openai.com/auth'];
+    const expiresAtSeconds = typeof claims.exp === 'number' ? claims.exp : undefined;
+    return {
+        email: asOptionalString(claims.email) ?? asOptionalString(profile?.email),
+        chatgptPlanType: asOptionalString(auth?.chatgpt_plan_type),
+        chatgptUserId: asOptionalString(auth?.chatgpt_user_id) ?? asOptionalString(auth?.user_id),
+        chatgptAccountId: asOptionalString(auth?.chatgpt_account_id),
+        chatgptAccountIsFedramp: auth?.chatgpt_account_is_fedramp === true,
+        expiresAt: expiresAtSeconds ? new Date(expiresAtSeconds * 1000).toISOString() : undefined,
+        rawJwt: idToken,
+    };
+}
+function createTokenData(response) {
+    const idToken = asString(response.id_token, 'id_token');
+    const accessToken = asString(response.access_token, 'access_token');
+    const refreshToken = asString(response.refresh_token, 'refresh_token');
+    const idTokenInfo = parseOpenAiMaxIdToken(idToken);
+    return {
+        idToken,
+        accessToken,
+        refreshToken,
+        accountId: idTokenInfo.chatgptAccountId,
+        idTokenInfo,
+    };
+}
+export async function requestOpenAiMaxDeviceCode(options = {}) {
+    const issuer = getIssuer(options);
+    const response = await postJson(`${issuer}/api/accounts/deviceauth/usercode`, {
+        client_id: getClientId(options),
+    }, options);
+    return {
+        verificationUrl: `${issuer}/codex/device`,
+        userCode: asString(response.user_code ?? response.usercode, 'user_code'),
+        deviceAuthId: asString(response.device_auth_id, 'device_auth_id'),
+        intervalSeconds: asIntervalSeconds(response.interval),
+    };
+}
+export async function pollOpenAiMaxDeviceCode(deviceCode, options = {}) {
+    const issuer = getIssuer(options);
+    const pollUrl = `${issuer}/api/accounts/deviceauth/token`;
+    const timeoutMs = options.timeoutMs ?? DEVICE_CODE_TIMEOUT_MS;
+    const sleepFunction = options.sleep ?? sleep;
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        const response = await getFetch(options)(pollUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                device_auth_id: deviceCode.deviceAuthId,
+                user_code: deviceCode.userCode,
+            }),
+        });
+        if (response.ok) {
+            const body = await readJson(response, `POST ${pollUrl}`);
+            return {
+                authorizationCode: asString(body.authorization_code, 'authorization_code'),
+                codeChallenge: asString(body.code_challenge, 'code_challenge'),
+                codeVerifier: asString(body.code_verifier, 'code_verifier'),
+            };
+        }
+        if (response.status !== 403 && response.status !== 404) {
+            const body = await response.text();
+            throw new OpenAiMaxAuthError(`OpenAI Max device-code polling failed with status ${response.status}.`, {
+                status: response.status,
+                body,
+            });
+        }
+        await response.arrayBuffer().catch(() => undefined);
+        const remaining = timeoutMs - (Date.now() - startedAt);
+        await sleepFunction(Math.min(deviceCode.intervalSeconds * 1000, Math.max(remaining, 0)));
+    }
+    throw new OpenAiMaxAuthError('OpenAI Max device-code login timed out.');
+}
+export async function exchangeOpenAiMaxAuthorizationCode(authorizationCode, options = {}) {
+    const issuer = getIssuer(options);
+    const response = await postForm(`${issuer}/oauth/token`, new URLSearchParams({
+        grant_type: 'authorization_code',
+        code: authorizationCode.authorizationCode,
+        redirect_uri: `${issuer}/deviceauth/callback`,
+        client_id: getClientId(options),
+        code_verifier: authorizationCode.codeVerifier,
+    }), options);
+    return createTokenData(response);
+}
+export function ensureOpenAiMaxWorkspaceAllowed(tokenData, forcedChatGptWorkspaceId) {
+    if (!forcedChatGptWorkspaceId) {
+        return;
+    }
+    if (tokenData.idTokenInfo.chatgptAccountId !== forcedChatGptWorkspaceId) {
+        throw new OpenAiMaxAuthError(`OpenAI Max login is restricted to workspace ${forcedChatGptWorkspaceId}.`);
+    }
+}
+export async function completeOpenAiMaxDeviceCodeLogin(deviceCode, options = {}) {
+    const authorizationCode = await pollOpenAiMaxDeviceCode(deviceCode, options);
+    const tokenData = await exchangeOpenAiMaxAuthorizationCode(authorizationCode, options);
+    ensureOpenAiMaxWorkspaceAllowed(tokenData, options.forcedChatGptWorkspaceId);
+    return tokenData;
+}
+export async function refreshOpenAiMaxTokenData(tokenData, options = {}) {
+    const issuer = getIssuer(options);
+    const response = await postJson(`${issuer}/oauth/token`, {
+        client_id: getClientId(options),
+        grant_type: 'refresh_token',
+        refresh_token: tokenData.refreshToken,
+    }, options);
+    return createTokenData({
+        id_token: response.id_token ?? tokenData.idToken,
+        access_token: response.access_token ?? tokenData.accessToken,
+        refresh_token: response.refresh_token ?? tokenData.refreshToken,
+    });
+}
+export function createOpenAiMaxProviderSettings(credentials) {
+    const accountId = credentials.accountId ?? credentials.idTokenInfo?.chatgptAccountId;
+    const isFedrampAccount = credentials.idTokenInfo?.chatgptAccountIsFedramp === true;
+    const headers = {
+        originator: credentials.originator ?? OPENAI_MAX_DEFAULT_ORIGINATOR,
+    };
+    if (accountId) {
+        headers['ChatGPT-Account-ID'] = accountId;
+    }
+    if (isFedrampAccount) {
+        headers['X-OpenAI-Fedramp'] = 'true';
+    }
+    return {
+        apiKey: credentials.accessToken,
+        baseURL: credentials.baseUrl ?? OPENAI_MAX_CODEX_BASE_URL,
+        headers,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartai.auth.openai.js","sourceRoot":"","sources":["../ts/smartai.auth.openai.ts"],"names":[],"mappings":"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"}

package/dist_ts/smartai.cache.d.ts

@@ -0,0 +1,31 @@
+import type { LanguageModelV3Middleware, LanguageModelV3Prompt } from '@ai-sdk/provider';
+import type { TSmartAiProviderOptions } from './smartai.interfaces.js';
+export type TSmartAiMessageCacheProvider = 'anthropic' | 'openrouter' | 'bedrock' | 'openaiCompatible' | 'copilot' | 'alibaba';
+export type TSmartAiCacheRetention = 'ephemeral' | '1h' | 'in_memory' | '24h';
+export interface ISmartAiCacheOptions {
+    /** Provider-specific message cache marker namespace. Usually inferred from the model. */
+    provider?: TSmartAiMessageCacheProvider;
+    /** Stable session/request key for providers that support request-level prompt cache affinity. */
+    key?: string;
+    /** Short retention is the default; longer retention is opt-in. */
+    retention?: TSmartAiCacheRetention;
+}
+export type TSmartAiCacheSetting = boolean | 'auto' | ISmartAiCacheOptions;
+export declare function mergeSmartAiProviderOptions(defaults?: TSmartAiProviderOptions, overrides?: TSmartAiProviderOptions): TSmartAiProviderOptions | undefined;
+export declare function resolveSmartAiCacheProvider(provider?: string, modelId?: string): TSmartAiMessageCacheProvider | undefined;
+export declare function getSmartAiMessageCacheProviderOptions(provider: TSmartAiMessageCacheProvider, options?: ISmartAiCacheOptions): TSmartAiProviderOptions;
+export declare function applySmartAiPromptCaching(prompt: LanguageModelV3Prompt, options?: ISmartAiCacheOptions): LanguageModelV3Prompt;
+export declare function createSmartAiCachingMiddleware(options?: ISmartAiCacheOptions): LanguageModelV3Middleware;
+export declare function getSmartAiCacheProviderOptions(input: {
+    provider?: string;
+    modelId?: string;
+    cache?: TSmartAiCacheSetting;
+    sessionId?: string;
+}): TSmartAiProviderOptions | undefined;
+export declare function applySmartAiCacheProviderOptions(input: {
+    provider?: string;
+    modelId?: string;
+    providerOptions?: TSmartAiProviderOptions;
+    cache?: TSmartAiCacheSetting;
+    sessionId?: string;
+}): TSmartAiProviderOptions | undefined;

package/dist_ts/smartai.cache.js

@@ -0,0 +1,179 @@
+function isObject(input) {
+    return typeof input === 'object' && input !== null && !Array.isArray(input);
+}
+function mergeJsonDefaults(defaults, overrides) {
+    const result = { ...defaults };
+    if (!overrides)
+        return result;
+    for (const [key, value] of Object.entries(overrides)) {
+        const existing = result[key];
+        if (isObject(existing) && isObject(value)) {
+            result[key] = mergeJsonDefaults(existing, value);
+            continue;
+        }
+        result[key] = value;
+    }
+    return result;
+}
+export function mergeSmartAiProviderOptions(defaults, overrides) {
+    if (!defaults)
+        return overrides;
+    if (!overrides)
+        return defaults;
+    return mergeJsonDefaults(defaults, overrides);
+}
+function cacheOptionsFromSetting(cache) {
+    if (cache === false)
+        return undefined;
+    if (cache === undefined || cache === true || cache === 'auto')
+        return {};
+    return cache;
+}
+export function resolveSmartAiCacheProvider(provider, modelId) {
+    const providerLower = provider?.toLowerCase() ?? '';
+    const modelLower = modelId?.toLowerCase() ?? '';
+    if (providerLower.includes('openrouter'))
+        return 'openrouter';
+    if (providerLower.includes('bedrock'))
+        return 'bedrock';
+    if (providerLower.includes('copilot'))
+        return 'copilot';
+    if (providerLower.includes('alibaba'))
+        return 'alibaba';
+    if (providerLower.includes('openai-compatible') || providerLower.includes('openaicompatible')) {
+        return 'openaiCompatible';
+    }
+    if (providerLower.includes('anthropic'))
+        return 'anthropic';
+    if (modelLower.includes('claude') || modelLower.includes('anthropic'))
+        return 'anthropic';
+    return undefined;
+}
+export function getSmartAiMessageCacheProviderOptions(provider, options = {}) {
+    const anthropicCacheControl = {
+        type: 'ephemeral',
+        ...(options.retention === '1h' ? { ttl: '1h' } : {}),
+    };
+    const providerOptions = {
+        anthropic: {
+            anthropic: {
+                cacheControl: anthropicCacheControl,
+            },
+        },
+        openrouter: {
+            openrouter: {
+                cacheControl: { type: 'ephemeral' },
+            },
+        },
+        bedrock: {
+            bedrock: {
+                cachePoint: { type: 'default' },
+            },
+        },
+        openaiCompatible: {
+            openaiCompatible: {
+                cache_control: { type: 'ephemeral' },
+            },
+        },
+        copilot: {
+            copilot: {
+                copilot_cache_control: { type: 'ephemeral' },
+            },
+        },
+        alibaba: {
+            alibaba: {
+                cacheControl: { type: 'ephemeral' },
+            },
+        },
+    };
+    return providerOptions[provider];
+}
+function shouldUseMessageLevelOptions(provider) {
+    return provider === 'anthropic' || provider === 'bedrock';
+}
+function applyProviderOptionsDefaults(item, defaults) {
+    return {
+        ...item,
+        providerOptions: mergeSmartAiProviderOptions(defaults, item.providerOptions),
+    };
+}
+function isToolApprovalPart(part) {
+    if (!isObject(part))
+        return false;
+    return part.type === 'tool-approval-request' || part.type === 'tool-approval-response';
+}
+function applyCacheToMessage(message, provider, options) {
+    const providerOptions = getSmartAiMessageCacheProviderOptions(provider, options);
+    const content = message.content;
+    if (!shouldUseMessageLevelOptions(provider) && Array.isArray(content) && content.length > 0) {
+        const lastIndex = content.length - 1;
+        const lastPart = content[lastIndex];
+        if (!isToolApprovalPart(lastPart)) {
+            const messageWithArrayContent = message;
+            return {
+                ...messageWithArrayContent,
+                content: content.map((part, index) => index === lastIndex ? applyProviderOptionsDefaults(part, providerOptions) : part),
+            };
+        }
+    }
+    return applyProviderOptionsDefaults(message, providerOptions);
+}
+export function applySmartAiPromptCaching(prompt, options = {}) {
+    const provider = options.provider ?? 'anthropic';
+    const targetIndexes = new Set();
+    const nonSystemIndexes = [];
+    let systemCount = 0;
+    for (let i = 0; i < prompt.length; i++) {
+        const message = prompt[i];
+        if (message.role === 'system') {
+            if (systemCount < 2)
+                targetIndexes.add(i);
+            systemCount++;
+            continue;
+        }
+        nonSystemIndexes.push(i);
+    }
+    for (const index of nonSystemIndexes.slice(-2)) {
+        targetIndexes.add(index);
+    }
+    if (targetIndexes.size === 0)
+        return prompt;
+    return prompt.map((message, index) => targetIndexes.has(index) ? applyCacheToMessage(message, provider, options) : message);
+}
+export function createSmartAiCachingMiddleware(options = {}) {
+    return {
+        specificationVersion: 'v3',
+        transformParams: async ({ params }) => ({
+            ...params,
+            prompt: applySmartAiPromptCaching(params.prompt, options),
+        }),
+    };
+}
+function isOpenAiProvider(provider) {
+    const providerLower = provider?.toLowerCase() ?? '';
+    return providerLower === 'openai' || providerLower.startsWith('openai.') || providerLower.includes('@ai-sdk/openai');
+}
+export function getSmartAiCacheProviderOptions(input) {
+    const cacheOptions = cacheOptionsFromSetting(input.cache);
+    if (!cacheOptions)
+        return undefined;
+    if (isOpenAiProvider(input.provider)) {
+        const key = cacheOptions.key ?? input.sessionId;
+        return {
+            openai: {
+                store: false,
+                ...(key ? { promptCacheKey: key } : {}),
+                ...(cacheOptions.retention === '24h' || cacheOptions.retention === 'in_memory'
+                    ? { promptCacheRetention: cacheOptions.retention }
+                    : key
+                        ? { promptCacheRetention: 'in_memory' }
+                        : {}),
+            },
+        };
+    }
+    return undefined;
+}
+export function applySmartAiCacheProviderOptions(input) {
+    return mergeSmartAiProviderOptions(getSmartAiCacheProviderOptions(input), input.providerOptions);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smartai.classes.smartai.d.ts

@@ -1,7 +1,11 @@
-import type { ISmartAiOptions, LanguageModelV3 } from './smartai.interfaces.js';
+import type { ISmartAiModelSetup, ISmartAiOptions, LanguageModelV3 } from './smartai.interfaces.js';
 /**
  * Returns a LanguageModelV3 for the given provider and model.
  * This is the primary API — consumers use the returned model with AI SDK's
  * generateText(), streamText(), etc.
  */
 export declare function getModel(options: ISmartAiOptions): LanguageModelV3;
+/**
+ * Returns the model plus request-time providerOptions for AI SDK calls.
+ */
+export declare function getModelSetup(options: ISmartAiOptions): ISmartAiModelSetup;

package/dist_ts/smartai.classes.smartai.js

@@ -1,6 +1,7 @@
 import * as plugins from './plugins.js';
 import { createOllamaModel } from './smartai.provider.ollama.js';
 import { createAnthropicCachingMiddleware } from './smartai.middleware.anthropic.js';
+import { createOpenAiMaxProviderSettings } from './smartai.auth.openai.js';
 /**
  * Returns a LanguageModelV3 for the given provider and model.
  * This is the primary API — consumers use the returned model with AI SDK's
@@ -15,11 +16,13 @@ export function getModel(options) {
                 return base;
             return plugins.wrapLanguageModel({
                 model: base,
-                middleware: createAnthropicCachingMiddleware(),
+                middleware: createAnthropicCachingMiddleware(typeof options.promptCaching === 'object' ? options.promptCaching : undefined),
             });
         }
         case 'openai': {
-            const p = plugins.createOpenAI({ apiKey: options.apiKey });
+            const p = plugins.createOpenAI(options.openAiMaxAuth
+                ? createOpenAiMaxProviderSettings(options.openAiMaxAuth)
+                : { apiKey: options.apiKey });
             return p(options.model);
         }
         case 'google': {
@@ -48,4 +51,11 @@ export function getModel(options) {
             throw new Error(`Unknown provider: ${options.provider}`);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Returns the model plus request-time providerOptions for AI SDK calls.
+ */
+export function getModelSetup(options) {
+    const model = getModel(options);
+    return options.providerOptions ? { model, providerOptions: options.providerOptions } : { model };
+}
+//# sourceMappingURL=data:application/json;base64,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