glirastes 0.3.0 → 0.3.2

package/dist/cjs/react/utils/create-tool-result-handler.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createToolResultHandler = createToolResultHandler;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function extractUiAction(result) {
+    if (result.uiAction !== undefined)
+        return result.uiAction;
+    if (isRecord(result.data) && result.data.uiAction !== undefined) {
+        return result.data.uiAction;
+    }
+    return undefined;
+}
+function hasSuccessfulResult(result) {
+    if (result.success === true)
+        return true;
+    return isRecord(result.data) && result.data.success === true;
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return '[unserializable]';
+    }
+}
+/**
+ * Create a tool result handler that processes tool outputs for UI-side actions.
+ *
+ * Extracts `uiAction` from tool results, validates against an optional schema,
+ * and routes to the appropriate handler based on action type.
+ *
+ * Supports convention-based entity actions (`{entity}-created`, `{entity}-updated`,
+ * `{entity}-deleted`), `run-client-action`, and custom action handlers.
+ *
+ * @example
+ * ```ts
+ * import { createToolResultHandler } from '../index.js';
+ * import { dispatchAiClientAction } from '../ui/index.js';
+ *
+ * const handleToolResult = createToolResultHandler({
+ *   uiActionSchema: mySchema,
+ *   entityListDestinations: { task: '/tasks', group: '/groups' },
+ *   onNavigate: (dest) => router.push(dest),
+ *   onOpenDetail: (entity, id) => openPanel(entity, id),
+ *   onClientAction: (actionId, payload) => dispatchAiClientAction({ actionId, payload }),
+ *   onSuccess: () => window.dispatchEvent(new CustomEvent('data-refresh')),
+ *   actionHandlers: {
+ *     'set-filters': (action) => {
+ *       window.dispatchEvent(new CustomEvent('ai-set-filters', { detail: action.filters }));
+ *     },
+ *   },
+ * });
+ *
+ * // Wire into AiChatProvider or use in useEffect:
+ * <AiChatProvider onToolResult={handleToolResult} ... />
+ * ```
+ */
+function createToolResultHandler(config) {
+    const { uiActionSchema, actionHandlers = {}, entityListDestinations = {}, onNavigate, onOpenDetail, onClientAction, onSuccess, toolFallbacks = {}, clientActionDedupe, } = config;
+    const dedupeEnabled = clientActionDedupe?.enabled ?? false;
+    const dedupeWindowMs = clientActionDedupe?.windowMs ?? 1500;
+    const dedupeActionIds = clientActionDedupe?.actionIds ?? ['navigate'];
+    const recentClientActions = new Map();
+    return (toolName, result) => {
+        if (!isRecord(result))
+            return;
+        let handledByAction = false;
+        const uiActionCandidate = extractUiAction(result);
+        if (uiActionCandidate !== undefined) {
+            // Normalize to array for uniform processing (supports compound actions)
+            const candidates = Array.isArray(uiActionCandidate)
+                ? uiActionCandidate
+                : [uiActionCandidate];
+            for (const candidate of candidates) {
+                // Validate if schema provided
+                let uiAction;
+                if (uiActionSchema) {
+                    const parsed = uiActionSchema.safeParse(candidate);
+                    if (!parsed.success) {
+                        console.warn('[AI Chat] Invalid uiAction dropped:', parsed.error.issues);
+                        continue;
+                    }
+                    uiAction = parsed.data;
+                }
+                else {
+                    if (!isRecord(candidate))
+                        continue;
+                    uiAction = candidate;
+                }
+                const actionType = typeof uiAction.type === 'string' ? uiAction.type : '';
+                // Convention-based entity actions: {entity}-{created|updated|deleted}
+                const entityMatch = actionType.match(/^(\w+)-(created|updated|deleted)$/);
+                if (entityMatch) {
+                    const [, entity, action] = entityMatch;
+                    const idKey = `${entity}Id`;
+                    const entityId = uiAction[idKey];
+                    if (action === 'created' && entityListDestinations[entity] && onNavigate) {
+                        onNavigate(entityListDestinations[entity], entity);
+                        handledByAction = true;
+                    }
+                    if (action === 'updated' && typeof entityId === 'string' && onOpenDetail) {
+                        onOpenDetail(entity, entityId);
+                        handledByAction = true;
+                    }
+                    if (action === 'deleted' && entityListDestinations[entity] && onNavigate) {
+                        onNavigate(entityListDestinations[entity], entity);
+                        handledByAction = true;
+                    }
+                }
+                // run-client-action
+                if (actionType === 'run-client-action' && onClientAction) {
+                    const actionId = typeof uiAction.actionId === 'string' ? uiAction.actionId : '';
+                    const payload = isRecord(uiAction.payload) ? uiAction.payload : undefined;
+                    if (actionId) {
+                        if (dedupeEnabled && dedupeActionIds.includes(actionId)) {
+                            const key = `${actionId}:${safeStringify(payload)}`;
+                            const now = Date.now();
+                            const lastSeen = recentClientActions.get(key);
+                            if (lastSeen && now - lastSeen < dedupeWindowMs) {
+                                handledByAction = true;
+                                continue;
+                            }
+                            recentClientActions.set(key, now);
+                        }
+                        onClientAction(actionId, payload);
+                        handledByAction = true;
+                    }
+                }
+                // Built-in navigate: route through onClientAction so consumers
+                // only need useAiClientAction('navigate', ...) — no raw CustomEvent.
+                if (actionType === 'navigate' && onClientAction) {
+                    const path = typeof uiAction.path === 'string' ? uiAction.path : '';
+                    if (path) {
+                        if (dedupeEnabled && dedupeActionIds.includes('navigate')) {
+                            const key = `navigate:${path}`;
+                            const now = Date.now();
+                            const lastSeen = recentClientActions.get(key);
+                            if (lastSeen && now - lastSeen < dedupeWindowMs) {
+                                handledByAction = true;
+                                continue;
+                            }
+                            recentClientActions.set(key, now);
+                        }
+                        onClientAction('navigate', { path });
+                        handledByAction = true;
+                        continue; // skip actionHandlers fallback for navigate
+                    }
+                }
+                // Custom action handlers
+                if (actionHandlers[actionType]) {
+                    actionHandlers[actionType](uiAction);
+                    handledByAction = true;
+                }
+            }
+        }
+        const successful = hasSuccessfulResult(result);
+        // Tool-specific fallback when no action was processed
+        if (!handledByAction && successful && toolFallbacks[toolName]) {
+            toolFallbacks[toolName](result);
+        }
+        // Global success callback
+        if (successful && onSuccess) {
+            onSuccess(toolName, result);
+        }
+    };
+}

package/dist/cjs/react/utils/mention-markup.d.ts

@@ -0,0 +1,13 @@
+import type { Mention, MentionData, MentionSerializationConfig } from '../types.js';
+export declare function stripContextBlocks(text: string): string;
+export declare function inferMentionPrefix(type: string): string;
+export declare function normalizeMentionSlug(value: string): string;
+export type MentionTextSegment = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'mention';
+    mention: Mention;
+};
+export declare function parseMentionSegments(text: string): MentionTextSegment[];
+export declare function serializeMentionsForSend(text: string, mentions: MentionData[], options?: MentionSerializationConfig): string;

package/dist/cjs/react/utils/mention-markup.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripContextBlocks = stripContextBlocks;
+exports.inferMentionPrefix = inferMentionPrefix;
+exports.normalizeMentionSlug = normalizeMentionSlug;
+exports.parseMentionSegments = parseMentionSegments;
+exports.serializeMentionsForSend = serializeMentionsForSend;
+const CONTEXT_BLOCK_RE = /<!--\s*context:[\s\S]*?-->\s*/gi;
+const MENTION_MARKER_RE = /\{\{mention:([^:}]+):([^:}]+):([^}]+)\}\}/g;
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function stripContextBlocks(text) {
+    return text.replace(CONTEXT_BLOCK_RE, '').trimStart();
+}
+function inferMentionPrefix(type) {
+    return type === 'task' || type === 'command' ? '/' : '@';
+}
+function normalizeMentionSlug(value) {
+    return value
+        .toLowerCase()
+        .normalize('NFKD')
+        .replace(/[^\w\s-]/g, '')
+        .trim()
+        .replace(/\s+/g, '-');
+}
+function parseMentionSegments(text) {
+    const segments = [];
+    let cursor = 0;
+    let match;
+    MENTION_MARKER_RE.lastIndex = 0;
+    while ((match = MENTION_MARKER_RE.exec(text)) !== null) {
+        const [raw, type, id, label] = match;
+        const start = match.index;
+        const end = start + raw.length;
+        if (start > cursor) {
+            segments.push({ kind: 'text', text: text.slice(cursor, start) });
+        }
+        segments.push({
+            kind: 'mention',
+            mention: {
+                id,
+                type,
+                displayName: label,
+                prefix: inferMentionPrefix(type),
+            },
+        });
+        cursor = end;
+    }
+    if (cursor < text.length) {
+        segments.push({ kind: 'text', text: text.slice(cursor) });
+    }
+    return segments;
+}
+function buildContextBlock(mentions, label) {
+    if (mentions.length === 0)
+        return null;
+    const summary = mentions
+        .map((m) => {
+        const displayName = m.displayName ?? m.label ?? m.id;
+        return `${displayName} (ID: ${m.id})`;
+    })
+        .join(', ');
+    return `<!--context:[${label}: ${summary}]--> `;
+}
+function serializeMentionsForSend(text, mentions, options) {
+    const enabled = options?.enabled ?? true;
+    if (!enabled || mentions.length === 0) {
+        return stripContextBlocks(text);
+    }
+    const cleaned = stripContextBlocks(text);
+    let nextText = cleaned;
+    const serializedMentions = [];
+    for (const mention of mentions) {
+        const id = typeof mention.id === 'string' ? mention.id : '';
+        const type = typeof mention.type === 'string' ? mention.type : '';
+        if (!id || !type)
+            continue;
+        const label = typeof mention.label === 'string'
+            ? mention.label
+            : typeof mention.displayName === 'string'
+                ? mention.displayName
+                : id;
+        const slug = typeof mention.slug === 'string' && mention.slug.trim().length > 0
+            ? mention.slug.trim()
+            : normalizeMentionSlug(label);
+        const prefix = typeof mention.prefix === 'string' && mention.prefix.length > 0
+            ? mention.prefix
+            : inferMentionPrefix(type);
+        const token = `${prefix}${slug}`;
+        const marker = `{{mention:${type}:${id}:${label}}}`;
+        const tokenPattern = new RegExp(`(^|\\s)${escapeRegex(token)}(?=\\s|$)`, 'g');
+        let wasInserted = false;
+        nextText = nextText.replace(tokenPattern, (fullMatch, leading) => {
+            wasInserted = true;
+            return `${leading}${marker}`;
+        });
+        if (wasInserted) {
+            serializedMentions.push({
+                id,
+                type,
+                label,
+                displayName: label,
+                slug,
+                prefix,
+            });
+        }
+    }
+    if (options?.includeContextBlock) {
+        const contextLabel = options.contextLabel ?? 'Referenced entities';
+        const contextBlock = buildContextBlock(serializedMentions, contextLabel);
+        if (contextBlock) {
+            return `${contextBlock}${nextText}`.trim();
+        }
+    }
+    return nextText;
+}

package/dist/cjs/react/utils/merge-pipeline-steps.d.ts

@@ -0,0 +1,19 @@
+import type { PipelineStepReport } from '../types.js';
+/**
+ * Merge incoming pipeline steps with existing stable state.
+ *
+ * Handles:
+ * - Synthetic resume steps (step 0 with stop reason after approval waits)
+ * - Timestamp-based conflict resolution for duplicate step numbers
+ * - Stable ordering by step number
+ *
+ * @example
+ * ```tsx
+ * const [stableSteps, setStableSteps] = useState<PipelineStepReport[]>([]);
+ *
+ * useEffect(() => {
+ *   setStableSteps((prev) => mergePipelineSteps(prev, pipelineSteps));
+ * }, [pipelineSteps]);
+ * ```
+ */
+export declare function mergePipelineSteps(previous: PipelineStepReport[], incoming: PipelineStepReport[]): PipelineStepReport[];

package/dist/cjs/react/utils/merge-pipeline-steps.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergePipelineSteps = mergePipelineSteps;
+function parseStepTimestamp(value) {
+    const ts = Date.parse(value);
+    return Number.isFinite(ts) ? ts : null;
+}
+/**
+ * Merge incoming pipeline steps with existing stable state.
+ *
+ * Handles:
+ * - Synthetic resume steps (step 0 with stop reason after approval waits)
+ * - Timestamp-based conflict resolution for duplicate step numbers
+ * - Stable ordering by step number
+ *
+ * @example
+ * ```tsx
+ * const [stableSteps, setStableSteps] = useState<PipelineStepReport[]>([]);
+ *
+ * useEffect(() => {
+ *   setStableSteps((prev) => mergePipelineSteps(prev, pipelineSteps));
+ * }, [pipelineSteps]);
+ * ```
+ */
+function mergePipelineSteps(previous, incoming) {
+    if (incoming.length === 0)
+        return [];
+    const sorted = [...incoming].sort((a, b) => a.stepNumber - b.stepNumber);
+    const previousHasWorkflow = previous.some((step) => step.toolCalls.length > 0 || step.requiresApproval);
+    const firstIncoming = sorted[0];
+    const isSyntheticResumeStep = firstIncoming &&
+        firstIncoming.stepNumber === 0 &&
+        firstIncoming.finishReason === 'stop' &&
+        firstIncoming.toolCalls.length === 0 &&
+        firstIncoming.toolResults === 0 &&
+        !firstIncoming.requiresApproval;
+    // After an approval wait, the server sends a synthetic step 0 with finishReason='stop'.
+    // Instead of replacing previous steps, append it as a final step.
+    if (isSyntheticResumeStep && previousHasWorkflow) {
+        const resolved = previous.map((step) => step.requiresApproval
+            ? { ...step, requiresApproval: false, pendingApprovals: 0 }
+            : step);
+        const alreadyFinalized = resolved.some((step) => step.finishReason === 'stop' && step.toolCalls.length === 0);
+        if (alreadyFinalized)
+            return resolved;
+        return [
+            ...resolved,
+            { ...firstIncoming, stepNumber: resolved.length },
+        ];
+    }
+    // Also clear approval flags when execution continues with tool calls after approval.
+    // This handles cases where followup tools (like suggest_followups) execute after
+    // approval is granted, instead of getting a synthetic resume step.
+    const previousHadApprovals = previous.some((step) => step.requiresApproval);
+    const incomingAllCleared = sorted.every((step) => step.pendingApprovals === 0);
+    const shouldClearFlags = previousHadApprovals && incomingAllCleared && sorted.length > 0;
+    if (shouldClearFlags) {
+        previous = previous.map((step) => step.requiresApproval
+            ? { ...step, requiresApproval: false, pendingApprovals: 0 }
+            : step);
+    }
+    // Standard merge: keep newer timestamps when step numbers collide
+    const mergedByStep = new Map();
+    for (const step of previous)
+        mergedByStep.set(step.stepNumber, step);
+    for (const step of sorted) {
+        const existing = mergedByStep.get(step.stepNumber);
+        if (!existing) {
+            mergedByStep.set(step.stepNumber, step);
+            continue;
+        }
+        const existingTs = parseStepTimestamp(existing.createdAt) ?? 0;
+        const incomingTs = parseStepTimestamp(step.createdAt) ?? 0;
+        if (incomingTs >= existingTs) {
+            mergedByStep.set(step.stepNumber, step);
+        }
+    }
+    return Array.from(mergedByStep.entries())
+        .sort((a, b) => a[0] - b[0])
+        .map(([, step]) => step);
+}

package/dist/cjs/react/utils/sanitize-stored-messages.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Sanitize raw stored messages to remove incomplete tool calls that would
+ * cause `AI_MissingToolResultsError` when sent to the API.
+ *
+ * This handles the case where a user closes the chat or refreshes while
+ * a tool approval is pending, leaving orphaned tool calls in the history.
+ *
+ * Call this when loading messages from storage (sessionStorage, localStorage,
+ * or any backend) before passing them to `setMessages()` or the SDK provider.
+ *
+ * @example
+ * ```ts
+ * const sessionAdapter: SessionConfig = {
+ *   load: () => {
+ *     const raw = JSON.parse(sessionStorage.getItem('chat') ?? '[]');
+ *     return sanitizeStoredMessages(raw);
+ *   },
+ *   save: (_, msgs) => sessionStorage.setItem('chat', JSON.stringify(msgs)),
+ *   clear: () => sessionStorage.removeItem('chat'),
+ * };
+ * ```
+ */
+export declare function sanitizeStoredMessages(messages: unknown[]): unknown[];

package/dist/cjs/react/utils/sanitize-stored-messages.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeStoredMessages = sanitizeStoredMessages;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+/**
+ * Sanitize raw stored messages to remove incomplete tool calls that would
+ * cause `AI_MissingToolResultsError` when sent to the API.
+ *
+ * This handles the case where a user closes the chat or refreshes while
+ * a tool approval is pending, leaving orphaned tool calls in the history.
+ *
+ * Call this when loading messages from storage (sessionStorage, localStorage,
+ * or any backend) before passing them to `setMessages()` or the SDK provider.
+ *
+ * @example
+ * ```ts
+ * const sessionAdapter: SessionConfig = {
+ *   load: () => {
+ *     const raw = JSON.parse(sessionStorage.getItem('chat') ?? '[]');
+ *     return sanitizeStoredMessages(raw);
+ *   },
+ *   save: (_, msgs) => sessionStorage.setItem('chat', JSON.stringify(msgs)),
+ *   clear: () => sessionStorage.removeItem('chat'),
+ * };
+ * ```
+ */
+function sanitizeStoredMessages(messages) {
+    return messages
+        .map((message) => {
+        if (!isRecord(message))
+            return message;
+        const parts = Array.isArray(message.parts) ? message.parts : [];
+        const sanitizedParts = parts.filter((part) => {
+            if (!isRecord(part))
+                return true;
+            const partType = typeof part.type === 'string' ? part.type : '';
+            // Remove tool parts stuck in approval-requested state
+            if (partType.startsWith('tool-') && part.state === 'approval-requested') {
+                return false;
+            }
+            return true;
+        });
+        // If all parts were removed, mark for filtering
+        if (sanitizedParts.length === 0 && parts.length > 0) {
+            return null;
+        }
+        return { ...message, parts: sanitizedParts };
+    })
+        .filter((message) => message !== null);
+}

package/dist/cjs/server/adapters/nestjs/chat/ai-chat-auth.guard.d.ts

@@ -0,0 +1,10 @@
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { type AiChatModuleOptions } from './ai-chat-module-options.interface.js';
+export declare class AiChatAuthGuard implements CanActivate {
+    private readonly options;
+    private readonly moduleRef;
+    private guardInstance;
+    constructor(options: AiChatModuleOptions | null, moduleRef: ModuleRef);
+    canActivate(context: ExecutionContext): Promise<boolean>;
+}

package/dist/cjs/server/adapters/nestjs/chat/ai-chat-auth.guard.js

@@ -0,0 +1,42 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiChatAuthGuard = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const ai_chat_module_options_interface_js_1 = require("./ai-chat-module-options.interface.js");
+let AiChatAuthGuard = class AiChatAuthGuard {
+    options;
+    moduleRef;
+    guardInstance = null;
+    constructor(options, moduleRef) {
+        this.options = options;
+        this.moduleRef = moduleRef;
+    }
+    async canActivate(context) {
+        if (!this.options) {
+            return false;
+        }
+        if (!this.guardInstance) {
+            this.guardInstance = await this.moduleRef.create(this.options.authGuard);
+        }
+        return this.guardInstance.canActivate(context);
+    }
+};
+exports.AiChatAuthGuard = AiChatAuthGuard;
+exports.AiChatAuthGuard = AiChatAuthGuard = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(ai_chat_module_options_interface_js_1.AI_CHAT_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object, core_1.ModuleRef])
+], AiChatAuthGuard);

package/dist/cjs/server/adapters/nestjs/chat/ai-chat-module-options.interface.d.ts

@@ -0,0 +1,32 @@
+import type { CanActivate, InjectionToken, ModuleMetadata, OptionalFactoryDependency, Type } from '@nestjs/common';
+import type { LanguageModel } from 'ai';
+import type { AuditEmitter } from '../../../../types.js';
+import type { Lancer } from '../../../lancer/index.js';
+export declare const AI_CHAT_MODULE_OPTIONS: unique symbol;
+export interface AiChatModuleFeatures {
+    speechToText?: boolean;
+}
+export interface AiChatModuleOptions {
+    /** Vercel AI SDK LanguageModel — consumer creates and owns this */
+    model: LanguageModel;
+    /** Project-specific system prompt, static string or factory */
+    systemPrompt: string | ((context: {
+        currentDate: string;
+    }) => string);
+    /** NestJS guard class for HTTP authentication */
+    authGuard: Type<CanActivate>;
+    /** Optional feature toggles */
+    features?: AiChatModuleFeatures;
+    /** Max tool-call steps per chat request (default: 4) */
+    maxSteps?: number;
+    /** Unified audit event callback for compliance logging */
+    onAudit?: AuditEmitter;
+    /** Lancer client for runtime prompt overrides (Pro feature) */
+    lancer?: Lancer;
+}
+export interface AiChatModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    /** Factory that returns options or null to disable the module */
+    useFactory: (...args: any[]) => Promise<AiChatModuleOptions | null> | AiChatModuleOptions | null;
+    /** Injection tokens to pass to useFactory */
+    inject?: (InjectionToken | OptionalFactoryDependency)[];
+}

package/dist/cjs/server/adapters/nestjs/chat/ai-chat-module-options.interface.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AI_CHAT_MODULE_OPTIONS = void 0;
+exports.AI_CHAT_MODULE_OPTIONS = Symbol('AI_CHAT_MODULE_OPTIONS');

package/dist/cjs/server/adapters/nestjs/chat/ai-chat.controller.d.ts

@@ -0,0 +1,11 @@
+import type { Request, Response } from 'express';
+import { AiChatService } from './ai-chat.service.js';
+import { AiChatRequestDto } from './dto/index.js';
+import { type AiChatModuleOptions } from './ai-chat-module-options.interface.js';
+export declare class AiChatController {
+    private readonly options;
+    private readonly aiChatService;
+    private readonly logger;
+    constructor(options: AiChatModuleOptions | null, aiChatService: AiChatService);
+    chat(dto: AiChatRequestDto, req: Request, res: Response): Promise<void>;
+}

package/dist/cjs/server/adapters/nestjs/chat/ai-chat.controller.js

@@ -0,0 +1,80 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var AiChatController_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiChatController = void 0;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const ai_chat_service_js_1 = require("./ai-chat.service.js");
+const index_js_1 = require("./dto/index.js");
+const ai_chat_module_options_interface_js_1 = require("./ai-chat-module-options.interface.js");
+const ai_chat_auth_guard_js_1 = require("./ai-chat-auth.guard.js");
+let AiChatController = AiChatController_1 = class AiChatController {
+    options;
+    aiChatService;
+    logger = new common_1.Logger(AiChatController_1.name);
+    constructor(options, aiChatService) {
+        this.options = options;
+        this.aiChatService = aiChatService;
+    }
+    async chat(dto, req, res) {
+        if (!this.options) {
+            throw new common_1.ServiceUnavailableException('AI chat is not configured');
+        }
+        const authHeader = req.headers.authorization ?? '';
+        this.logger.debug(`Chat request: ${dto.messages.length} messages`);
+        let streamResponse;
+        try {
+            streamResponse = await this.aiChatService.streamChat(dto.messages, authHeader);
+        }
+        catch (error) {
+            this.logger.error(`streamChat() threw: ${error}`, error.stack);
+            throw error;
+        }
+        this.logger.debug(`Stream response status: ${streamResponse.status}`);
+        res.status(streamResponse.status);
+        streamResponse.headers.forEach((value, key) => {
+            res.setHeader(key, value);
+        });
+        if (streamResponse.body) {
+            const reader = streamResponse.body.getReader();
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                res.write(value);
+            }
+        }
+        this.logger.debug('Stream completed');
+        res.end();
+    }
+};
+exports.AiChatController = AiChatController;
+__decorate([
+    (0, common_1.Post)('chat'),
+    (0, swagger_1.ApiOperation)({ summary: 'Stream AI chat response' }),
+    __param(0, (0, common_1.Body)()),
+    __param(1, (0, common_1.Req)()),
+    __param(2, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [index_js_1.AiChatRequestDto, Object, Object]),
+    __metadata("design:returntype", Promise)
+], AiChatController.prototype, "chat", null);
+exports.AiChatController = AiChatController = AiChatController_1 = __decorate([
+    (0, swagger_1.ApiTags)('ai'),
+    (0, common_1.UseGuards)(ai_chat_auth_guard_js_1.AiChatAuthGuard),
+    (0, common_1.Controller)('ai'),
+    __param(0, (0, common_1.Inject)(ai_chat_module_options_interface_js_1.AI_CHAT_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object, ai_chat_service_js_1.AiChatService])
+], AiChatController);