@unchainedshop/api 5.0.0-alpha.1 → 5.0.0-alpha.3

package/README.md

@@ -141,14 +141,16 @@ The API exposes a complete GraphQL schema with:
 
 ## MCP Server
 
-Model Context Protocol server for AI agent integrations:
+Model Context Protocol server for AI agent integrations. `connect()` (Express or Fastify) automatically mounts a stateless MCP endpoint at `/mcp` (configurable via `MCP_API_PATH`). The endpoint requires an authenticated user with the `admin` role and serves 9 management tools plus the shop localization resources.
 
-```typescript
-import { createMCPServer } from '@unchainedshop/api/mcp';
+MCP support is an optional peer dependency:
 
-const mcpServer = createMCPServer(unchainedCore);
+```bash
+npm install @modelcontextprotocol/server
 ```
 
+Without it, the engine boots normally and `/mcp` responds with `503`. The chat handlers (`connect(..., { chat })`) additionally require the optional peers `ai` and `@ai-sdk/mcp` — and `@modelcontextprotocol/server` too, since chat derives its tool set through the engine's own `/mcp` endpoint.
+
 ## Security
 
 The API layer implements comprehensive security controls.

package/lib/adminUiPlugins.d.ts

@@ -0,0 +1,73 @@
+export interface AdminUIPluginEntityConfig {
+    path: string;
+    label: string;
+    icon?: string;
+    requiredRole?: string;
+    sortOrder?: number;
+    components: {
+        list: string;
+        detail: string;
+        create?: string;
+    };
+}
+export interface AdminUIPluginPageConfig {
+    path: string;
+    label: string;
+    icon?: string;
+    requiredRole?: string;
+    sortOrder?: number;
+    component: string;
+}
+export interface AdminUIPluginTabConfig {
+    label: string;
+    component: string;
+    requiredRole?: string;
+}
+export interface AdminUIPluginWidgetConfig {
+    component: string;
+    width?: 'full' | 'half' | 'third';
+}
+export interface AdminUIPluginSlotConfig {
+    component: string;
+}
+export interface AdminUIPluginConfig {
+    name: string;
+    version?: string;
+    bundlePath: string;
+    navigation?: {
+        label: string;
+        icon?: string;
+        requiredRole?: string;
+        sortOrder?: number;
+    };
+    slots: {
+        entities?: AdminUIPluginEntityConfig[];
+        pages?: AdminUIPluginPageConfig[];
+        'dashboard:widgets'?: AdminUIPluginWidgetConfig[];
+        'product:tabs'?: AdminUIPluginTabConfig[];
+        'assortment:tabs'?: AdminUIPluginTabConfig[];
+        'filter:tabs'?: AdminUIPluginTabConfig[];
+        'user:tabs'?: AdminUIPluginTabConfig[];
+        'order:tabs'?: AdminUIPluginTabConfig[];
+        [key: string]: AdminUIPluginTabConfig[] | AdminUIPluginSlotConfig[] | AdminUIPluginEntityConfig[] | AdminUIPluginPageConfig[] | AdminUIPluginWidgetConfig[] | undefined;
+    };
+}
+interface StaticAsset {
+    content: string | (() => string);
+    contentType: string;
+    cacheControl: string;
+    etag?: string;
+}
+export interface PreparedPluginAssets {
+    routes: Map<string, StaticAsset>;
+    validPlugins: AdminUIPluginConfig[];
+}
+export declare const resolveAdminUIPath: () => string | null;
+export declare const parseBundleExports: (bundle: string) => Set<string> | null;
+export declare function preparePluginAssets(plugins: AdminUIPluginConfig[], log: {
+    info: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+}, options?: {
+    devMode?: boolean;
+}): PreparedPluginAssets;
+export {};

package/lib/adminUiPlugins.js

@@ -0,0 +1,164 @@
+import { createHash } from 'node:crypto';
+import { readFileSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+const PLUGIN_NAME_RE = /^[a-z0-9]([a-z0-9_-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9_-]*[a-z0-9])?)*$/i;
+const IMMUTABLE_CACHE = 'public, max-age=31536000, immutable';
+export const resolveAdminUIPath = () => {
+    try {
+        const staticURL = import.meta.resolve('@unchainedshop/admin-ui');
+        return new URL(staticURL).pathname.split('/').slice(0, -1).join('/');
+    }
+    catch {
+        return null;
+    }
+};
+const contentHash = (content) => createHash('sha256').update(content).digest('hex').slice(0, 8);
+export const parseBundleExports = (bundle) => {
+    const returnMatch = bundle.match(/return __toCommonJS\(([\w$]+)\);/);
+    if (!returnMatch)
+        return null;
+    const blockMatch = bundle.match(new RegExp(`__export\\(${returnMatch[1].replace(/\$/g, '\\$')},\\s*\\{([\\s\\S]*?)\\}\\);`));
+    if (!blockMatch)
+        return null;
+    const names = new Set();
+    for (const m of blockMatch[1].matchAll(/(?:^|,)\s*(?:"([^"]+)"|([\w$]+)):\s*\(\)\s*=>/g)) {
+        names.add(m[1] ?? m[2]);
+    }
+    return names.size > 0 ? names : null;
+};
+const collectReferencedComponents = (plugin) => {
+    const names = new Set();
+    for (const [slotId, configs] of Object.entries(plugin.slots || {})) {
+        if (!Array.isArray(configs))
+            continue;
+        for (const config of configs) {
+            if (slotId === 'entities') {
+                const components = config.components;
+                if (components?.list)
+                    names.add(components.list);
+                if (components?.detail)
+                    names.add(components.detail);
+                if (components?.create)
+                    names.add(components.create);
+            }
+            else if (typeof config.component === 'string') {
+                names.add(config.component);
+            }
+        }
+    }
+    return [...names];
+};
+export function preparePluginAssets(plugins, log, options = {}) {
+    const { devMode = false } = options;
+    const routes = new Map();
+    const devCacheControl = 'no-cache, no-store, must-revalidate';
+    const validPlugins = plugins.filter((p) => {
+        if (!PLUGIN_NAME_RE.test(p.name)) {
+            log.warn(`Skipping admin-ui plugin with invalid name: "${p.name}"`);
+            return false;
+        }
+        return true;
+    });
+    const seenNames = new Set();
+    for (const plugin of validPlugins) {
+        if (seenNames.has(plugin.name)) {
+            log.warn(`Duplicate admin-ui plugin name "${plugin.name}": later entries override earlier ones`);
+        }
+        seenNames.add(plugin.name);
+    }
+    if (validPlugins.length > 0) {
+        const pluginList = validPlugins
+            .map((p) => `${p.name}${p.version ? `@${p.version}` : ''}`)
+            .join(', ');
+        log.info(`Loading ${validPlugins.length} admin-ui plugin(s): ${pluginList}`);
+    }
+    const resolvedBundlePaths = new Map();
+    const pluginBundles = new Map();
+    for (const plugin of validPlugins) {
+        try {
+            const bundlePath = resolve(plugin.bundlePath);
+            const content = readFileSync(bundlePath, 'utf-8');
+            resolvedBundlePaths.set(plugin.name, bundlePath);
+            pluginBundles.set(plugin.name, { content, hash: contentHash(content) });
+        }
+        catch (err) {
+            log.warn(`Failed to read bundle for plugin "${plugin.name}" at ${plugin.bundlePath}: ${err.message}`);
+        }
+    }
+    const pluginsWithBundles = validPlugins.filter((p) => pluginBundles.has(p.name));
+    for (const plugin of pluginsWithBundles) {
+        const exportNames = parseBundleExports(pluginBundles.get(plugin.name).content);
+        if (!exportNames)
+            continue;
+        const missing = collectReferencedComponents(plugin).filter((name) => !exportNames.has(name));
+        if (missing.length > 0) {
+            log.warn(`admin-ui plugin "${plugin.name}" references component(s) not exported by its bundle: ${missing.join(', ')}. Exported: ${[...exportNames].join(', ')}`);
+        }
+    }
+    const bundleMtimes = new Map();
+    const bundleHashes = new Map();
+    for (const [name, bundle] of pluginBundles) {
+        bundleHashes.set(name, bundle.hash);
+        try {
+            bundleMtimes.set(name, statSync(resolvedBundlePaths.get(name)).mtimeMs);
+        }
+        catch {
+        }
+    }
+    const refreshBundleHash = (name) => {
+        const bundlePath = resolvedBundlePaths.get(name);
+        try {
+            const currentMtime = statSync(bundlePath).mtimeMs;
+            const cachedMtime = bundleMtimes.get(name);
+            if (cachedMtime !== undefined && cachedMtime === currentMtime) {
+                return bundleHashes.get(name);
+            }
+            const hash = contentHash(readFileSync(bundlePath, 'utf-8'));
+            bundleMtimes.set(name, currentMtime);
+            bundleHashes.set(name, hash);
+            return hash;
+        }
+        catch {
+            return bundleHashes.get(name) ?? pluginBundles.get(name).hash;
+        }
+    };
+    const buildManifestJSON = () => JSON.stringify(pluginsWithBundles.map((plugin) => ({
+        ...Object.fromEntries(Object.entries(plugin).filter(([k]) => k !== 'bundlePath')),
+        bundleUrl: `/admin-plugins/${plugin.name}.js?v=${devMode ? refreshBundleHash(plugin.name) : pluginBundles.get(plugin.name).hash}`,
+    })));
+    if (devMode) {
+        routes.set('/admin-ui-plugins.json', {
+            content: buildManifestJSON,
+            contentType: 'application/json',
+            cacheControl: devCacheControl,
+        });
+    }
+    else {
+        const manifestJSON = buildManifestJSON();
+        routes.set('/admin-ui-plugins.json', {
+            content: manifestJSON,
+            contentType: 'application/json',
+            cacheControl: 'public, max-age=0, must-revalidate',
+            etag: `"${contentHash(manifestJSON)}"`,
+        });
+    }
+    for (const plugin of pluginsWithBundles) {
+        const bundlePath = resolvedBundlePaths.get(plugin.name);
+        if (devMode) {
+            routes.set(`/admin-plugins/${plugin.name}.js`, {
+                content: () => readFileSync(bundlePath, 'utf-8'),
+                contentType: 'application/javascript',
+                cacheControl: devCacheControl,
+            });
+        }
+        else {
+            const { content } = pluginBundles.get(plugin.name);
+            routes.set(`/admin-plugins/${plugin.name}.js`, {
+                content,
+                contentType: 'application/javascript',
+                cacheControl: IMMUTABLE_CACHE,
+            });
+        }
+    }
+    return { routes, validPlugins };
+}

package/lib/adminUiTheme.d.ts

@@ -0,0 +1,25 @@
+export interface AdminUIThemeTokens {
+    surface?: string;
+    'surface-subtle'?: string;
+    'surface-raised'?: string;
+    'surface-input'?: string;
+    border?: string;
+    'border-subtle'?: string;
+    'text-primary'?: string;
+    'text-secondary'?: string;
+    'text-muted'?: string;
+    'text-on-dark'?: string;
+    accent?: string;
+    'accent-hover'?: string;
+    danger?: string;
+    'danger-surface'?: string;
+    success?: string;
+    warning?: string;
+    'focus-ring'?: string;
+    'text-on-accent'?: string;
+}
+export interface AdminUIThemeConfig {
+    light?: AdminUIThemeTokens;
+    dark?: AdminUIThemeTokens;
+}
+export declare const generateThemeCSS: (theme?: AdminUIThemeConfig) => string;

package/lib/adminUiTheme.js

@@ -0,0 +1,34 @@
+const CSS_VALUE_RE = /^[a-zA-Z0-9#().,/%\s\-_]+$/;
+const sanitizeCSSValue = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed || !CSS_VALUE_RE.test(trimmed))
+        return null;
+    return trimmed;
+};
+const buildTokenBlock = (selector, tokens) => {
+    const vars = Object.entries(tokens)
+        .map(([key, value]) => {
+        const safe = sanitizeCSSValue(value);
+        return safe ? `  --token-${key}: ${safe};` : null;
+    })
+        .filter(Boolean);
+    if (vars.length === 0)
+        return null;
+    return `${selector} {\n${vars.join('\n')}\n}`;
+};
+export const generateThemeCSS = (theme) => {
+    if (!theme)
+        return '/* default theme */';
+    const blocks = [];
+    if (theme.light) {
+        const block = buildTokenBlock(':root:root', theme.light);
+        if (block)
+            blocks.push(block);
+    }
+    if (theme.dark) {
+        const block = buildTokenBlock('.dark.dark', theme.dark);
+        if (block)
+            blocks.push(block);
+    }
+    return blocks.length > 0 ? blocks.join('\n\n') : '/* default theme */';
+};

package/lib/chat/generateImageHandler.d.ts

@@ -2,11 +2,277 @@ import type * as aiTypes from 'ai';
 declare const generateImageHandler: (req: any) => ({ model, uploadUrl, }: {
     model: aiTypes.ImageModel;
     uploadUrl?: string;
-}) => aiTypes.Tool<{
-    prompt: string;
-    size?: "512x512" | "768x768" | "1024x1024" | "512x896" | "640x1120" | "768x1344" | "1024x1792" | "896x512" | "1120x640" | "1344x768" | "1792x1024" | undefined;
-}, string | {
-    imageUrl: any;
-    prompt: string;
-}>;
+}) => ({
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    metadata?: import("@ai-sdk/provider").JSONObject;
+    inputSchema: aiTypes.FlexibleSchema<{
+        prompt: any;
+        size?: string | undefined;
+    }>;
+    contextSchema?: aiTypes.FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
+    onInputStart?: ((options: aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputDelta?: ((options: {
+        inputTextDelta: string;
+    } & aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputAvailable?: ((options: {
+        input: {
+            prompt: any;
+            size?: string | undefined;
+        };
+    } & aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            prompt: any;
+            size?: string | undefined;
+        };
+        output: NoInfer<string | {
+            imageUrl: any;
+            prompt: any;
+        }>;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    outputSchema?: aiTypes.FlexibleSchema<string | {
+        imageUrl: any;
+        prompt: any;
+    }> | undefined;
+    execute: aiTypes.ToolExecuteFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, string | {
+        imageUrl: any;
+        prompt: any;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+} & {
+    description?: string | ((options: {
+        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
+        experimental_sandbox?: aiTypes.Experimental_SandboxSession;
+    }) => string) | undefined;
+    strict?: boolean;
+    inputExamples?: {
+        input: NoInfer<{
+            prompt: any;
+            size?: string | undefined;
+        }>;
+    }[] | undefined;
+    id?: never;
+    isProviderExecuted?: never;
+    args?: never;
+    supportsDeferredResults?: never;
+} & {
+    type?: undefined | "function";
+} & {
+    execute: aiTypes.ToolExecuteFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, string | {
+        imageUrl: any;
+        prompt: any;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+}) | ({
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    metadata?: import("@ai-sdk/provider").JSONObject;
+    inputSchema: aiTypes.FlexibleSchema<{
+        prompt: any;
+        size?: string | undefined;
+    }>;
+    contextSchema?: aiTypes.FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
+    onInputStart?: ((options: aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputDelta?: ((options: {
+        inputTextDelta: string;
+    } & aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputAvailable?: ((options: {
+        input: {
+            prompt: any;
+            size?: string | undefined;
+        };
+    } & aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            prompt: any;
+            size?: string | undefined;
+        };
+        output: NoInfer<string | {
+            imageUrl: any;
+            prompt: any;
+        }>;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    outputSchema?: aiTypes.FlexibleSchema<string | {
+        imageUrl: any;
+        prompt: any;
+    }> | undefined;
+    execute: aiTypes.ToolExecuteFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, string | {
+        imageUrl: any;
+        prompt: any;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+} & {
+    description?: string | ((options: {
+        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
+        experimental_sandbox?: aiTypes.Experimental_SandboxSession;
+    }) => string) | undefined;
+    strict?: boolean;
+    inputExamples?: {
+        input: NoInfer<{
+            prompt: any;
+            size?: string | undefined;
+        }>;
+    }[] | undefined;
+    id?: never;
+    isProviderExecuted?: never;
+    args?: never;
+    supportsDeferredResults?: never;
+} & {
+    type: "dynamic";
+} & {
+    execute: aiTypes.ToolExecuteFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, string | {
+        imageUrl: any;
+        prompt: any;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+}) | ({
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    metadata?: import("@ai-sdk/provider").JSONObject;
+    inputSchema: aiTypes.FlexibleSchema<{
+        prompt: any;
+        size?: string | undefined;
+    }>;
+    contextSchema?: aiTypes.FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
+    onInputStart?: ((options: aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputDelta?: ((options: {
+        inputTextDelta: string;
+    } & aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputAvailable?: ((options: {
+        input: {
+            prompt: any;
+            size?: string | undefined;
+        };
+    } & aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            prompt: any;
+            size?: string | undefined;
+        };
+        output: NoInfer<string | {
+            imageUrl: any;
+            prompt: any;
+        }>;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    outputSchema?: aiTypes.FlexibleSchema<string | {
+        imageUrl: any;
+        prompt: any;
+    }> | undefined;
+    execute: aiTypes.ToolExecuteFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, string | {
+        imageUrl: any;
+        prompt: any;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+} & {
+    type: "provider";
+    id: `${string}.${string}`;
+    args: Record<string, unknown>;
+    description?: never;
+    strict?: never;
+    inputExamples?: never;
+} & {
+    isProviderExecuted: false;
+    supportsDeferredResults?: never;
+} & {
+    execute: aiTypes.ToolExecuteFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, string | {
+        imageUrl: any;
+        prompt: any;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+}) | ({
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    metadata?: import("@ai-sdk/provider").JSONObject;
+    inputSchema: aiTypes.FlexibleSchema<{
+        prompt: any;
+        size?: string | undefined;
+    }>;
+    contextSchema?: aiTypes.FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
+    onInputStart?: ((options: aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputDelta?: ((options: {
+        inputTextDelta: string;
+    } & aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputAvailable?: ((options: {
+        input: {
+            prompt: any;
+            size?: string | undefined;
+        };
+    } & aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            prompt: any;
+            size?: string | undefined;
+        };
+        output: NoInfer<string | {
+            imageUrl: any;
+            prompt: any;
+        }>;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    outputSchema?: aiTypes.FlexibleSchema<string | {
+        imageUrl: any;
+        prompt: any;
+    }> | undefined;
+    execute: aiTypes.ToolExecuteFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, string | {
+        imageUrl: any;
+        prompt: any;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+} & {
+    type: "provider";
+    id: `${string}.${string}`;
+    args: Record<string, unknown>;
+    description?: never;
+    strict?: never;
+    inputExamples?: never;
+} & {
+    isProviderExecuted: true;
+    supportsDeferredResults?: boolean;
+} & {
+    execute: aiTypes.ToolExecuteFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, string | {
+        imageUrl: any;
+        prompt: any;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+});
 export default generateImageHandler;

package/lib/chat/utils.d.ts

@@ -1,4 +1,6 @@
 import type * as aiTypes from 'ai';
+import type { ServerResponse } from 'node:http';
+export declare const logOptionalPeerLoadError: (packageName: string, error: unknown) => void;
 export type StreamTextParams = Parameters<typeof aiTypes.streamText>[0];
 export type ChatConfiguration = Omit<StreamTextParams, 'messages'> & {
     unchainedMCPUrl?: string;
@@ -8,4 +10,10 @@ export type ChatConfiguration = Omit<StreamTextParams, 'messages'> & {
     };
 };
 export declare const errorHandler: (error: any) => string;
+export declare const chatErrorStatus: (error: unknown) => number;
+export declare const createChatRequestLifecycle: (response: ServerResponse, configuredSignal?: AbortSignal) => {
+    signal: AbortSignal;
+    setClientClose(closeClient: () => Promise<void>): void;
+    close: () => Promise<void>;
+};
 export declare const categorizeTools: (toolName: string) => string;