@modelprofile.com/flexharness-providers 7.0.0

package/dist_ts_media_openai/image.d.ts

@@ -0,0 +1,46 @@
+export interface IImageGenerateOptions {
+    apiKey: string;
+    prompt: string;
+    model?: 'gpt-image-1' | 'dall-e-3' | 'dall-e-2';
+    quality?: 'low' | 'medium' | 'high' | 'standard' | 'hd' | 'auto';
+    size?: '256x256' | '512x512' | '1024x1024' | '1536x1024' | '1024x1536' | '1792x1024' | '1024x1792' | 'auto';
+    style?: 'vivid' | 'natural';
+    background?: 'transparent' | 'opaque' | 'auto';
+    outputFormat?: 'png' | 'jpeg' | 'webp';
+    outputCompression?: number;
+    moderation?: 'low' | 'auto';
+    n?: number;
+    stream?: boolean;
+    partialImages?: number;
+}
+export interface IImageEditOptions {
+    apiKey: string;
+    image: Buffer;
+    prompt: string;
+    mask?: Buffer;
+    model?: 'gpt-image-1' | 'dall-e-2';
+    quality?: 'low' | 'medium' | 'high' | 'standard' | 'auto';
+    size?: '256x256' | '512x512' | '1024x1024' | '1536x1024' | '1024x1536' | 'auto';
+    background?: 'transparent' | 'opaque' | 'auto';
+    outputFormat?: 'png' | 'jpeg' | 'webp';
+    outputCompression?: number;
+    n?: number;
+    stream?: boolean;
+    partialImages?: number;
+}
+export interface IImageResponse {
+    images: Array<{
+        b64_json?: string;
+        url?: string;
+        revisedPrompt?: string;
+    }>;
+    metadata?: {
+        model: string;
+        quality?: string;
+        size?: string;
+        outputFormat?: string;
+        tokensUsed?: number;
+    };
+}
+export declare function generateImage(options: IImageGenerateOptions): Promise<IImageResponse>;
+export declare function editImage(options: IImageEditOptions): Promise<IImageResponse>;

package/dist_ts_media_openai/image.js

@@ -0,0 +1,110 @@
+import * as plugins from './plugins.js';
+export async function generateImage(options) {
+    const client = new plugins.OpenAI({ apiKey: options.apiKey });
+    const model = options.model || 'gpt-image-1';
+    const requestParams = {
+        model,
+        prompt: options.prompt,
+        n: options.n || 1,
+    };
+    if (model === 'gpt-image-1') {
+        if (options.quality)
+            requestParams.quality = options.quality;
+        if (options.size)
+            requestParams.size = options.size;
+        if (options.background)
+            requestParams.background = options.background;
+        if (options.outputFormat)
+            requestParams.output_format = options.outputFormat;
+        if (options.outputCompression !== undefined)
+            requestParams.output_compression = options.outputCompression;
+        if (options.moderation)
+            requestParams.moderation = options.moderation;
+        if (options.stream !== undefined)
+            requestParams.stream = options.stream;
+        if (options.partialImages !== undefined)
+            requestParams.partial_images = options.partialImages;
+    }
+    else if (model === 'dall-e-3') {
+        if (options.quality)
+            requestParams.quality = options.quality;
+        if (options.size)
+            requestParams.size = options.size;
+        if (options.style)
+            requestParams.style = options.style;
+        requestParams.response_format = 'b64_json';
+    }
+    else if (model === 'dall-e-2') {
+        if (options.size)
+            requestParams.size = options.size;
+        requestParams.response_format = 'b64_json';
+    }
+    const result = await client.images.generate(requestParams);
+    const images = (result.data || []).map((img) => ({
+        b64_json: img.b64_json,
+        url: img.url,
+        revisedPrompt: img.revised_prompt,
+    }));
+    return {
+        images,
+        metadata: {
+            model,
+            quality: result.quality,
+            size: result.size,
+            outputFormat: result.output_format,
+            tokensUsed: result.usage?.total_tokens,
+        },
+    };
+}
+export async function editImage(options) {
+    const client = new plugins.OpenAI({ apiKey: options.apiKey });
+    const model = options.model || 'gpt-image-1';
+    const imageFile = await plugins.toFile(options.image, 'image.png', { type: 'image/png' });
+    const requestParams = {
+        model,
+        image: imageFile,
+        prompt: options.prompt,
+        n: options.n || 1,
+    };
+    if (options.mask) {
+        requestParams.mask = await plugins.toFile(options.mask, 'mask.png', { type: 'image/png' });
+    }
+    if (model === 'gpt-image-1') {
+        if (options.quality)
+            requestParams.quality = options.quality;
+        if (options.size)
+            requestParams.size = options.size;
+        if (options.background)
+            requestParams.background = options.background;
+        if (options.outputFormat)
+            requestParams.output_format = options.outputFormat;
+        if (options.outputCompression !== undefined)
+            requestParams.output_compression = options.outputCompression;
+        if (options.stream !== undefined)
+            requestParams.stream = options.stream;
+        if (options.partialImages !== undefined)
+            requestParams.partial_images = options.partialImages;
+    }
+    else if (model === 'dall-e-2') {
+        if (options.size)
+            requestParams.size = options.size;
+        requestParams.response_format = 'b64_json';
+    }
+    const result = await client.images.edit(requestParams);
+    const images = (result.data || []).map((img) => ({
+        b64_json: img.b64_json,
+        url: img.url,
+        revisedPrompt: img.revised_prompt,
+    }));
+    return {
+        images,
+        metadata: {
+            model,
+            quality: result.quality,
+            size: result.size,
+            outputFormat: result.output_format,
+            tokensUsed: result.usage?.total_tokens,
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_media_openai/index.d.ts

@@ -0,0 +1,10 @@
+export interface IOpenAiTtsOptions {
+    apiKey: string;
+    text: string;
+    voice?: 'alloy' | 'echo' | 'fable' | 'onyx' | 'nova' | 'shimmer';
+    model?: 'tts-1' | 'tts-1-hd';
+    responseFormat?: 'mp3' | 'opus' | 'aac' | 'flac';
+    speed?: number;
+}
+export declare function textToSpeech(options: IOpenAiTtsOptions): Promise<NodeJS.ReadableStream>;
+export * from './image.js';

package/dist_ts_media_openai/index.js

@@ -0,0 +1,16 @@
+import * as plugins from './plugins.js';
+import { Readable } from 'node:stream';
+export async function textToSpeech(options) {
+    const client = new plugins.OpenAI({ apiKey: options.apiKey });
+    const result = await client.audio.speech.create({
+        model: options.model ?? 'tts-1',
+        voice: options.voice ?? 'alloy',
+        input: options.text,
+        response_format: options.responseFormat ?? 'mp3',
+        speed: options.speed ?? 1,
+    });
+    const stream = result.body;
+    return Readable.fromWeb(stream);
+}
+export * from './image.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19tZWRpYV9vcGVuYWkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxjQUFjLENBQUM7QUFDeEMsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQVd2QyxNQUFNLENBQUMsS0FBSyxVQUFVLFlBQVksQ0FBQyxPQUEwQjtJQUMzRCxNQUFNLE1BQU0sR0FBRyxJQUFJLE9BQU8sQ0FBQyxNQUFNLENBQUMsRUFBRSxNQUFNLEVBQUUsT0FBTyxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQUM7SUFDOUQsTUFBTSxNQUFNLEdBQUcsTUFBTSxNQUFNLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUM7UUFDOUMsS0FBSyxFQUFFLE9BQU8sQ0FBQyxLQUFLLElBQUksT0FBTztRQUMvQixLQUFLLEVBQUUsT0FBTyxDQUFDLEtBQUssSUFBSSxPQUFPO1FBQy9CLEtBQUssRUFBRSxPQUFPLENBQUMsSUFBSTtRQUNuQixlQUFlLEVBQUUsT0FBTyxDQUFDLGNBQWMsSUFBSSxLQUFLO1FBQ2hELEtBQUssRUFBRSxPQUFPLENBQUMsS0FBSyxJQUFJLENBQUM7S0FDMUIsQ0FBQyxDQUFDO0lBQ0gsTUFBTSxNQUFNLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQztJQUMzQixPQUFPLFFBQVEsQ0FBQyxPQUFPLENBQUMsTUFBYSxDQUFDLENBQUM7QUFDekMsQ0FBQztBQUVELGNBQWMsWUFBWSxDQUFDIn0=

package/dist_ts_media_openai/plugins.d.ts

@@ -0,0 +1,3 @@
+import OpenAI from 'openai';
+import { toFile } from 'openai';
+export { OpenAI, toFile };

package/dist_ts_media_openai/plugins.js

@@ -0,0 +1,4 @@
+import OpenAI from 'openai';
+import { toFile } from 'openai';
+export { OpenAI, toFile };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX21lZGlhX29wZW5haS9wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sTUFBTSxNQUFNLFFBQVEsQ0FBQztBQUM1QixPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sUUFBUSxDQUFDO0FBQ2hDLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLENBQUMifQ==

package/dist_ts_openai_account/index.d.ts

@@ -0,0 +1,6 @@
+export * from './smartai.providers.interfaces.js';
+export * from './smartai.providers.error.js';
+export * from './smartai.providers.credentials.js';
+export * from './smartai.providers.openai.js';
+export * from './smartai.providers.registry.js';
+export { OPENAI_CHATGPT_AUTH_ISSUER, OPENAI_CHATGPT_CLIENT_ID, OPENAI_CHATGPT_CODEX_BASE_URL, OPENAI_CHATGPT_DEFAULT_ORIGINATOR, } from '@modelprofile.com/flexharness-providers/auth';

package/dist_ts_openai_account/index.js

@@ -0,0 +1,7 @@
+export * from './smartai.providers.interfaces.js';
+export * from './smartai.providers.error.js';
+export * from './smartai.providers.credentials.js';
+export * from './smartai.providers.openai.js';
+export * from './smartai.providers.registry.js';
+export { OPENAI_CHATGPT_AUTH_ISSUER, OPENAI_CHATGPT_CLIENT_ID, OPENAI_CHATGPT_CODEX_BASE_URL, OPENAI_CHATGPT_DEFAULT_ORIGINATOR, } from '@modelprofile.com/flexharness-providers/auth';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19vcGVuYWlfYWNjb3VudC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyxvQ0FBb0MsQ0FBQztBQUNuRCxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsT0FBTyxFQUNMLDBCQUEwQixFQUMxQix3QkFBd0IsRUFDeEIsNkJBQTZCLEVBQzdCLGlDQUFpQyxHQUNsQyxNQUFNLDhDQUE4QyxDQUFDIn0=

package/dist_ts_openai_account/plugins.d.ts

@@ -0,0 +1,7 @@
+import * as crypto from 'node:crypto';
+import * as http from 'node:http';
+import { Buffer } from 'node:buffer';
+import type { Server } from 'node:http';
+import type { Socket } from 'node:net';
+export { Buffer, crypto, http };
+export type { Server, Socket };

package/dist_ts_openai_account/plugins.js

@@ -0,0 +1,6 @@
+// node native scope
+import * as crypto from 'node:crypto';
+import * as http from 'node:http';
+import { Buffer } from 'node:buffer';
+export { Buffer, crypto, http };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX29wZW5haV9hY2NvdW50L3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBQ3RDLE9BQU8sS0FBSyxJQUFJLE1BQU0sV0FBVyxDQUFDO0FBQ2xDLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFJckMsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLENBQUMifQ==

package/dist_ts_openai_account/smartai.providers.credentials.d.ts

@@ -0,0 +1,7 @@
+import type { IOpenAiChatGptAuthCredentials } from '@modelprofile.com/flexharness-providers/auth';
+import type { IOpenAiChatGptOAuthCredential, TSmartAiProviderCredential } from './smartai.providers.interfaces.js';
+export declare const providerCredentialEnvelopeVersion: 1;
+export declare const providerCredentialEnvelopeMaxBytes = 16384;
+export declare const serializeProviderCredential: (credentialArg: TSmartAiProviderCredential) => Uint8Array;
+export declare const parseProviderCredential: (envelopeBytesArg: Uint8Array) => TSmartAiProviderCredential;
+export declare const toOpenAiChatGptAuthCredentials: (credentialArg: IOpenAiChatGptOAuthCredential) => IOpenAiChatGptAuthCredentials;

package/dist_ts_openai_account/smartai.providers.credentials.js

@@ -0,0 +1,126 @@
+import * as plugins from './plugins.js';
+import { parseOpenAiChatGptTokenInfo } from '@modelprofile.com/flexharness-providers/auth';
+import { createSmartAiProviderError } from './smartai.providers.error.js';
+export const providerCredentialEnvelopeVersion = 1;
+export const providerCredentialEnvelopeMaxBytes = 16_384;
+const isPlainObject = (valueArg) => typeof valueArg === 'object'
+    && valueArg !== null
+    && !Array.isArray(valueArg)
+    && (Object.getPrototypeOf(valueArg) === Object.prototype
+        || Object.getPrototypeOf(valueArg) === null);
+const hasExactKeys = (valueArg, keysArg) => {
+    const keys = Object.keys(valueArg);
+    return keys.length === keysArg.length && keysArg.every((key) => Object.hasOwn(valueArg, key));
+};
+const boundedString = (valueArg, maximumBytesArg) => typeof valueArg === 'string'
+    && valueArg.length > 0
+    && plugins.Buffer.byteLength(valueArg, 'utf8') <= maximumBytesArg;
+const parseOAuthCredential = (valueArg) => {
+    const required = [
+        'kind',
+        'providerId',
+        'accessToken',
+        'refreshToken',
+        'idToken',
+    ];
+    const optional = ['lastRefreshAt'];
+    const keys = Object.keys(valueArg);
+    if (!required.every((key) => Object.hasOwn(valueArg, key))
+        || keys.some((key) => !required.includes(key) && !optional.includes(key))
+        || valueArg.kind !== 'chatgptOAuth'
+        || valueArg.providerId !== 'openai'
+        || !boundedString(valueArg.accessToken, providerCredentialEnvelopeMaxBytes)
+        || !boundedString(valueArg.refreshToken, providerCredentialEnvelopeMaxBytes)
+        || !boundedString(valueArg.idToken, providerCredentialEnvelopeMaxBytes)
+        || (valueArg.lastRefreshAt !== undefined
+            && (!boundedString(valueArg.lastRefreshAt, 128)
+                || !Number.isFinite(Date.parse(valueArg.lastRefreshAt))))) {
+        throw createSmartAiProviderError('CREDENTIAL_INVALID');
+    }
+    try {
+        parseOpenAiChatGptTokenInfo(valueArg.idToken);
+    }
+    catch {
+        throw createSmartAiProviderError('CREDENTIAL_INVALID');
+    }
+    return {
+        kind: 'chatgptOAuth',
+        providerId: 'openai',
+        accessToken: valueArg.accessToken,
+        refreshToken: valueArg.refreshToken,
+        idToken: valueArg.idToken,
+        ...(typeof valueArg.lastRefreshAt === 'string'
+            ? { lastRefreshAt: valueArg.lastRefreshAt }
+            : {}),
+    };
+};
+const parseCredential = (valueArg) => {
+    if (!isPlainObject(valueArg))
+        throw createSmartAiProviderError('CREDENTIAL_INVALID');
+    if (valueArg.kind === 'apiKey') {
+        if (!hasExactKeys(valueArg, ['kind', 'providerId', 'apiKey'])
+            || !boundedString(valueArg.providerId, 256)
+            || !boundedString(valueArg.apiKey, providerCredentialEnvelopeMaxBytes)) {
+            throw createSmartAiProviderError('CREDENTIAL_INVALID');
+        }
+        return { kind: 'apiKey', providerId: valueArg.providerId, apiKey: valueArg.apiKey };
+    }
+    return parseOAuthCredential(valueArg);
+};
+export const serializeProviderCredential = (credentialArg) => {
+    const credential = parseCredential(credentialArg);
+    const envelope = {
+        schemaVersion: providerCredentialEnvelopeVersion,
+        credential,
+    };
+    const bytes = plugins.Buffer.from(JSON.stringify(envelope), 'utf8');
+    if (bytes.byteLength > providerCredentialEnvelopeMaxBytes) {
+        bytes.fill(0);
+        throw createSmartAiProviderError('CREDENTIAL_INVALID');
+    }
+    return Uint8Array.from(bytes);
+};
+export const parseProviderCredential = (envelopeBytesArg) => {
+    if (!(envelopeBytesArg instanceof Uint8Array)
+        || envelopeBytesArg.byteLength < 1
+        || envelopeBytesArg.byteLength > providerCredentialEnvelopeMaxBytes) {
+        throw createSmartAiProviderError('CREDENTIAL_INVALID');
+    }
+    const copiedBytes = plugins.Buffer.from(envelopeBytesArg);
+    let parsed;
+    try {
+        parsed = JSON.parse(copiedBytes.toString('utf8'));
+    }
+    catch {
+        throw createSmartAiProviderError('CREDENTIAL_INVALID');
+    }
+    finally {
+        copiedBytes.fill(0);
+    }
+    if (!isPlainObject(parsed)
+        || !hasExactKeys(parsed, ['schemaVersion', 'credential'])
+        || parsed.schemaVersion !== providerCredentialEnvelopeVersion) {
+        throw createSmartAiProviderError('CREDENTIAL_INVALID');
+    }
+    return parseCredential(parsed.credential);
+};
+export const toOpenAiChatGptAuthCredentials = (credentialArg) => {
+    const credential = parseOAuthCredential(credentialArg);
+    let tokenInfo;
+    try {
+        tokenInfo = parseOpenAiChatGptTokenInfo(credential.idToken);
+    }
+    catch {
+        throw createSmartAiProviderError('CREDENTIAL_INVALID');
+    }
+    return {
+        accessToken: credential.accessToken,
+        refreshToken: credential.refreshToken,
+        idToken: credential.idToken,
+        ...(tokenInfo.chatgptAccountId ? { accountId: tokenInfo.chatgptAccountId } : {}),
+        tokenInfo: {
+            ...tokenInfo,
+        },
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_openai_account/smartai.providers.error.d.ts

@@ -0,0 +1,11 @@
+export type TSmartAiProviderErrorCode = 'ABORTED' | 'CLOSED' | 'CREDENTIAL_INVALID' | 'INVALID_ARGUMENT' | 'LOGIN_BUSY' | 'LOGIN_CANCELED' | 'LOGIN_FAILED' | 'MODEL_LIST_FAILED' | 'NETWORK_FAILED' | 'PROTOCOL_ERROR' | 'REFRESH_FAILED' | 'TIMEOUT';
+export declare class SmartAiProviderError extends Error {
+    readonly code: TSmartAiProviderErrorCode;
+    constructor(codeArg: TSmartAiProviderErrorCode);
+    toJSON(): {
+        name: string;
+        code: TSmartAiProviderErrorCode;
+        message: string;
+    };
+}
+export declare const createSmartAiProviderError: (codeArg: TSmartAiProviderErrorCode) => SmartAiProviderError;

package/dist_ts_openai_account/smartai.providers.error.js

@@ -0,0 +1,30 @@
+const codes = new Set([
+    'ABORTED',
+    'CLOSED',
+    'CREDENTIAL_INVALID',
+    'INVALID_ARGUMENT',
+    'LOGIN_BUSY',
+    'LOGIN_CANCELED',
+    'LOGIN_FAILED',
+    'MODEL_LIST_FAILED',
+    'NETWORK_FAILED',
+    'PROTOCOL_ERROR',
+    'REFRESH_FAILED',
+    'TIMEOUT',
+]);
+export class SmartAiProviderError extends Error {
+    code;
+    constructor(codeArg) {
+        const code = codes.has(codeArg) ? codeArg : 'PROTOCOL_ERROR';
+        super(`SmartAI provider operation failed (${code}).`);
+        this.name = 'SmartAiProviderError';
+        this.code = code;
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.stack = `${this.name}: ${this.message}`;
+    }
+    toJSON() {
+        return { name: this.name, code: this.code, message: this.message };
+    }
+}
+export const createSmartAiProviderError = (codeArg) => new SmartAiProviderError(codeArg);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRhaS5wcm92aWRlcnMuZXJyb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19vcGVuYWlfYWNjb3VudC9zbWFydGFpLnByb3ZpZGVycy5lcnJvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFjQSxNQUFNLEtBQUssR0FBRyxJQUFJLEdBQUcsQ0FBNEI7SUFDL0MsU0FBUztJQUNULFFBQVE7SUFDUixvQkFBb0I7SUFDcEIsa0JBQWtCO0lBQ2xCLFlBQVk7SUFDWixnQkFBZ0I7SUFDaEIsY0FBYztJQUNkLG1CQUFtQjtJQUNuQixnQkFBZ0I7SUFDaEIsZ0JBQWdCO0lBQ2hCLGdCQUFnQjtJQUNoQixTQUFTO0NBQ1YsQ0FBQyxDQUFDO0FBRUgsTUFBTSxPQUFPLG9CQUFxQixTQUFRLEtBQUs7SUFDN0IsSUFBSSxDQUE0QjtJQUVoRCxZQUFZLE9BQWtDO1FBQzVDLE1BQU0sSUFBSSxHQUFHLEtBQUssQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsZ0JBQWdCLENBQUM7UUFDN0QsS0FBSyxDQUFDLHNDQUFzQyxJQUFJLElBQUksQ0FBQyxDQUFDO1FBQ3RELElBQUksQ0FBQyxJQUFJLEdBQUcsc0JBQXNCLENBQUM7UUFDbkMsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUM7UUFDakIsTUFBTSxDQUFDLGNBQWMsQ0FBQyxJQUFJLEVBQUUsR0FBRyxDQUFDLE1BQU0sQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUNsRCxJQUFJLENBQUMsS0FBSyxHQUFHLEdBQUcsSUFBSSxDQUFDLElBQUksS0FBSyxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7SUFDL0MsQ0FBQztJQUVNLE1BQU07UUFDWCxPQUFPLEVBQUUsSUFBSSxFQUFFLElBQUksQ0FBQyxJQUFJLEVBQUUsSUFBSSxFQUFFLElBQUksQ0FBQyxJQUFJLEVBQUUsT0FBTyxFQUFFLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUNyRSxDQUFDO0NBQ0Y7QUFFRCxNQUFNLENBQUMsTUFBTSwwQkFBMEIsR0FBRyxDQUN4QyxPQUFrQyxFQUNaLEVBQUUsQ0FBQyxJQUFJLG9CQUFvQixDQUFDLE9BQU8sQ0FBQyxDQUFDIn0=

package/dist_ts_openai_account/smartai.providers.interfaces.d.ts

@@ -0,0 +1,161 @@
+export type TSmartAiProviderId = string;
+export type TSmartAiProviderLoginFlow = 'browser' | 'device';
+export type TSmartAiProviderInputModality = 'text' | 'image' | 'audio';
+export interface ISmartAiProviderDescriptor {
+    providerId: TSmartAiProviderId;
+    displayName: string;
+    loginFlows: readonly TSmartAiProviderLoginFlow[];
+    supportsApiKey: boolean;
+}
+export interface ISmartAiProviderApiKeyCredential {
+    kind: 'apiKey';
+    providerId: TSmartAiProviderId;
+    apiKey: string;
+}
+export interface IOpenAiChatGptOAuthCredential {
+    kind: 'chatgptOAuth';
+    providerId: 'openai';
+    accessToken: string;
+    refreshToken: string;
+    idToken: string;
+    lastRefreshAt?: string;
+}
+export type TSmartAiProviderCredential = ISmartAiProviderApiKeyCredential | IOpenAiChatGptOAuthCredential;
+export interface ISmartAiProviderAccountSummary {
+    providerId: TSmartAiProviderId;
+    authKind: TSmartAiProviderCredential['kind'];
+    accountId?: string;
+    email?: string;
+    plan?: string;
+}
+export interface ISmartAiProviderLoginResult {
+    credential: IOpenAiChatGptOAuthCredential;
+    account: ISmartAiProviderAccountSummary;
+}
+export interface ISmartAiProviderBrowserLoginPrompt {
+    flow: 'browser';
+    authUrl: string;
+}
+export interface ISmartAiProviderDeviceLoginPrompt {
+    flow: 'device';
+    verificationUrl: string;
+    userCode: string;
+}
+export type TSmartAiProviderLoginPrompt = ISmartAiProviderBrowserLoginPrompt | ISmartAiProviderDeviceLoginPrompt;
+export type TSmartAiProviderCancelStatus = 'canceled' | 'notFound';
+export interface ISmartAiProviderLoginHandle {
+    readonly prompt: TSmartAiProviderLoginPrompt;
+    readonly completion: Promise<ISmartAiProviderLoginResult>;
+    cancel(): Promise<TSmartAiProviderCancelStatus>;
+    close(): Promise<void>;
+}
+export interface ISmartAiProviderOperationOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+export interface ISmartAiProviderModelReasoningEffort {
+    effort: string;
+    description: string;
+}
+export interface ISmartAiProviderModelServiceTier {
+    id: string;
+    name: string;
+    description: string;
+}
+export interface ISmartAiProviderModel {
+    providerId: 'openai';
+    modelId: string;
+    wireModel: string;
+    displayName: string;
+    description: string;
+    hidden: boolean;
+    reasoningEfforts: ISmartAiProviderModelReasoningEffort[];
+    defaultReasoningEffort: string;
+    inputModalities: TSmartAiProviderInputModality[];
+    supportsPersonality: boolean;
+    serviceTiers: ISmartAiProviderModelServiceTier[];
+    defaultServiceTier?: string;
+    isDefault: boolean;
+}
+export interface ISmartAiProviderModelListOptions extends ISmartAiProviderOperationOptions {
+    cursor?: string;
+    limit?: number;
+    includeHidden?: boolean;
+}
+export type TSmartAiProviderCredentialOperationErrorCode = 'ABORTED' | 'TIMEOUT';
+export interface ISmartAiProviderRefreshSuccess {
+    success: true;
+    credential: IOpenAiChatGptOAuthCredential;
+    account: ISmartAiProviderAccountSummary;
+}
+export interface ISmartAiProviderRefreshFailure {
+    success: false;
+    credential: IOpenAiChatGptOAuthCredential;
+    errorCode: TSmartAiProviderCredentialOperationErrorCode | 'REFRESH_FAILED';
+}
+export type TSmartAiProviderRefreshResult = ISmartAiProviderRefreshSuccess | ISmartAiProviderRefreshFailure;
+export interface ISmartAiProviderModelListSuccess {
+    success: true;
+    models: ISmartAiProviderModel[];
+    nextCursor?: string;
+}
+export interface ISmartAiProviderModelListFailure {
+    success: false;
+    errorCode: TSmartAiProviderCredentialOperationErrorCode | 'CREDENTIAL_REFRESH_REQUIRED' | 'MODEL_LIST_FAILED';
+}
+export type TSmartAiProviderModelListResult = ISmartAiProviderModelListSuccess | ISmartAiProviderModelListFailure;
+export interface ISmartAiProviderRateLimitWindow {
+    usedPercent: number;
+    limitWindowSeconds: number;
+    resetAfterSeconds: number;
+    /** Unix timestamp in seconds. */
+    resetsAt: number;
+}
+export interface ISmartAiProviderRateLimitDetails {
+    allowed: boolean;
+    limitReached: boolean;
+    primaryWindow?: ISmartAiProviderRateLimitWindow;
+    secondaryWindow?: ISmartAiProviderRateLimitWindow;
+}
+export interface ISmartAiProviderAdditionalRateLimit {
+    limitName: string;
+    meteredFeature: string;
+    rateLimit?: ISmartAiProviderRateLimitDetails;
+}
+export interface ISmartAiProviderAccountRateLimits {
+    providerId: 'openai';
+    plan: string;
+    observedAt: string;
+    rateLimit?: ISmartAiProviderRateLimitDetails;
+    additionalRateLimits: ISmartAiProviderAdditionalRateLimit[];
+    rateLimitReachedType?: string;
+    rateLimitResetCreditsAvailableCount?: number;
+}
+export interface ISmartAiProviderAccountRateLimitsSuccess {
+    success: true;
+    rateLimits: ISmartAiProviderAccountRateLimits;
+}
+export interface ISmartAiProviderAccountRateLimitsFailure {
+    success: false;
+    errorCode: TSmartAiProviderCredentialOperationErrorCode | 'CREDENTIAL_REFRESH_REQUIRED' | 'ACCOUNT_RATE_LIMITS_FAILED';
+}
+export type TSmartAiProviderAccountRateLimitsResult = ISmartAiProviderAccountRateLimitsSuccess | ISmartAiProviderAccountRateLimitsFailure;
+export interface ISmartAiProviderLoginOptions extends ISmartAiProviderOperationOptions {
+    flow: TSmartAiProviderLoginFlow;
+}
+export interface ISmartAiProviderAdapter {
+    readonly descriptor: ISmartAiProviderDescriptor;
+    createApiKeyCredential(apiKey: string): ISmartAiProviderApiKeyCredential;
+    inspectCredential(credential: TSmartAiProviderCredential): ISmartAiProviderAccountSummary;
+    beginLogin(options: ISmartAiProviderLoginOptions): Promise<ISmartAiProviderLoginHandle>;
+    refreshCredential(credential: IOpenAiChatGptOAuthCredential, options?: ISmartAiProviderOperationOptions): Promise<TSmartAiProviderRefreshResult>;
+    listModels(credential: IOpenAiChatGptOAuthCredential, options?: ISmartAiProviderModelListOptions): Promise<TSmartAiProviderModelListResult>;
+    getAccountRateLimits(credential: IOpenAiChatGptOAuthCredential, options?: ISmartAiProviderOperationOptions): Promise<TSmartAiProviderAccountRateLimitsResult>;
+    logoutCredential(credential: IOpenAiChatGptOAuthCredential, options?: ISmartAiProviderOperationOptions): Promise<void>;
+    dispose(): Promise<void>;
+}
+export interface IOpenAiProviderAdapterOptions {
+    fetch?: typeof fetch;
+    originator?: string;
+    now?: () => Date;
+}

package/dist_ts_openai_account/smartai.providers.interfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRhaS5wcm92aWRlcnMuaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX29wZW5haV9hY2NvdW50L3NtYXJ0YWkucHJvdmlkZXJzLmludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist_ts_openai_account/smartai.providers.openai.d.ts

@@ -0,0 +1,29 @@
+import type { IOpenAiChatGptOAuthCredential, IOpenAiProviderAdapterOptions, ISmartAiProviderAccountSummary, ISmartAiProviderAdapter, ISmartAiProviderApiKeyCredential, ISmartAiProviderDescriptor, ISmartAiProviderLoginHandle, ISmartAiProviderLoginOptions, ISmartAiProviderModelListOptions, ISmartAiProviderOperationOptions, TSmartAiProviderAccountRateLimitsResult, TSmartAiProviderCredential, TSmartAiProviderModelListResult, TSmartAiProviderRefreshResult } from './smartai.providers.interfaces.js';
+export declare class OpenAiProviderAdapter implements ISmartAiProviderAdapter {
+    readonly descriptor: ISmartAiProviderDescriptor;
+    private readonly fetchImplementation;
+    private readonly originator;
+    private readonly now;
+    private readonly cursorKey;
+    private readonly handles;
+    private readonly operations;
+    private readonly refreshes;
+    private closed;
+    private disposePromise?;
+    constructor(optionsArg?: IOpenAiProviderAdapterOptions);
+    private requireOpen;
+    private authOptions;
+    createApiKeyCredential(apiKeyArg: string): ISmartAiProviderApiKeyCredential;
+    inspectCredential(credentialArg: TSmartAiProviderCredential): ISmartAiProviderAccountSummary;
+    beginLogin(optionsArg: ISmartAiProviderLoginOptions): Promise<ISmartAiProviderLoginHandle>;
+    refreshCredential(credentialArg: IOpenAiChatGptOAuthCredential, optionsArg?: ISmartAiProviderOperationOptions): Promise<TSmartAiProviderRefreshResult>;
+    private performRefreshCredential;
+    private fetchCatalog;
+    private encodeCursor;
+    private decodeCursor;
+    listModels(credentialArg: IOpenAiChatGptOAuthCredential, optionsArg?: ISmartAiProviderModelListOptions): Promise<TSmartAiProviderModelListResult>;
+    private fetchAccountRateLimits;
+    getAccountRateLimits(credentialArg: IOpenAiChatGptOAuthCredential, optionsArg?: ISmartAiProviderOperationOptions): Promise<TSmartAiProviderAccountRateLimitsResult>;
+    logoutCredential(credentialArg: IOpenAiChatGptOAuthCredential, optionsArg?: ISmartAiProviderOperationOptions): Promise<void>;
+    dispose(): Promise<void>;
+}