svedocs 0.1.0-beta.10

package/LICENSE

@@ -0,0 +1,5 @@
+MIT License
+
+Copyright (c) 2026 svedocs contributors
+
+See the repository root license for the full text.

package/README.md

@@ -0,0 +1,85 @@
+# svedocs
+
+Integrated SvelteKit documentation framework package.
+
+## Exports
+
+- `svedocs/config`: config schema and `defineConfig`.
+- `svedocs/core`: content manifest, scoped navigation, checks, search records, and shared types.
+- `svedocs/vite`: virtual modules and content refresh Vite plugin.
+- `svedocs/theme`: default Svelte theme components, replaceable theme component map, and Tailwind CSS v4 styles.
+- `svedocs/theme/headless`: unstyled theme behavior controllers for custom themes.
+- `svedocs/theme/types`: public theme component prop and component-map types.
+- `svedocs/svelte`: `mdsvex`-based Svelte-compatible authoring helpers.
+- `svedocs/search`: weighted local search, scope filters, Cloudflare AI Search provider, and indexing sync.
+- `svedocs/ai`: Ask AI providers, SSE responses, and rate limiting helpers.
+- `svedocs/og`: SEO metadata, sitemap/robots, opt-in RSS, SVG/PNG/Satori OG generation.
+- `svedocs/cloudflare`: build presets, wrangler config, and binding type helpers.
+
+All rendering, theme, search, AI, SEO, OG, and Cloudflare capabilities are intentionally kept inside this package.
+
+## Theme Development
+
+The default theme is optional and replaceable. Import the full bundled CSS when you want the standard look:
+
+```svelte
+<script lang="ts">
+  import 'svedocs/theme/styles.css';
+</script>
+```
+
+Custom themes can import only `svedocs/theme/base.css` for reset, accessibility, prose, and code structure, or skip theme CSS entirely and own every style.
+
+Register replacement components in the Vite plugin, not `svedocs.config.ts`, because Svelte component paths are build-time imports:
+
+```ts
+import { svedocs } from 'svedocs/vite';
+import svedocsConfig from './svedocs.config';
+
+svedocs({
+  config: svedocsConfig,
+  theme: {
+    components: {
+      Navbar: '$lib/theme/Navbar.svelte',
+      Article: '$lib/theme/Article.svelte',
+      Search: '$lib/theme/Search.svelte',
+      AskAi: '$lib/theme/AskAi.svelte',
+      Error: '$lib/theme/Error.svelte'
+    }
+  }
+});
+```
+
+Generated routes import `virtual:svedocs/theme-components` and pass the map to `DocsApp`. You can replace broad page layouts such as `Root`, `Layout`, `Docs`, `Page`, `Home`, and `Error`, or smaller pieces such as `Navbar`, `Sidebar`, `Article`, `Toc`, `Search`, `AskAi`, `Footer`, `ThemeToggle`, `PageTools`, and `RenderError`.
+
+Use `svedocs/theme/types` for stable props and `svedocs/theme/headless` for unstyled behavior controllers such as search, Ask AI, ToC tracking, theme mode, mobile nav, page tools, and code-copy behavior. Replacement page layouts should keep passing `pages`, `tree`, `search`, `config`, `loadSearch`, and `themeComponents` into nested default components so navigation highlighting, mobile menus, and runtime panels stay connected.
+
+Generated templates include `src/routes/+error.svelte`. Register `theme.components.Error` to customize full-route error pages and `theme.components.RenderError` to customize local render-boundary failures inside layouts, articles, and tools.
+
+## MDX/SVX Components
+
+The Vite plugin loads `svedocs.config.ts` by default. You can also pass a config object explicitly and register shared authoring components or layouts:
+
+```ts
+import { svedocs } from 'svedocs/vite';
+import svedocsConfig from './svedocs.config';
+
+svedocs({
+  config: svedocsConfig,
+  components: {
+    Callout: '$lib/Callout.svelte'
+  },
+  layouts: {
+    feature: '$lib/FeatureLayout.svelte'
+  },
+  theme: {
+    components: {
+      Navbar: '$lib/theme/Navbar.svelte',
+      Article: '$lib/theme/Article.svelte'
+    }
+  }
+})
+```
+
+`.svx` and `.mdx` files can then use `<Callout />` without local imports.
+Registered theme components are exposed through `virtual:svedocs/theme-components` and can replace default navigation, article, search, Ask AI, ToC, and footer rendering.

package/dist/ai/openai-compatible.d.ts

@@ -0,0 +1,13 @@
+import type { AiProvider } from './types.js';
+export interface OpenAiCompatibleProviderOptions {
+    apiKey: string;
+    model: string;
+    baseUrl?: string;
+    systemPrompt?: string;
+    citationLimit?: number;
+    temperature?: number;
+    headers?: Record<string, string>;
+    fetch?: typeof fetch;
+}
+export declare function createOpenAiCompatibleProvider(options: OpenAiCompatibleProviderOptions): AiProvider;
+//# sourceMappingURL=openai-compatible.d.ts.map

package/dist/ai/openai-compatible.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-compatible.d.ts","sourceRoot":"","sources":["../../src/ai/openai-compatible.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAY,MAAM,YAAY,CAAC;AAEvD,MAAM,WAAW,+BAA+B;IAC9C,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CACtB;AAYD,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,+BAA+B,GAAG,UAAU,CAgDnG"}

package/dist/ai/openai-compatible.js

@@ -0,0 +1,92 @@
+import { filterSearchRecords, searchRecords } from '../search.js';
+export function createOpenAiCompatibleProvider(options) {
+    const citationLimit = options.citationLimit ?? 5;
+    const systemPrompt = options.systemPrompt ?? [
+        'Answer from the documentation sources provided by svedocs.',
+        'Cite relevant pages by title and URL.',
+        'If the sources are insufficient, say what is missing.'
+    ].join(' ');
+    return {
+        name: 'openai-compatible',
+        async ask(input) {
+            const ranked = createOpenAiContextRecords(input, citationLimit);
+            const citations = ranked.map((result) => ({
+                title: result.title,
+                url: result.url,
+                ...(result.section ? { section: result.section } : {})
+            }));
+            const history = (input.messages ?? []).map((message) => ({ role: message.role, content: message.content }));
+            const lastIsCurrent = history.length > 0
+                && history[history.length - 1]?.role === 'user'
+                && history[history.length - 1]?.content === input.question;
+            const trailing = history.length > 0 && lastIsCurrent ? history.slice(0, -1) : history;
+            const response = await (options.fetch ?? fetch)(createChatCompletionsEndpoint(options.baseUrl), {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    authorization: `Bearer ${options.apiKey}`,
+                    ...(options.headers ?? {})
+                },
+                body: JSON.stringify({
+                    model: options.model,
+                    ...(typeof options.temperature === 'number' ? { temperature: options.temperature } : {}),
+                    messages: [
+                        { role: 'system', content: systemPrompt },
+                        ...trailing,
+                        { role: 'user', content: createPrompt(input, ranked) }
+                    ]
+                })
+            });
+            if (!response.ok) {
+                throw new Error(`OpenAI-compatible provider returned ${response.status}: ${(await response.text()).slice(0, 500)}`);
+            }
+            const payload = await response.json();
+            return {
+                answer: readChatCompletionAnswer(payload),
+                citations
+            };
+        }
+    };
+}
+function createOpenAiContextRecords(input, citationLimit) {
+    const ranked = searchRecords(input.records ?? [], {
+        query: input.question,
+        limit: citationLimit,
+        ...(input.scope ?? {})
+    });
+    if (ranked.length > 0)
+        return ranked;
+    return filterSearchRecords(input.records ?? [], input.scope).slice(0, citationLimit).map((record, index) => ({
+        id: record.id,
+        title: record.title,
+        url: record.url,
+        ...(record.section ? { section: record.section } : {}),
+        excerpt: record.content.slice(0, 220),
+        score: 1 / (index + 1),
+        metadata: record.metadata
+    }));
+}
+function createChatCompletionsEndpoint(baseUrl = 'https://api.openai.com/v1') {
+    return `${baseUrl.replace(/\/$/, '')}/chat/completions`;
+}
+function createPrompt(input, sources) {
+    const context = sources.length > 0
+        ? sources.map((source, index) => [
+            `[${index + 1}] ${source.section ? `${source.title}: ${source.section}` : source.title}`,
+            `URL: ${source.url}`,
+            source.excerpt
+        ].join('\n')).join('\n\n')
+        : 'No local documentation source matched.';
+    return [
+        `Question: ${input.question}`,
+        '',
+        'Sources:',
+        context
+    ].join('\n');
+}
+function readChatCompletionAnswer(payload) {
+    return payload.output_text
+        ?? payload.choices?.[0]?.message?.content
+        ?? payload.choices?.[0]?.text
+        ?? 'No answer was returned.';
+}

package/dist/ai/providers.d.ts

@@ -0,0 +1,20 @@
+import type { SvedocsSearchRecord } from '../core.js';
+import type { AiProvider, AiSearchBinding, AskCitation, CloudflareWorkersAiBinding } from './types.js';
+export declare function createMockAiProvider(): AiProvider;
+export declare function createCloudflareAiSearchAiProvider(input: {
+    binding: AiSearchBinding;
+    instanceName?: string;
+    namespace?: boolean;
+    systemPrompt?: string;
+    model?: string;
+    maxResults?: number;
+}): AiProvider;
+export declare function createWorkersAiProvider(input: {
+    ai: CloudflareWorkersAiBinding;
+    model?: string;
+    systemPrompt?: string;
+    citationLimit?: number;
+}): AiProvider;
+export declare function rankAskCitations(records: SvedocsSearchRecord[], question: string, limit?: number): AskCitation[];
+export declare const mockAiProvider: AiProvider;
+//# sourceMappingURL=providers.d.ts.map

package/dist/ai/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../src/ai/providers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAItD,OAAO,KAAK,EACV,UAAU,EACV,eAAe,EACf,WAAW,EAGX,0BAA0B,EAC3B,MAAM,YAAY,CAAC;AAEpB,wBAAgB,oBAAoB,IAAI,UAAU,CAajD;AAED,wBAAgB,kCAAkC,CAAC,KAAK,EAAE;IACxD,OAAO,EAAE,eAAe,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,UAAU,CAuDb;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE;IAC7C,EAAE,EAAE,0BAA0B,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,UAAU,CA2Bb;AAED,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,mBAAmB,EAAE,EAC9B,QAAQ,EAAE,MAAM,EAChB,KAAK,SAAI,GACR,WAAW,EAAE,CAMf;AAED,eAAO,MAAM,cAAc,YAAyB,CAAC"}

package/dist/ai/providers.js

@@ -0,0 +1,185 @@
+import { createCloudflareAiSearchScopeFilters, normalizeCloudflareAiSearchResults } from '../search/cloudflare.js';
+import { matchesSearchScope, searchRecords } from '../search.js';
+export function createMockAiProvider() {
+    return {
+        name: 'mock',
+        ask(input) {
+            const citations = rankAskCitations(input.records ?? [], input.question, 3);
+            return {
+                answer: citations.length > 0
+                    ? `I found ${citations.length} relevant source${citations.length === 1 ? '' : 's'} in this documentation. Connect Cloudflare AI Search to generate a hosted answer.`
+                    : `Ask AI is configured. Connect Cloudflare AI Search to answer: ${input.question}`,
+                citations
+            };
+        }
+    };
+}
+export function createCloudflareAiSearchAiProvider(input) {
+    const maxResults = input.maxResults ?? 5;
+    const systemPrompt = input.systemPrompt ?? 'Answer from the documentation. Cite the pages you used.';
+    async function ask(question) {
+        const conversation = buildChatMessages(systemPrompt, question);
+        const instance = resolveAiChatInstance(input.binding, input.instanceName, input.namespace);
+        if (!instance.chatCompletions) {
+            const result = await instance.search({
+                messages: conversation,
+                ai_search_options: {
+                    retrieval: createCloudflareAiSearchRetrieval(maxResults, question.scope)
+                }
+            });
+            return {
+                answer: result.response ?? result.answer ?? 'No answer was returned.',
+                citations: createCloudflareAiSearchCitations(result, question, maxResults)
+            };
+        }
+        const result = await instance.chatCompletions({
+            messages: conversation,
+            ...(input.model ? { model: input.model } : {}),
+            ai_search_options: {
+                retrieval: createCloudflareAiSearchRetrieval(maxResults, question.scope)
+            }
+        });
+        return {
+            answer: readAiSearchAnswer(result),
+            citations: readCloudflareAiSearchCitations(result, question, maxResults)
+        };
+    }
+    return {
+        name: 'cloudflare-ai-search',
+        ask,
+        async stream(question) {
+            const instance = resolveAiChatInstance(input.binding, input.instanceName, input.namespace);
+            if (!instance.chatCompletions) {
+                return createSvedocsAnswerStream(await ask(question));
+            }
+            const result = await instance.chatCompletions({
+                messages: buildChatMessages(systemPrompt, question),
+                ...(input.model ? { model: input.model } : {}),
+                stream: true,
+                ai_search_options: {
+                    retrieval: createCloudflareAiSearchRetrieval(maxResults, question.scope)
+                }
+            });
+            if (result instanceof Response || result instanceof ReadableStream)
+                return result;
+            return createSvedocsAnswerStream({
+                answer: readAiSearchAnswer(result),
+                citations: readCloudflareAiSearchCitations(result, question, maxResults)
+            });
+        }
+    };
+}
+export function createWorkersAiProvider(input) {
+    const systemPrompt = input.systemPrompt ?? 'Answer from the documentation context. Keep answers concise and cite relevant pages.';
+    return {
+        name: 'cloudflare-workers-ai',
+        async ask(question) {
+            const citations = rankAskCitations(question.records ?? [], question.question, input.citationLimit ?? 5);
+            const context = citations.map((citation) => `- ${citation.section ?? citation.title}: ${citation.url}`).join('\n');
+            const history = (question.messages ?? []).map((message) => ({ role: message.role, content: message.content }));
+            const userContent = [
+                `Question: ${question.question}`,
+                '',
+                'Sources:',
+                context || 'No local source matched.'
+            ].join('\n');
+            const result = await input.ai.run(input.model ?? '@cf/meta/llama-3.1-8b-instruct', {
+                messages: [
+                    { role: 'system', content: systemPrompt },
+                    ...history,
+                    { role: 'user', content: userContent }
+                ]
+            });
+            return {
+                answer: readWorkersAiAnswer(result),
+                citations
+            };
+        }
+    };
+}
+export function rankAskCitations(records, question, limit = 3) {
+    return searchRecords(records, { query: question, limit }).map((result) => ({
+        title: result.title,
+        url: result.url,
+        ...(result.section ? { section: result.section } : {})
+    }));
+}
+export const mockAiProvider = createMockAiProvider();
+function createSvedocsAnswerStream(result) {
+    const encoder = new TextEncoder();
+    return new ReadableStream({
+        start(controller) {
+            controller.enqueue(encoder.encode(`event: answer\ndata: ${JSON.stringify({ answer: result.answer })}\n\n`));
+            controller.enqueue(encoder.encode(`event: citations\ndata: ${JSON.stringify({ citations: result.citations })}\n\n`));
+            controller.enqueue(encoder.encode('event: done\ndata: {}\n\n'));
+            controller.close();
+        }
+    });
+}
+function resolveAiChatInstance(binding, instanceName = 'svedocs', namespace = false) {
+    return namespace
+        ? binding.get(instanceName)
+        : binding;
+}
+function normalizeCitations(citations) {
+    return (citations ?? []).map((citation) => ({
+        title: citation.title ?? 'Source',
+        url: citation.url ?? '#',
+        ...(citation.section ? { section: citation.section } : {})
+    }));
+}
+function createCloudflareAiSearchRetrieval(maxResults, scope) {
+    const filters = createCloudflareAiSearchScopeFilters(scope);
+    return {
+        retrieval_type: 'hybrid',
+        max_num_results: maxResults,
+        ...(filters ? { filters } : {})
+    };
+}
+function readCloudflareAiSearchCitations(result, input, maxResults) {
+    const scopedCitations = createCloudflareAiSearchCitations(result, input, maxResults);
+    const citations = normalizeCitations(result.citations);
+    if (hasSearchScope(input.scope)) {
+        return scopedCitations.length > 0 ? scopedCitations : citations.slice(0, maxResults);
+    }
+    return citations.length > 0 ? citations.slice(0, maxResults) : scopedCitations;
+}
+function createCloudflareAiSearchCitations(result, input, maxResults) {
+    return normalizeCloudflareAiSearchResults(result, input.question)
+        .filter((searchResult) => matchesSearchScope({ metadata: searchResult.metadata }, input.scope))
+        .slice(0, maxResults)
+        .map((searchResult) => ({
+        title: searchResult.title,
+        url: searchResult.url,
+        ...(searchResult.section ? { section: searchResult.section } : {})
+    }));
+}
+function hasSearchScope(scope) {
+    return Boolean(scope?.locale || scope?.kind);
+}
+function readAiSearchAnswer(result) {
+    return (result.response ??
+        result.answer ??
+        result.choices?.[0]?.message?.content ??
+        result.choices?.[0]?.text ??
+        'No answer was returned.');
+}
+function readWorkersAiAnswer(result) {
+    if (typeof result === 'string')
+        return result;
+    return result.response ?? result.answer ?? result.result ?? 'No answer was returned.';
+}
+function buildChatMessages(systemPrompt, input) {
+    const history = (input.messages ?? []).map((message) => ({ role: message.role, content: message.content }));
+    const lastIsCurrentQuestion = history.length > 0 &&
+        history[history.length - 1]?.role === 'user' &&
+        history[history.length - 1]?.content === input.question;
+    const messages = [
+        { role: 'system', content: systemPrompt },
+        ...history
+    ];
+    if (!lastIsCurrentQuestion) {
+        messages.push({ role: 'user', content: input.question });
+    }
+    return messages;
+}

package/dist/ai/rate-limit.d.ts

@@ -0,0 +1,18 @@
+import type { AiRateLimiter, AiRateLimitStore, CloudflareKvNamespace } from './types.js';
+export declare function createMemoryRateLimiter(input: {
+    windowMs: number;
+    max: number;
+}): AiRateLimiter;
+export declare function createStoreRateLimiter(input: {
+    windowMs: number;
+    max: number;
+    store: AiRateLimitStore;
+    prefix?: string;
+}): AiRateLimiter;
+export declare function createCloudflareKvRateLimiter(input: {
+    namespace: CloudflareKvNamespace;
+    windowMs: number;
+    max: number;
+    prefix?: string;
+}): AiRateLimiter;
+//# sourceMappingURL=rate-limit.d.ts.map

package/dist/ai/rate-limit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limit.d.ts","sourceRoot":"","sources":["../../src/ai/rate-limit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAEzF,wBAAgB,uBAAuB,CAAC,KAAK,EAAE;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;CACb,GAAG,aAAa,CAchB;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE;IAC5C,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,gBAAgB,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,aAAa,CAqBhB;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE;IACnD,SAAS,EAAE,qBAAqB,CAAC;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,aAAa,CAchB"}

package/dist/ai/rate-limit.js

@@ -0,0 +1,52 @@
+export function createMemoryRateLimiter(input) {
+    const buckets = new Map();
+    return createStoreRateLimiter({
+        windowMs: input.windowMs,
+        max: input.max,
+        store: {
+            async get(key) {
+                return buckets.get(key);
+            },
+            async put(key, value) {
+                buckets.set(key, value);
+            }
+        }
+    });
+}
+export function createStoreRateLimiter(input) {
+    return {
+        async check({ key }) {
+            const now = Date.now();
+            const storeKey = `${input.prefix ?? 'svedocs:ai'}:${key}`;
+            const existing = await input.store.get(storeKey);
+            if (!existing || existing.resetAt <= now) {
+                await input.store.put(storeKey, { count: 1, resetAt: now + input.windowMs }, Math.ceil(input.windowMs / 1000));
+                return { allowed: true };
+            }
+            const next = { count: existing.count + 1, resetAt: existing.resetAt };
+            await input.store.put(storeKey, next, Math.ceil((existing.resetAt - now) / 1000));
+            if (next.count > input.max) {
+                return {
+                    allowed: false,
+                    retryAfter: Math.ceil((existing.resetAt - now) / 1000)
+                };
+            }
+            return { allowed: true };
+        }
+    };
+}
+export function createCloudflareKvRateLimiter(input) {
+    return createStoreRateLimiter({
+        windowMs: input.windowMs,
+        max: input.max,
+        ...(input.prefix ? { prefix: input.prefix } : {}),
+        store: {
+            async get(key) {
+                return input.namespace.get(key, { type: 'json' }).then((value) => value ?? undefined);
+            },
+            async put(key, value, ttlSeconds) {
+                await input.namespace.put(key, JSON.stringify(value), { expirationTtl: ttlSeconds });
+            }
+        }
+    });
+}

package/dist/ai/response.d.ts

@@ -0,0 +1,4 @@
+import type { SvedocsSearchRecord } from '../core.js';
+import type { AiProvider, CreateAskResponseOptions } from './types.js';
+export declare function createAskResponse(provider: AiProvider, request: Request, recordsOrOptions?: SvedocsSearchRecord[] | CreateAskResponseOptions): Promise<Response>;
+//# sourceMappingURL=response.d.ts.map

package/dist/ai/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../src/ai/response.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAGtD,OAAO,KAAK,EAAE,UAAU,EAA0B,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAE/F,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,UAAU,EACpB,OAAO,EAAE,OAAO,EAChB,gBAAgB,GAAE,mBAAmB,EAAE,GAAG,wBAA6B,GACtE,OAAO,CAAC,QAAQ,CAAC,CA2CnB"}

package/dist/ai/response.js

@@ -0,0 +1,151 @@
+import { filterSearchRecords } from '../search.js';
+export async function createAskResponse(provider, request, recordsOrOptions = []) {
+    const options = Array.isArray(recordsOrOptions) ? { records: recordsOrOptions } : recordsOrOptions;
+    const stream = options.stream ?? wantsStream(request);
+    try {
+        const body = await request.json().catch(() => ({}));
+        const messages = sanitizeMessages(body.messages);
+        const lastUserMessage = [...messages].reverse().find((message) => message.role === 'user');
+        const question = (body.question?.trim() ?? lastUserMessage?.content.trim() ?? '');
+        if (!question) {
+            return askErrorResponse('Question is required.', 400, stream);
+        }
+        if (options.rateLimiter) {
+            const limit = await options.rateLimiter.check({
+                key: createRateLimitKey(request, options.rateLimitKey),
+                request
+            });
+            if (!limit.allowed) {
+                return askErrorResponse('Ask AI rate limit exceeded.', 429, stream, limit.retryAfter);
+            }
+        }
+        const scope = createRequestScope(request, body, options.scope);
+        const records = filterSearchRecords(options.records ?? [], scope);
+        const askInput = {
+            question,
+            records,
+            scope,
+            ...(messages.length > 0 ? { messages } : {}),
+            ...(options.systemPrompt ? { systemPrompt: options.systemPrompt } : {}),
+            ...(options.maxResults ? { maxResults: options.maxResults } : {})
+        };
+        if (stream && provider.stream) {
+            return streamProviderResponse(await provider.stream(askInput));
+        }
+        const result = await provider.ask(askInput);
+        return stream ? streamAskResult(result) : jsonResponse(result);
+    }
+    catch (error) {
+        return askErrorResponse(error instanceof Error ? error.message : 'Ask AI failed.', 500, stream);
+    }
+}
+function sanitizeMessages(messages) {
+    if (!Array.isArray(messages))
+        return [];
+    return messages
+        .filter((message) => Boolean(message)
+        && (message.role === 'user' || message.role === 'assistant')
+        && typeof message.content === 'string'
+        && message.content.trim().length > 0)
+        .map((message) => ({ role: message.role, content: message.content }));
+}
+function createRequestScope(request, body, configured) {
+    const url = new URL(request.url);
+    const base = typeof configured === 'function' ? configured(request) : configured;
+    const locale = readScopeParam(url, 'locale');
+    const kind = readScopeParam(url, 'kind');
+    return cleanScope({
+        ...(base ?? {}),
+        ...(locale ? { locale } : {}),
+        ...(kind ? { kind } : {}),
+        ...(body.locale ? { locale: body.locale } : {}),
+        ...(body.kind ? { kind: body.kind } : {})
+    });
+}
+function cleanScope(scope) {
+    return {
+        ...(scope.locale?.trim() ? { locale: scope.locale.trim() } : {}),
+        ...(scope.kind?.trim() ? { kind: scope.kind.trim() } : {})
+    };
+}
+function readScopeParam(url, key) {
+    return url.searchParams.get(key)?.trim() || undefined;
+}
+function wantsStream(request) {
+    const url = new URL(request.url);
+    return url.searchParams.get('stream') === '1' || request.headers.get('accept')?.includes('text/event-stream') === true;
+}
+function createRateLimitKey(request, key) {
+    if (typeof key === 'function')
+        return key(request);
+    if (typeof key === 'string')
+        return key;
+    return request.headers.get('cf-connecting-ip')
+        ?? request.headers.get('x-forwarded-for')?.split(',')[0]?.trim()
+        ?? 'anonymous';
+}
+function streamProviderResponse(result) {
+    if (result instanceof Response) {
+        return new Response(result.body, {
+            status: result.status,
+            headers: {
+                'content-type': result.headers.get('content-type') ?? 'text/event-stream; charset=utf-8',
+                'cache-control': result.headers.get('cache-control') ?? 'no-cache, no-transform'
+            }
+        });
+    }
+    return new Response(result, {
+        headers: {
+            'content-type': 'text/event-stream; charset=utf-8',
+            'cache-control': 'no-cache, no-transform'
+        }
+    });
+}
+function streamAskResult(result) {
+    return eventStreamResponse((send) => {
+        send('answer', { answer: result.answer });
+        send('citations', { citations: result.citations });
+        send('done', {});
+    });
+}
+function askErrorResponse(message, status, stream, retryAfter) {
+    if (stream) {
+        return eventStreamResponse((send) => {
+            send('error', { error: message, status, ...(retryAfter ? { retryAfter } : {}) });
+            send('done', {});
+        }, status, retryAfter);
+    }
+    return jsonResponse({
+        error: message,
+        ...(retryAfter ? { retryAfter } : {})
+    }, status, retryAfter);
+}
+function eventStreamResponse(write, status = 200, retryAfter) {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        start(controller) {
+            const send = (event, value) => {
+                controller.enqueue(encoder.encode(`event: ${event}\ndata: ${JSON.stringify(value)}\n\n`));
+            };
+            write(send);
+            controller.close();
+        }
+    });
+    return new Response(stream, {
+        status,
+        headers: {
+            'content-type': 'text/event-stream; charset=utf-8',
+            'cache-control': 'no-cache, no-transform',
+            ...(retryAfter ? { 'retry-after': String(retryAfter) } : {})
+        }
+    });
+}
+function jsonResponse(value, status = 200, retryAfter) {
+    return new Response(JSON.stringify(value), {
+        status,
+        headers: {
+            'content-type': 'application/json; charset=utf-8',
+            ...(retryAfter ? { 'retry-after': String(retryAfter) } : {})
+        }
+    });
+}