@modelprofile.com/flexharness 6.1.0 → 7.0.1

package/dist_ts_kvm/tools.d.ts

@@ -0,0 +1,15 @@
+import { KvmTerminal } from './classes.kvmterminal.js';
+export interface IKvmTool<TInput = unknown, TOutput = unknown> {
+    name: string;
+    description: string;
+    parameters: unknown;
+    execute: (input: TInput) => Promise<TOutput>;
+}
+export interface IKvmToolOptions {
+    terminal: KvmTerminal;
+}
+export interface IKvmTerminalRunCommandInput {
+    command: string;
+}
+export type TKvmTerminalObserveInput = Record<string, never>;
+export declare const createKvmTools: (options: IKvmToolOptions) => IKvmTool[];

package/dist_ts_kvm/tools.js

@@ -0,0 +1,40 @@
+import { KvmTerminal } from './classes.kvmterminal.js';
+export const createKvmTools = (options) => {
+    return [
+        {
+            name: 'kvm_terminal_run_command',
+            description: 'Run a command through the visual KVM terminal transport and return OCR-parsed output.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    command: {
+                        type: 'string',
+                        description: 'The terminal command to run.',
+                    },
+                },
+                required: ['command'],
+                additionalProperties: false,
+            },
+            execute: async (input) => {
+                const typedInput = input;
+                if (!typedInput || typeof typedInput.command !== 'string') {
+                    throw new Error('kvm_terminal_run_command requires a string command.');
+                }
+                return options.terminal.runCommand(typedInput.command);
+            },
+        },
+        {
+            name: 'kvm_terminal_observe',
+            description: 'Observe the current visual KVM terminal text through the configured OCR engine.',
+            parameters: {
+                type: 'object',
+                properties: {},
+                additionalProperties: false,
+            },
+            execute: async () => {
+                return options.terminal.observeText();
+            },
+        },
+    ];
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19rdm0vdG9vbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBb0J2RCxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUcsQ0FBQyxPQUF3QixFQUFjLEVBQUU7SUFDckUsT0FBTztRQUNMO1lBQ0UsSUFBSSxFQUFFLDBCQUEwQjtZQUNoQyxXQUFXLEVBQUUsdUZBQXVGO1lBQ3BHLFVBQVUsRUFBRTtnQkFDVixJQUFJLEVBQUUsUUFBUTtnQkFDZCxVQUFVLEVBQUU7b0JBQ1YsT0FBTyxFQUFFO3dCQUNQLElBQUksRUFBRSxRQUFRO3dCQUNkLFdBQVcsRUFBRSw4QkFBOEI7cUJBQzVDO2lCQUNGO2dCQUNELFFBQVEsRUFBRSxDQUFDLFNBQVMsQ0FBQztnQkFDckIsb0JBQW9CLEVBQUUsS0FBSzthQUM1QjtZQUNELE9BQU8sRUFBRSxLQUFLLEVBQUUsS0FBYyxFQUFzQyxFQUFFO2dCQUNwRSxNQUFNLFVBQVUsR0FBRyxLQUE2QyxDQUFDO2dCQUNqRSxJQUFJLENBQUMsVUFBVSxJQUFJLE9BQU8sVUFBVSxDQUFDLE9BQU8sS0FBSyxRQUFRLEVBQUUsQ0FBQztvQkFDMUQsTUFBTSxJQUFJLEtBQUssQ0FBQyxxREFBcUQsQ0FBQyxDQUFDO2dCQUN6RSxDQUFDO2dCQUNELE9BQU8sT0FBTyxDQUFDLFFBQVEsQ0FBQyxVQUFVLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1lBQ3pELENBQUM7U0FDRjtRQUNEO1lBQ0UsSUFBSSxFQUFFLHNCQUFzQjtZQUM1QixXQUFXLEVBQUUsaUZBQWlGO1lBQzlGLFVBQVUsRUFBRTtnQkFDVixJQUFJLEVBQUUsUUFBUTtnQkFDZCxVQUFVLEVBQUUsRUFBRTtnQkFDZCxvQkFBb0IsRUFBRSxLQUFLO2FBQzVCO1lBQ0QsT0FBTyxFQUFFLEtBQUssSUFBcUIsRUFBRTtnQkFDbkMsT0FBTyxPQUFPLENBQUMsUUFBUSxDQUFDLFdBQVcsRUFBRSxDQUFDO1lBQ3hDLENBQUM7U0FDRjtLQUNGLENBQUM7QUFDSixDQUFDLENBQUMifQ==

package/dist_ts_mcp/index.d.ts

@@ -0,0 +1,86 @@
+import { Client, type ClientOptions } from '@modelcontextprotocol/sdk/client/index.js';
+import { type StdioServerParameters } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { type StreamableHTTPClientTransportOptions } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import type { RequestOptions } from '@modelcontextprotocol/sdk/shared/protocol.js';
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type { ToolSet } from 'ai';
+export type TMcpListToolsResult = Awaited<ReturnType<Client['listTools']>>;
+export type TMcpToolMetadata = TMcpListToolsResult['tools'][number];
+export type TMcpCallToolResult = Awaited<ReturnType<Client['callTool']>>;
+export interface IMcpClientLike {
+    listTools(params?: {
+        cursor?: string;
+    }, options?: RequestOptions): Promise<TMcpListToolsResult>;
+    callTool(params: {
+        name: string;
+        arguments?: Record<string, unknown>;
+    }, resultSchema?: unknown, options?: RequestOptions): Promise<TMcpCallToolResult>;
+    close?(): Promise<void>;
+}
+export interface IMcpServerClientOptions {
+    clientName?: string;
+    clientVersion?: string;
+    clientOptions?: ClientOptions;
+    requestOptions?: RequestOptions;
+}
+export interface IMcpStdioServerConfig extends StdioServerParameters, IMcpServerClientOptions {
+    type: 'stdio';
+}
+export interface IMcpStreamableHttpServerConfig extends IMcpServerClientOptions {
+    type: 'streamableHttp' | 'http';
+    url: string | URL;
+    transportOptions?: StreamableHTTPClientTransportOptions;
+}
+export interface IMcpTransportServerConfig extends IMcpServerClientOptions {
+    type: 'transport';
+    transport: Transport;
+}
+export interface IMcpClientServerConfig {
+    type: 'client';
+    client: IMcpClientLike;
+}
+export type TMcpServerConfig = IMcpStdioServerConfig | IMcpStreamableHttpServerConfig | IMcpTransportServerConfig | IMcpClientServerConfig;
+export interface IMcpToolFormatContext {
+    serverName: string;
+    toolName: string;
+    exposedToolName: string;
+}
+export interface IMcpAuthorizeToolCallContext extends IMcpToolFormatContext {
+    arguments: Record<string, unknown>;
+    tool: TMcpToolMetadata;
+    toolCallId: string;
+    abortSignal?: AbortSignal;
+}
+export interface ICreateMcpToolsOptions {
+    servers: Record<string, TMcpServerConfig>;
+    clientName?: string;
+    clientVersion?: string;
+    clientOptions?: ClientOptions;
+    requestOptions?: RequestOptions;
+    listToolsRequestOptions?: RequestOptions;
+    callToolRequestOptions?: RequestOptions;
+    /** Maximum MCP listTools pages per server. Default: 100. */
+    maxListToolsPages?: number;
+    prefixToolNames?: boolean;
+    formatResult?: (result: TMcpCallToolResult, context: IMcpToolFormatContext) => unknown;
+    /** Resolve to allow the MCP tool call, or throw to deny it. Omission allows all calls. */
+    authorizeToolCall?: (context: IMcpAuthorizeToolCallContext) => PromiseLike<void> | void;
+}
+export interface IMcpConnectedServer {
+    name: string;
+    client: IMcpClientLike;
+    tools: TMcpToolMetadata[];
+}
+export interface IMcpToolNameMapping {
+    serverName: string;
+    toolName: string;
+}
+export interface ICreateMcpToolsResult {
+    tools: ToolSet;
+    servers: IMcpConnectedServer[];
+    toolNameMap: Record<string, IMcpToolNameMapping>;
+    close: () => Promise<void>;
+}
+export declare const createMcpTools: (options: ICreateMcpToolsOptions) => Promise<ICreateMcpToolsResult>;
+export declare const sanitizeMcpToolName: (name: string, fallback?: string) => string;
+export declare const formatMcpToolResult: (result: TMcpCallToolResult) => unknown;

package/dist_ts_mcp/index.js

@@ -0,0 +1,284 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport, } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransport, } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { jsonSchema, tool } from 'ai';
+import { connectMcpClientWithRequestOptions, withMcpRequestOptions, } from './requestcontext.js';
+const DEFAULT_MAX_LIST_TOOLS_PAGES = 100;
+export const createMcpTools = async (options) => {
+    const serverEntries = Object.entries(options.servers);
+    if (serverEntries.length === 0) {
+        throw new Error('createMcpTools requires at least one MCP server.');
+    }
+    const maxListToolsPages = normalizeMaxListToolsPages(options.maxListToolsPages);
+    const connectedServers = [];
+    try {
+        for (const [serverName, config] of serverEntries) {
+            const client = await connectMcpServer(serverName, config, options);
+            const connectedServer = { name: serverName, client, tools: [] };
+            connectedServers.push(connectedServer);
+            connectedServer.tools = await listAllMcpTools(client, options.listToolsRequestOptions ?? getServerRequestOptions(config) ?? options.requestOptions, maxListToolsPages);
+        }
+        const exposedTools = {};
+        const toolNameMap = {};
+        const usedToolNames = new Set(['invalid']);
+        const formatResult = options.formatResult ?? formatMcpToolResult;
+        const shouldPrefixToolNames = options.prefixToolNames ?? connectedServers.length > 1;
+        for (const server of connectedServers) {
+            for (const mcpTool of server.tools) {
+                const baseToolName = createExposedToolName(server.name, mcpTool.name, shouldPrefixToolNames);
+                const exposedToolName = createUniqueToolName(baseToolName, usedToolNames);
+                usedToolNames.add(exposedToolName);
+                toolNameMap[exposedToolName] = {
+                    serverName: server.name,
+                    toolName: mcpTool.name,
+                };
+                exposedTools[exposedToolName] = tool({
+                    description: mcpTool.description ?? `MCP tool ${mcpTool.name} from ${server.name}`,
+                    inputSchema: jsonSchema(mcpTool.inputSchema),
+                    execute: async (input, invocationOptions) => {
+                        const normalizedArguments = normalizeMcpArguments(input);
+                        await options.authorizeToolCall?.({
+                            serverName: server.name,
+                            toolName: mcpTool.name,
+                            exposedToolName,
+                            arguments: normalizedArguments,
+                            tool: mcpTool,
+                            toolCallId: invocationOptions?.toolCallId ?? '',
+                            abortSignal: invocationOptions?.abortSignal,
+                        });
+                        const configuredCallToolOptions = {
+                            ...options.requestOptions,
+                            ...options.callToolRequestOptions,
+                        };
+                        const result = await withMcpRequestOptions(configuredCallToolOptions, invocationOptions?.abortSignal, (requestOptions) => server.client.callTool({
+                            name: mcpTool.name,
+                            arguments: normalizedArguments,
+                        }, undefined, requestOptions));
+                        const formattedResult = formatResult(result, {
+                            serverName: server.name,
+                            toolName: mcpTool.name,
+                            exposedToolName,
+                        });
+                        if (result.isError === true) {
+                            throw new Error(formatMcpError(formattedResult));
+                        }
+                        return formattedResult;
+                    },
+                });
+            }
+        }
+        return {
+            tools: exposedTools,
+            servers: connectedServers,
+            toolNameMap,
+            close: async () => closeMcpClients(connectedServers),
+        };
+    }
+    catch (error) {
+        return rethrowAfterCleanup(error, () => closeMcpClients(connectedServers), 'Failed to create MCP tools and clean up connected clients.');
+    }
+};
+export const sanitizeMcpToolName = (name, fallback = 'mcp_tool') => {
+    const sanitized = name
+        .trim()
+        .replace(/[^a-zA-Z0-9_-]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+    const safeName = sanitized || fallback;
+    return /^[a-zA-Z_]/.test(safeName) ? safeName : `_${safeName}`;
+};
+export const formatMcpToolResult = (result) => {
+    const resultRecord = result;
+    if (Object.prototype.hasOwnProperty.call(resultRecord, 'toolResult')) {
+        return resultRecord.toolResult;
+    }
+    const content = Array.isArray(resultRecord.content)
+        ? resultRecord.content.map(formatMcpContentPart).filter(Boolean).join('\n\n')
+        : '';
+    const formattedContent = resultRecord.isError && content
+        ? `MCP tool returned an error:\n${content}`
+        : content;
+    const structuredContent = resultRecord.structuredContent;
+    if (structuredContent !== undefined && formattedContent) {
+        return `${formattedContent}\n\nStructured content:\n${stringifyJson(structuredContent)}`;
+    }
+    if (structuredContent !== undefined) {
+        return structuredContent;
+    }
+    if (formattedContent) {
+        return formattedContent;
+    }
+    return stringifyJson(result);
+};
+const connectMcpServer = async (serverName, config, options) => {
+    if (config.type === 'client') {
+        return config.client;
+    }
+    const client = new Client({
+        name: config.clientName ?? options.clientName ?? 'smartagent-mcp',
+        version: config.clientVersion ?? options.clientVersion ?? '1.0.0',
+    }, config.clientOptions ?? options.clientOptions ?? { capabilities: {} });
+    const transport = createMcpTransport(config);
+    try {
+        await connectMcpClientWithRequestOptions(client, transport, config.requestOptions ?? options.requestOptions);
+    }
+    catch (error) {
+        await rethrowAfterCleanup(error, async () => {
+            try {
+                await client.close();
+            }
+            catch (clientCloseError) {
+                try {
+                    await transport.close();
+                }
+                catch (transportCloseError) {
+                    throw new AggregateError([clientCloseError, transportCloseError], `Failed to close MCP client and transport for "${serverName}".`);
+                }
+                throw clientCloseError;
+            }
+        }, `Failed to connect MCP server "${serverName}" and clean up its client.`);
+    }
+    return client;
+};
+const createMcpTransport = (config) => {
+    if (config.type === 'stdio') {
+        const { type, clientName, clientVersion, clientOptions, requestOptions, ...serverParameters } = config;
+        return new StdioClientTransport(serverParameters);
+    }
+    if (config.type === 'streamableHttp' || config.type === 'http') {
+        return new StreamableHTTPClientTransport(new URL(config.url), config.transportOptions);
+    }
+    if (config.type === 'transport') {
+        return config.transport;
+    }
+    throw new Error('Unsupported MCP server transport.');
+};
+const getServerRequestOptions = (config) => {
+    return config.type === 'client' ? undefined : config.requestOptions;
+};
+const listAllMcpTools = async (client, requestOptions, maxPages = DEFAULT_MAX_LIST_TOOLS_PAGES) => {
+    const tools = [];
+    const seenCursors = new Set();
+    let cursor;
+    for (let page = 1; page <= maxPages; page++) {
+        const result = await withMcpRequestOptions(requestOptions, undefined, (isolatedRequestOptions) => client.listTools(cursor ? { cursor } : undefined, isolatedRequestOptions));
+        tools.push(...result.tools);
+        const nextCursor = result.nextCursor;
+        if (!nextCursor) {
+            return tools;
+        }
+        if (seenCursors.has(nextCursor)) {
+            throw new Error(`MCP listTools returned repeated cursor "${nextCursor}".`);
+        }
+        seenCursors.add(nextCursor);
+        cursor = nextCursor;
+    }
+    throw new Error(`MCP listTools exceeded the maximum of ${maxPages} pages.`);
+};
+const normalizeMaxListToolsPages = (maxPages = DEFAULT_MAX_LIST_TOOLS_PAGES) => {
+    if (!Number.isSafeInteger(maxPages) || maxPages <= 0) {
+        throw new Error('maxListToolsPages must be a positive integer.');
+    }
+    return maxPages;
+};
+const createExposedToolName = (serverName, toolName, prefixToolName) => {
+    const safeToolName = sanitizeMcpToolName(toolName);
+    if (!prefixToolName) {
+        return safeToolName;
+    }
+    return `${sanitizeMcpToolName(serverName, 'mcp')}__${safeToolName}`;
+};
+const createUniqueToolName = (baseToolName, usedToolNames) => {
+    if (!usedToolNames.has(baseToolName)) {
+        return baseToolName;
+    }
+    let suffix = 2;
+    while (usedToolNames.has(`${baseToolName}_${suffix}`)) {
+        suffix++;
+    }
+    return `${baseToolName}_${suffix}`;
+};
+const normalizeMcpArguments = (input) => {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        return {};
+    }
+    return input;
+};
+const formatMcpError = (formattedResult) => {
+    if (typeof formattedResult === 'string' && formattedResult) {
+        return formattedResult;
+    }
+    const formatted = stringifyJson(formattedResult);
+    return formatted || 'MCP tool returned an error.';
+};
+const formatMcpContentPart = (part) => {
+    if (!part || typeof part !== 'object') {
+        return stringifyJson(part);
+    }
+    const partRecord = part;
+    const type = partRecord.type;
+    if (type === 'text') {
+        return typeof partRecord.text === 'string' ? partRecord.text : '';
+    }
+    if (type === 'image' || type === 'audio') {
+        const data = typeof partRecord.data === 'string' ? partRecord.data : '';
+        const mimeType = typeof partRecord.mimeType === 'string' ? partRecord.mimeType : 'application/octet-stream';
+        return `[${type}: ${mimeType}; base64 length ${data.length}]`;
+    }
+    if (type === 'resource') {
+        return formatMcpResourcePart(partRecord.resource);
+    }
+    if (type === 'resource_link') {
+        const name = typeof partRecord.name === 'string' ? partRecord.name : 'resource';
+        const uri = typeof partRecord.uri === 'string' ? partRecord.uri : '';
+        return `Resource link ${name}${uri ? `: ${uri}` : ''}`;
+    }
+    return stringifyJson(part);
+};
+const formatMcpResourcePart = (resource) => {
+    if (!resource || typeof resource !== 'object') {
+        return stringifyJson(resource);
+    }
+    const resourceRecord = resource;
+    const uri = typeof resourceRecord.uri === 'string' ? resourceRecord.uri : 'resource';
+    if (typeof resourceRecord.text === 'string') {
+        return `Resource ${uri}:\n${resourceRecord.text}`;
+    }
+    if (typeof resourceRecord.blob === 'string') {
+        const mimeType = typeof resourceRecord.mimeType === 'string' ? resourceRecord.mimeType : 'application/octet-stream';
+        return `[resource ${uri}: ${mimeType}; base64 length ${resourceRecord.blob.length}]`;
+    }
+    return stringifyJson(resource);
+};
+const stringifyJson = (value) => {
+    if (typeof value === 'string') {
+        return value;
+    }
+    try {
+        return JSON.stringify(value, undefined, 2);
+    }
+    catch {
+        return String(value);
+    }
+};
+const closeMcpClients = async (servers) => {
+    const results = await Promise.allSettled(servers.map((server) => server.client.close?.()));
+    const errors = results
+        .filter((result) => result.status === 'rejected')
+        .map((result) => result.reason);
+    if (errors.length > 0) {
+        throw new AggregateError(errors, 'Failed to close one or more MCP clients.');
+    }
+};
+const rethrowAfterCleanup = async (originalError, cleanup, message) => {
+    try {
+        await cleanup();
+    }
+    catch (cleanupError) {
+        const cleanupErrors = cleanupError instanceof AggregateError
+            ? cleanupError.errors
+            : [cleanupError];
+        throw new AggregateError([originalError, ...cleanupErrors], message);
+    }
+    throw originalError;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts_mcp/index.ts"],"names":[],"mappings":"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"}

package/dist_ts_mcp/requestcontext.d.ts

@@ -0,0 +1,11 @@
+import type { RequestOptions } from '@modelcontextprotocol/sdk/shared/protocol.js';
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+export interface IMcpRequestContext {
+    requestOptions?: RequestOptions;
+    cleanup: () => void;
+}
+export declare const createMcpRequestContext: (configuredOptions?: RequestOptions, preferredAbortSignal?: AbortSignal) => IMcpRequestContext;
+export declare const withMcpRequestOptions: <T>(configuredOptions: RequestOptions | undefined, preferredAbortSignal: AbortSignal | undefined, request: (requestOptions?: RequestOptions) => Promise<T>) => Promise<T>;
+export declare const connectMcpClientWithRequestOptions: (client: {
+    connect: (transport: Transport, requestOptions?: RequestOptions) => Promise<void>;
+}, transport: Transport, configuredOptions?: RequestOptions) => Promise<void>;

package/dist_ts_mcp/requestcontext.js

@@ -0,0 +1,42 @@
+export const createMcpRequestContext = (configuredOptions, preferredAbortSignal) => {
+    const requestOptions = { ...configuredOptions };
+    const sourceSignal = preferredAbortSignal ?? requestOptions.signal;
+    if (!sourceSignal) {
+        return {
+            requestOptions: Object.keys(requestOptions).length > 0 ? requestOptions : undefined,
+            cleanup: () => undefined,
+        };
+    }
+    const relayController = new AbortController();
+    const forwardAbort = () => relayController.abort(sourceSignal.reason);
+    let listenerWasAdded = false;
+    if (sourceSignal.aborted) {
+        forwardAbort();
+    }
+    else {
+        sourceSignal.addEventListener('abort', forwardAbort, { once: true });
+        listenerWasAdded = true;
+    }
+    return {
+        requestOptions: {
+            ...requestOptions,
+            signal: relayController.signal,
+        },
+        cleanup: () => {
+            if (listenerWasAdded) {
+                sourceSignal.removeEventListener('abort', forwardAbort);
+            }
+        },
+    };
+};
+export const withMcpRequestOptions = async (configuredOptions, preferredAbortSignal, request) => {
+    const context = createMcpRequestContext(configuredOptions, preferredAbortSignal);
+    try {
+        return await request(context.requestOptions);
+    }
+    finally {
+        context.cleanup();
+    }
+};
+export const connectMcpClientWithRequestOptions = async (client, transport, configuredOptions) => withMcpRequestOptions(configuredOptions, undefined, (requestOptions) => client.connect(transport, requestOptions));
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_media/index.d.ts

@@ -0,0 +1,8 @@
+import type { TSmartAiLanguageModel } from '@modelprofile.com/flexharness-models';
+export interface IVisionOptions {
+    model: TSmartAiLanguageModel;
+    image: Buffer | Uint8Array;
+    prompt: string;
+    mediaType?: 'image/jpeg' | 'image/png' | 'image/webp' | 'image/gif';
+}
+export declare function analyzeImage(options: IVisionOptions): Promise<string>;

package/dist_ts_media/index.js

@@ -0,0 +1,21 @@
+import * as plugins from './plugins.js';
+export async function analyzeImage(options) {
+    const result = await plugins.generateText({
+        model: options.model,
+        messages: [
+            {
+                role: 'user',
+                content: [
+                    { type: 'text', text: options.prompt },
+                    {
+                        type: 'file',
+                        data: options.image,
+                        mediaType: options.mediaType ?? 'image/jpeg',
+                    },
+                ],
+            },
+        ],
+    });
+    return result.text;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19tZWRpYS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQVV4QyxNQUFNLENBQUMsS0FBSyxVQUFVLFlBQVksQ0FBQyxPQUF1QjtJQUN4RCxNQUFNLE1BQU0sR0FBRyxNQUFNLE9BQU8sQ0FBQyxZQUFZLENBQUM7UUFDeEMsS0FBSyxFQUFFLE9BQU8sQ0FBQyxLQUFLO1FBQ3BCLFFBQVEsRUFBRTtZQUNSO2dCQUNFLElBQUksRUFBRSxNQUFNO2dCQUNaLE9BQU8sRUFBRTtvQkFDUCxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLE9BQU8sQ0FBQyxNQUFNLEVBQUU7b0JBQ3RDO3dCQUNFLElBQUksRUFBRSxNQUFNO3dCQUNaLElBQUksRUFBRSxPQUFPLENBQUMsS0FBSzt3QkFDbkIsU0FBUyxFQUFFLE9BQU8sQ0FBQyxTQUFTLElBQUksWUFBWTtxQkFDN0M7aUJBQ0Y7YUFDRjtTQUNGO0tBQ0YsQ0FBQyxDQUFDO0lBQ0gsT0FBTyxNQUFNLENBQUMsSUFBSSxDQUFDO0FBQ3JCLENBQUMifQ==

package/dist_ts_media/plugins.d.ts

@@ -0,0 +1,2 @@
+import { generateText } from 'ai';
+export { generateText };

package/dist_ts_media/plugins.js

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

package/dist_ts_ocr/classes.imageocr.d.ts

@@ -0,0 +1,19 @@
+import { type ISmartAiMistralOcrOptions, type ISmartAiMistralOcrRecognizeOptions, type ISmartAiOcrEngine, type ISmartAiOcrImageInput, type ISmartAiOcrResult, type TSmartAiOcrImageMimeType } from './ocr.mistral.js';
+export interface IImageOcrOptions {
+    engine?: ISmartAiOcrEngine;
+    mistralOptions?: ISmartAiMistralOcrOptions;
+}
+export interface IImageOcrRecognitionOptions extends IImageOcrOptions {
+    recognizeOptions?: ISmartAiMistralOcrRecognizeOptions;
+}
+export interface IImageOcrBytesOptions extends IImageOcrRecognitionOptions {
+    mimeType: TSmartAiOcrImageMimeType;
+}
+/** Image recognition without a local OCR executable or PDF dependency. */
+export declare class ImageOcr {
+    private readonly options;
+    constructor(options?: IImageOcrOptions);
+    recognizeImage(input: ISmartAiOcrImageInput, options?: IImageOcrRecognitionOptions): Promise<ISmartAiOcrResult>;
+    /** Accepts Uint8Array, including Node Buffer, without importing Node builtins. */
+    recognizeImageBytes(bytes: Uint8Array, options: IImageOcrBytesOptions): Promise<ISmartAiOcrResult>;
+}

package/dist_ts_ocr/classes.imageocr.js

@@ -0,0 +1,27 @@
+import { createMistralOcrEngine, } from './ocr.mistral.js';
+/** Image recognition without a local OCR executable or PDF dependency. */
+export class ImageOcr {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async recognizeImage(input, options = {}) {
+        const engine = options.engine ?? this.options.engine ?? createMistralOcrEngine({
+            ...this.options.mistralOptions,
+            ...options.mistralOptions,
+        });
+        return engine.recognizeImage(input, options.recognizeOptions);
+    }
+    /** Accepts Uint8Array, including Node Buffer, without importing Node builtins. */
+    async recognizeImageBytes(bytes, options) {
+        const chunks = [];
+        for (let offset = 0; offset < bytes.length; offset += 8192) {
+            chunks.push(String.fromCharCode(...bytes.subarray(offset, offset + 8192)));
+        }
+        return this.recognizeImage({
+            dataBase64: btoa(chunks.join('')),
+            mimeType: options.mimeType,
+        }, options);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5pbWFnZW9jci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX29jci9jbGFzc2VzLmltYWdlb2NyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxzQkFBc0IsR0FPdkIsTUFBTSxrQkFBa0IsQ0FBQztBQWUxQiwwRUFBMEU7QUFDMUUsTUFBTSxPQUFPLFFBQVE7SUFDVTtJQUE3QixZQUE2QixVQUE0QixFQUFFO1FBQTlCLFlBQU8sR0FBUCxPQUFPLENBQXVCO0lBQUcsQ0FBQztJQUV4RCxLQUFLLENBQUMsY0FBYyxDQUN6QixLQUE0QixFQUM1QixVQUF1QyxFQUFFO1FBRXpDLE1BQU0sTUFBTSxHQUFHLE9BQU8sQ0FBQyxNQUFNLElBQUksSUFBSSxDQUFDLE9BQU8sQ0FBQyxNQUFNLElBQUksc0JBQXNCLENBQUM7WUFDN0UsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLGNBQWM7WUFDOUIsR0FBRyxPQUFPLENBQUMsY0FBYztTQUMxQixDQUFDLENBQUM7UUFDSCxPQUFPLE1BQU0sQ0FBQyxjQUFjLENBQUMsS0FBSyxFQUFFLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO0lBQ2hFLENBQUM7SUFFRCxrRkFBa0Y7SUFDM0UsS0FBSyxDQUFDLG1CQUFtQixDQUM5QixLQUFpQixFQUNqQixPQUE4QjtRQUU5QixNQUFNLE1BQU0sR0FBYSxFQUFFLENBQUM7UUFDNUIsS0FBSyxJQUFJLE1BQU0sR0FBRyxDQUFDLEVBQUUsTUFBTSxHQUFHLEtBQUssQ0FBQyxNQUFNLEVBQUUsTUFBTSxJQUFJLElBQUksRUFBRSxDQUFDO1lBQzNELE1BQU0sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLFlBQVksQ0FBQyxHQUFHLEtBQUssQ0FBQyxRQUFRLENBQUMsTUFBTSxFQUFFLE1BQU0sR0FBRyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDN0UsQ0FBQztRQUNELE9BQU8sSUFBSSxDQUFDLGNBQWMsQ0FBQztZQUN6QixVQUFVLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUM7WUFDakMsUUFBUSxFQUFFLE9BQU8sQ0FBQyxRQUFRO1NBQzNCLEVBQUUsT0FBTyxDQUFDLENBQUM7SUFDZCxDQUFDO0NBQ0YifQ==

package/dist_ts_ocr/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ocr.mistral.js';
+export * from './classes.imageocr.js';

package/dist_ts_ocr/index.js

@@ -0,0 +1,3 @@
+export * from './ocr.mistral.js';
+export * from './classes.imageocr.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19vY3IvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLHVCQUF1QixDQUFDIn0=