glirastes 0.1.0

package/dist/server/core/index.js

@@ -0,0 +1,787 @@
+import { defineTool } from '../../types.js';
+import { zodToCompactDescription } from './zod-compact.js';
+// ============================================================================
+// Helpers (internal)
+// ============================================================================
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+/**
+ * Default max characters for a serialized tool result (~4000 tokens).
+ * Arrays exceeding this are truncated with a `_truncated` marker.
+ */
+const DEFAULT_MAX_RESULT_CHARS = 16_000;
+/**
+ * Truncate large tool results to prevent LLM context overflow.
+ *
+ * Strategy: find the largest array in the top-level result and
+ * progressively remove items from the end until the serialized
+ * size is under the limit. A `_truncated` object is appended so the
+ * LLM knows the data was cut.
+ */
+export function truncateToolResult(result, maxChars = DEFAULT_MAX_RESULT_CHARS) {
+    if (!isRecord(result))
+        return result;
+    const serialized = JSON.stringify(result);
+    if (serialized.length <= maxChars)
+        return result;
+    // Find the largest array at the top level
+    let largestKey = null;
+    let largestLen = 0;
+    const rec = result;
+    for (const [key, value] of Object.entries(rec)) {
+        if (Array.isArray(value) && value.length > largestLen) {
+            largestKey = key;
+            largestLen = value.length;
+        }
+    }
+    if (!largestKey || largestLen === 0)
+        return result;
+    // Binary-search for the right array length
+    const arr = rec[largestKey];
+    let lo = 1;
+    let hi = arr.length;
+    while (lo < hi) {
+        const mid = Math.floor((lo + hi) / 2);
+        const candidate = {
+            ...rec,
+            [largestKey]: arr.slice(0, mid),
+            _truncated: { field: largestKey, showing: mid, total: arr.length },
+        };
+        if (JSON.stringify(candidate).length <= maxChars) {
+            lo = mid + 1;
+        }
+        else {
+            hi = mid;
+        }
+    }
+    const finalCount = Math.max(lo - 1, 1);
+    return {
+        ...rec,
+        [largestKey]: arr.slice(0, finalCount),
+        _truncated: { field: largestKey, showing: finalCount, total: arr.length },
+    };
+}
+export function buildPath(pathTemplate, payload) {
+    return pathTemplate.replace(/:([A-Za-z0-9_]+)/g, (_full, paramName) => {
+        const value = payload[paramName];
+        if (value === undefined || value === null || value === '') {
+            throw new Error(`Missing required path parameter: "${paramName}" for ${pathTemplate}`);
+        }
+        delete payload[paramName];
+        return encodeURIComponent(String(value));
+    });
+}
+export function stripPathParams(pathTemplate, payload) {
+    const pathParamNames = new Set();
+    for (const match of pathTemplate.matchAll(/:([A-Za-z0-9_]+)/g)) {
+        pathParamNames.add(match[1]);
+    }
+    const remaining = {};
+    for (const [key, value] of Object.entries(payload)) {
+        if (!pathParamNames.has(key)) {
+            remaining[key] = value;
+        }
+    }
+    return remaining;
+}
+export function buildQueryString(payload) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(payload)) {
+        if (value === undefined || value === null || value === '')
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (item === undefined || item === null || item === '')
+                    continue;
+                params.append(key, String(item));
+            }
+            continue;
+        }
+        params.append(key, String(value));
+    }
+    const query = params.toString();
+    return query ? `?${query}` : '';
+}
+// ============================================================================
+// Template Interpolation
+// ============================================================================
+export function applyTemplateValue(value, input, responseData) {
+    if (typeof value === 'string' && value.startsWith('$')) {
+        const key = value.slice(1);
+        if (key in responseData)
+            return responseData[key];
+        if (key in input)
+            return input[key];
+        return null;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => applyTemplateValue(item, input, responseData));
+    }
+    if (isRecord(value)) {
+        const output = {};
+        for (const [key, nested] of Object.entries(value)) {
+            output[key] = applyTemplateValue(nested, input, responseData);
+        }
+        return output;
+    }
+    return value;
+}
+function buildSuccessUiAction(template, input, responseData) {
+    if (!template)
+        return undefined;
+    return applyTemplateValue(template, input, responseData);
+}
+// ============================================================================
+// UI Pattern Builders
+// ============================================================================
+function getNestedValue(obj, path) {
+    const parts = path.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined)
+            return undefined;
+        if (typeof current !== 'object')
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+function buildFilterAndNavigateAction(pattern, input, response) {
+    if (pattern.condition) {
+        const conditionValue = getNestedValue(response, pattern.condition) ??
+            getNestedValue(input, pattern.condition);
+        if (!conditionValue)
+            return undefined;
+    }
+    const filters = {};
+    const mapping = pattern.filterMapping ?? {};
+    const arrayFields = new Set(pattern.arrayFields ?? ['status', 'priority', 'assignee']);
+    for (const [filterKey, responseField] of Object.entries(mapping)) {
+        const value = getNestedValue(response, responseField) ??
+            getNestedValue(input, responseField);
+        if (value === undefined || value === null)
+            continue;
+        if (arrayFields.has(filterKey)) {
+            filters[filterKey] = Array.isArray(value) ? value : [value];
+        }
+        else if (typeof value === 'string') {
+            filters[filterKey] = value;
+        }
+    }
+    const hasFilters = Object.keys(filters).length > 0;
+    if (!hasFilters && !pattern.condition) {
+        return { type: 'navigate-and-filter', destination: pattern.target };
+    }
+    if (!hasFilters)
+        return undefined;
+    return {
+        type: 'navigate-and-filter',
+        destination: pattern.target,
+        filters,
+    };
+}
+function buildOpenDetailAction(pattern, response) {
+    const id = getNestedValue(response, pattern.idField);
+    if (!id || typeof id !== 'string')
+        return undefined;
+    return {
+        type: 'run-client-action',
+        actionId: `${pattern.entity}-details.open`,
+        payload: { [`${pattern.entity}Id`]: id },
+    };
+}
+function buildOpenDialogAction(pattern, response) {
+    const payload = {};
+    if (pattern.idField) {
+        const id = getNestedValue(response, pattern.idField);
+        if (id && typeof id === 'string') {
+            payload.entityId = id;
+        }
+    }
+    return {
+        type: 'run-client-action',
+        actionId: `${pattern.dialog}-dialog.open`,
+        payload: Object.keys(payload).length > 0 ? payload : undefined,
+    };
+}
+function buildRefreshAction(pattern) {
+    return {
+        type: 'run-client-action',
+        actionId: `${pattern.target}.refresh`,
+    };
+}
+function buildToastAction(pattern, response) {
+    let message = pattern.message;
+    if (message.startsWith('$')) {
+        const fieldValue = getNestedValue(response, message.slice(1));
+        message = typeof fieldValue === 'string' ? fieldValue : pattern.message;
+    }
+    return {
+        type: 'run-client-action',
+        actionId: 'toast.show',
+        payload: { message, variant: pattern.variant ?? 'default' },
+    };
+}
+/**
+ * Build a uiAction from a UiPattern definition + runtime data.
+ */
+export function buildUiActionFromPattern(pattern, input, response) {
+    switch (pattern.type) {
+        case 'filter-and-navigate':
+            return buildFilterAndNavigateAction(pattern, input, response);
+        case 'open-detail':
+            return buildOpenDetailAction(pattern, response);
+        case 'open-dialog':
+            return buildOpenDialogAction(pattern, response);
+        case 'refresh':
+            return buildRefreshAction(pattern);
+        case 'toast':
+            return buildToastAction(pattern, response);
+        default:
+            return undefined;
+    }
+}
+/**
+ * Build uiActions from an array of UiPattern definitions.
+ * Filters out undefined results (patterns whose conditions were not met).
+ */
+function buildUiActionsFromPatterns(patterns, input, response) {
+    const results = [];
+    for (const pattern of patterns) {
+        const action = buildUiActionFromPattern(pattern, input, response);
+        if (action !== undefined) {
+            results.push(action);
+        }
+    }
+    return results;
+}
+// ============================================================================
+// UI Action Validation
+// ============================================================================
+/**
+ * Validates and normalizes optional uiAction inside tool results.
+ * Invalid actions are dropped so frontend event handling stays deterministic.
+ *
+ * @param result - Tool execution result (may contain uiAction)
+ * @param uiActionSchema - Zod schema to validate against (from createUiActionSchema)
+ */
+export function normalizeResultUiAction(result, uiActionSchema) {
+    if (!isRecord(result) || !('uiAction' in result))
+        return result;
+    if (!uiActionSchema)
+        return result; // No schema provided, pass through
+    const candidate = result.uiAction;
+    // Array of uiActions: validate each element, keep valid ones
+    if (Array.isArray(candidate)) {
+        const validActions = [];
+        for (const item of candidate) {
+            const parsed = uiActionSchema.safeParse(item);
+            if (parsed.success) {
+                validActions.push(parsed.data);
+            }
+        }
+        if (validActions.length > 0) {
+            return { ...result, uiAction: validActions };
+        }
+        const { uiAction: _invalid, ...rest } = result;
+        return { ...rest, warning: 'All UI actions in array were invalid and dropped.' };
+    }
+    // Single uiAction: existing logic
+    const parsed = uiActionSchema.safeParse(candidate);
+    if (parsed.success) {
+        return { ...result, uiAction: parsed.data };
+    }
+    const { uiAction: _invalid, ...rest } = result;
+    return { ...rest, warning: 'Invalid UI action dropped.' };
+}
+// ============================================================================
+// Endpoint Tool Definition → Tool Conversion
+// ============================================================================
+/**
+ * Convert an endpoint tool definition into a Tool.
+ * Uses callEndpoint from the ToolContext to execute HTTP requests.
+ */
+export function endpointToolToTool(endpointTool) {
+    let description = endpointTool.description;
+    if (endpointTool.outputSchema) {
+        description += `\n\nReturns: ${zodToCompactDescription(endpointTool.outputSchema)}`;
+    }
+    return defineTool({
+        id: endpointTool.id,
+        description,
+        inputSchema: endpointTool.inputSchema,
+        outputSchema: endpointTool.outputSchema,
+        method: endpointTool.method,
+        needsApproval: endpointTool.needsApproval ??
+            (endpointTool.method === 'GET' ? false : true),
+        execute: async (rawInput, context) => {
+            const endpointContext = context;
+            if (!endpointContext.callEndpoint) {
+                throw new Error('EndpointToolContext with callEndpoint is required for endpoint tools.');
+            }
+            const inputPayload = isRecord(rawInput) ? { ...rawInput } : {};
+            const endpointPath = buildPath(endpointTool.path, inputPayload);
+            const requestPayload = stripPathParams(endpointTool.path, inputPayload);
+            const requestPath = endpointTool.method === 'GET' || endpointTool.method === 'DELETE'
+                ? `${endpointPath}${buildQueryString(requestPayload)}`
+                : endpointPath;
+            const requestBody = endpointTool.method === 'GET' || endpointTool.method === 'DELETE'
+                ? undefined
+                : Object.keys(requestPayload).length > 0
+                    ? requestPayload
+                    : undefined;
+            const response = await endpointContext.callEndpoint({
+                method: endpointTool.method,
+                path: requestPath,
+                body: requestBody,
+            });
+            if (!response.ok) {
+                return {
+                    success: false,
+                    error: response.error ?? `Endpoint failed (${response.status})`,
+                };
+            }
+            const responseData = isRecord(response.data)
+                ? response.data
+                : { data: response.data };
+            // Priority: 1) Response uiAction, 2) uiPattern, 3) uiActionOnSuccess template
+            let uiAction;
+            if ('uiAction' in responseData && responseData.uiAction !== undefined) {
+                // Response-provided uiAction: pass through as-is (single or array)
+                if (Array.isArray(responseData.uiAction)) {
+                    const filtered = responseData.uiAction.filter(isRecord);
+                    uiAction = filtered.length > 0 ? filtered : undefined;
+                }
+                else if (isRecord(responseData.uiAction)) {
+                    uiAction = responseData.uiAction;
+                }
+            }
+            else if (endpointTool.uiPattern) {
+                if (Array.isArray(endpointTool.uiPattern)) {
+                    const actions = buildUiActionsFromPatterns(endpointTool.uiPattern, inputPayload, responseData);
+                    uiAction = actions.length > 0 ? actions : undefined;
+                }
+                else {
+                    uiAction = buildUiActionFromPattern(endpointTool.uiPattern, inputPayload, responseData);
+                }
+            }
+            else if (endpointTool.uiActionOnSuccess) {
+                if (Array.isArray(endpointTool.uiActionOnSuccess)) {
+                    const actions = [];
+                    for (const template of endpointTool.uiActionOnSuccess) {
+                        const action = buildSuccessUiAction(template, inputPayload, responseData);
+                        if (action)
+                            actions.push(action);
+                    }
+                    uiAction = actions.length > 0 ? actions : undefined;
+                }
+                else {
+                    uiAction = buildSuccessUiAction(endpointTool.uiActionOnSuccess, inputPayload, responseData);
+                }
+            }
+            return {
+                success: true,
+                ...responseData,
+                ...(uiAction ? { uiAction } : {}),
+            };
+        },
+    });
+}
+/**
+ * Convert an array of endpoint tools into a ToolRegistry.
+ */
+export function endpointToolsToRegistry(endpointTools) {
+    const registry = {};
+    for (const endpointTool of endpointTools) {
+        if (registry[endpointTool.toolName]) {
+            throw new Error(`Duplicate endpoint toolName: ${endpointTool.toolName}`);
+        }
+        registry[endpointTool.toolName] = endpointToolToTool(endpointTool);
+    }
+    return registry;
+}
+// ============================================================================
+// UI Tool Definition → Tool Conversion
+// ============================================================================
+function applyUiTemplateValue(value, input) {
+    if (typeof value === 'string' && value.startsWith('$')) {
+        const key = value.slice(1);
+        return key in input ? input[key] : null;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => applyUiTemplateValue(item, input));
+    }
+    if (isRecord(value)) {
+        const output = {};
+        for (const [key, nested] of Object.entries(value)) {
+            output[key] = applyUiTemplateValue(nested, input);
+        }
+        return output;
+    }
+    return value;
+}
+/**
+ * Convert a UI tool definition into a Tool.
+ * UI tools never call external services — they only produce uiActions.
+ */
+export function uiToolToTool(uiTool) {
+    let description = uiTool.description;
+    if (uiTool.outputSchema) {
+        description += `\n\nReturns: ${zodToCompactDescription(uiTool.outputSchema)}`;
+    }
+    return defineTool({
+        id: uiTool.id,
+        description,
+        inputSchema: uiTool.inputSchema,
+        outputSchema: uiTool.outputSchema,
+        needsApproval: uiTool.needsApproval ?? false,
+        execute: async (rawInput) => {
+            const inputPayload = isRecord(rawInput) ? { ...rawInput } : {};
+            // Priority: 1) uiPattern (dynamic), 2) uiAction (static template)
+            let uiAction;
+            if (uiTool.uiPattern) {
+                if (Array.isArray(uiTool.uiPattern)) {
+                    const actions = buildUiActionsFromPatterns(uiTool.uiPattern, inputPayload, {});
+                    uiAction = actions.length > 0 ? actions : undefined;
+                }
+                else {
+                    uiAction = buildUiActionFromPattern(uiTool.uiPattern, inputPayload, {});
+                }
+            }
+            else if (uiTool.uiAction) {
+                if (Array.isArray(uiTool.uiAction)) {
+                    const actions = [];
+                    for (const template of uiTool.uiAction) {
+                        const resolved = applyUiTemplateValue(template, inputPayload);
+                        if (resolved)
+                            actions.push(resolved);
+                    }
+                    uiAction = actions.length > 0 ? actions : undefined;
+                }
+                else {
+                    uiAction = applyUiTemplateValue(uiTool.uiAction, inputPayload);
+                }
+            }
+            const message = uiTool.successMessage
+                ? applyUiTemplateValue(uiTool.successMessage, inputPayload) || 'Action executed.'
+                : 'Action executed.';
+            return {
+                success: true,
+                message,
+                ...(uiAction ? { uiAction } : {}),
+            };
+        },
+    });
+}
+/**
+ * Convert an array of UI tools into a ToolRegistry.
+ */
+export function uiToolsToRegistry(uiTools) {
+    const registry = {};
+    for (const uiTool of uiTools) {
+        if (registry[uiTool.toolName]) {
+            throw new Error(`Duplicate UI toolName: ${uiTool.toolName}`);
+        }
+        registry[uiTool.toolName] = uiToolToTool(uiTool);
+    }
+    return registry;
+}
+/**
+ * Convert a Tool to an AI SDK-compatible tool object.
+ *
+ * Returns a plain object with `description`, `parameters`, `execute` that
+ * can be passed to any AI SDK that follows the Vercel AI SDK convention.
+ *
+ * @param tool - The tool to convert
+ * @param context - Runtime context (currentDate, locale, runtime)
+ * @param toolName - Override tool name (defaults to tool.id)
+ * @param options - Additional options
+ */
+export function toolToAiTool(tool, context, toolName, options) {
+    const name = toolName ?? tool.id;
+    const needsApproval = tool.needsApproval;
+    const requiresApproval = !!needsApproval;
+    return {
+        _toolId: tool.id,
+        description: tool.description,
+        parameters: tool.inputSchema,
+        needsApproval: requiresApproval
+            ? async (input) => {
+                const needed = typeof needsApproval === 'boolean'
+                    ? needsApproval
+                    : await needsApproval(input, context);
+                if (needed) {
+                    options?.onAudit?.({
+                        type: 'approval.requested',
+                        timestamp: new Date().toISOString(),
+                        sessionId: options.sessionId ?? '',
+                        source: 'server-core',
+                        details: {
+                            toolId: tool.id,
+                            toolName: name,
+                        },
+                    });
+                }
+                return needed;
+            }
+            : undefined,
+        execute: async (input) => {
+            const startTime = Date.now();
+            try {
+                const result = await tool.execute(input, context);
+                // Audit: tool executed successfully
+                options?.onAudit?.({
+                    type: 'tool.executed',
+                    timestamp: new Date().toISOString(),
+                    sessionId: options.sessionId ?? '',
+                    source: 'server-core',
+                    details: {
+                        toolId: tool.id,
+                        toolName: name,
+                        method: tool.method,
+                        latencyMs: Date.now() - startTime,
+                        success: true,
+                        approvalRequired: !!requiresApproval,
+                    },
+                });
+                // Output schema: parse to strip extra fields, re-attach uiAction for client
+                let cleanResult = result;
+                if (tool.outputSchema &&
+                    isRecord(result) &&
+                    result.success !== false) {
+                    const parsed = tool.outputSchema.safeParse(result);
+                    if (parsed.success) {
+                        // Use parsed data (extra fields stripped by Zod)
+                        const rec = result;
+                        cleanResult = {
+                            ...parsed.data,
+                            // Preserve success flag
+                            ...(rec.success !== undefined ? { success: rec.success } : {}),
+                            // Re-attach uiAction for client stream (stripped by schema parse)
+                            ...(rec.uiAction ? { uiAction: rec.uiAction } : {}),
+                        };
+                    }
+                    else {
+                        // Schema mismatch — warn but pass through unmodified
+                        console.warn(`[glirastes] Output schema mismatch for tool "${name}":`, parsed.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`));
+                    }
+                }
+                // Truncate large arrays to prevent context overflow
+                cleanResult = truncateToolResult(cleanResult);
+                return options?.uiActionSchema
+                    ? normalizeResultUiAction(cleanResult, options.uiActionSchema)
+                    : cleanResult;
+            }
+            catch (error) {
+                // Audit: tool execution failed
+                options?.onAudit?.({
+                    type: 'tool.failed',
+                    timestamp: new Date().toISOString(),
+                    sessionId: options.sessionId ?? '',
+                    source: 'server-core',
+                    details: {
+                        toolId: tool.id,
+                        toolName: name,
+                        error: error instanceof Error ? error.message : String(error),
+                        latencyMs: Date.now() - startTime,
+                    },
+                });
+                options?.onError?.(tool.id, error);
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                return normalizeResultUiAction({
+                    error: `Error in ${tool.id}: ${errorMessage}`,
+                    hint: 'Check the parameters and try again.',
+                }, options?.uiActionSchema);
+            }
+        },
+    };
+}
+/**
+ * Forward an audit event to the remote telemetry sink (fire-and-forget).
+ */
+function forwardToTelemetry(telemetry, event, traceId) {
+    try {
+        telemetry.emit({
+            eventType: event.type,
+            traceId: traceId ?? event.sessionId,
+            toolId: (event.details?.toolId ?? event.details?.toolName),
+            latencyMs: event.details?.latencyMs,
+            timestamp: event.timestamp,
+            payload: event.details,
+            actor: { sessionId: event.sessionId },
+        });
+    }
+    catch {
+        // Telemetry is fire-and-forget, never block tool execution
+    }
+}
+/**
+ * Wrap options to auto-forward audit events to remote telemetry.
+ * Returns options with an augmented `onAudit` that calls both
+ * the original callback and the telemetry sink.
+ */
+function withTelemetryForwarding(options) {
+    if (!options?.telemetry)
+        return options;
+    const { telemetry, onAudit: originalOnAudit } = options;
+    return {
+        ...options,
+        onAudit: (event) => {
+            originalOnAudit?.(event);
+            forwardToTelemetry(telemetry, event, options.traceId);
+        },
+    };
+}
+/**
+ * Convert a registry of tools to AI SDK tools.
+ * The SDK does not perform authorization — the backend API that each tool
+ * calls is responsible for permission enforcement.
+ */
+export function toolsToAiTools(registry, context, options) {
+    const resolvedOptions = withTelemetryForwarding(options);
+    const tools = {};
+    for (const [name, tool] of Object.entries(registry)) {
+        tools[name] = toolToAiTool(tool, context, name, resolvedOptions);
+    }
+    return tools;
+}
+// ============================================================================
+// Transport Adapters
+// ============================================================================
+function toErrorMessage(data, fallback) {
+    if (typeof data === 'string' && data.trim())
+        return data;
+    if (isRecord(data)) {
+        // NestJS ValidationPipe returns: { statusCode, message: string[], error: "Bad Request" }
+        // Prefer the detailed message(s) over the generic error string.
+        const message = data.message;
+        if (Array.isArray(message) && message.length > 0) {
+            const details = message
+                .filter((m) => typeof m === 'string' && m.trim().length > 0)
+                .join('; ');
+            if (details) {
+                const prefix = typeof data.error === 'string' && data.error.trim()
+                    ? `${data.error}: `
+                    : '';
+                return `${prefix}${details}`;
+            }
+        }
+        if (typeof message === 'string' && message.trim())
+            return message;
+        if (typeof data.error === 'string' && data.error.trim())
+            return data.error;
+    }
+    return fallback;
+}
+async function parseResponseBody(response) {
+    const contentType = response.headers.get('content-type') || '';
+    if (contentType.includes('application/json')) {
+        try {
+            return await response.json();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const text = await response.text();
+    return text.length > 0 ? text : undefined;
+}
+export function normalizeNodeHeaders(headers, allowedHeaderNames) {
+    const allowlist = allowedHeaderNames
+        ? new Set(allowedHeaderNames.map((n) => n.toLowerCase()))
+        : undefined;
+    const normalized = {};
+    for (const [rawName, rawValue] of Object.entries(headers)) {
+        const name = rawName.toLowerCase();
+        if (allowlist && !allowlist.has(name))
+            continue;
+        if (rawValue === undefined)
+            continue;
+        if (Array.isArray(rawValue)) {
+            normalized[name] = rawValue.join(name === 'cookie' ? '; ' : ', ');
+            continue;
+        }
+        normalized[name] = rawValue;
+    }
+    return normalized;
+}
+export function createFetchInternalApiCaller(options) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    return async (request) => {
+        const url = new URL(request.path, options.baseUrl).toString();
+        const methodAllowsBody = request.method !== 'GET' && request.method !== 'DELETE';
+        const headers = {
+            ...(options.defaultHeaders ?? {}),
+        };
+        const init = { method: request.method, headers };
+        if (methodAllowsBody && request.body !== undefined) {
+            if (!headers['content-type']) {
+                headers['content-type'] = 'application/json';
+            }
+            init.body = JSON.stringify(request.body);
+        }
+        const response = await fetchImpl(url, init);
+        const data = await parseResponseBody(response);
+        if (!response.ok) {
+            return {
+                ok: false,
+                status: response.status,
+                data,
+                error: toErrorMessage(data, `Endpoint failed (${response.status})`),
+            };
+        }
+        return { ok: true, status: response.status, data };
+    };
+}
+export function createNextInternalApiCaller(options) {
+    const headers = {
+        ...(options.defaultHeaders ?? {}),
+    };
+    if (options.cookieHeader)
+        headers.cookie = options.cookieHeader;
+    return createFetchInternalApiCaller({
+        baseUrl: options.origin,
+        fetchImpl: options.fetchImpl,
+        defaultHeaders: headers,
+    });
+}
+export function createExpressInternalApiCaller(options) {
+    const forwardHeaderNames = options.forwardHeaderNames ?? [
+        'cookie',
+        'authorization',
+        'x-request-id',
+    ];
+    const forwardedHeaders = options.reqHeaders
+        ? normalizeNodeHeaders(options.reqHeaders, forwardHeaderNames)
+        : {};
+    return createFetchInternalApiCaller({
+        baseUrl: options.baseUrl,
+        fetchImpl: options.fetchImpl,
+        defaultHeaders: {
+            ...forwardedHeaders,
+            ...(options.defaultHeaders ?? {}),
+        },
+    });
+}
+// ============================================================================
+// Re-exports
+// ============================================================================
+export { zodToCompactDescription } from './zod-compact.js';
+// ============================================================================
+// Followup Tool
+// ============================================================================
+export { createFollowupTool } from './followup-tool.js';
+// ============================================================================
+// Module Routing
+// ============================================================================
+export { defineModule, createAiRouter } from './module-router.js';
+// ============================================================================
+// Model Selection
+// ============================================================================
+export { createModelSelector, createModelSelectorFromMap } from './model-selector.js';
+// ============================================================================
+// Intent Classification
+// ============================================================================
+export { createIntentClassifier, tokenize, jaccardSimilarity, classifyWithHeuristics, buildClassificationPrompt, parseJsonResponse, } from './intent-classifier.js';
+//# sourceMappingURL=index.js.map