@flowget/ai-chat 0.1.0

package/dist/server.d.cts

@@ -0,0 +1,91 @@
+import { ResolvedConfig, AuthorRequest } from '@flowget/ai';
+export { AuthorRequest, ResolvedConfig } from '@flowget/ai';
+
+/**
+ * `@flowget/ai-chat/server` — the BFF helper (React-free).
+ *
+ * Wraps `@flowget/ai`'s `authorStream()` and forwards it to the browser as SSE
+ * (one `data:`-framed event per line: `text-delta`* then a terminal
+ * `proposal | message`, or `error`), matching what `@flowget/ai-chat/react`'s
+ * default transport reads. The host owns the engine config (its node catalog,
+ * LLM adapter, guardrail, toolsets) and passes it in — this helper only does
+ * the streaming plumbing.
+ *
+ * ⚠️ **Unauthenticated by design.** This helper performs NO authn/authz and NO
+ * rate-limiting. The host MUST place its own auth + rate-limiting in front of
+ * the route, and — for any actor-scoped data access — inject a *server-derived*
+ * actor via `options.buildRequest` (never trust the client-supplied `actor`).
+ * See the README "Security" section.
+ *
+ * ```ts
+ * // e.g. in a Bun / Node / edge route
+ * import { createChatStreamResponse } from "@flowget/ai-chat/server";
+ * import { finalizeConfig, resolveCatalog, openaiAdapter } from "@flowget/ai";
+ *
+ * const catalog = await resolveCatalog({ registryDir });
+ * const config = finalizeConfig({ adapter: openaiAdapter({ apiKey }), catalog }, catalog);
+ *
+ * export async function POST(req: Request): Promise<Response> {
+ *   // your auth middleware has already run:
+ *   const session = await getSession(req);
+ *   if (!session) return new Response("Unauthorized", { status: 401 });
+ *   return createChatStreamResponse(req, config, {
+ *     // override the untrusted client actor with a server-derived one:
+ *     buildRequest: (parsed) => ({ ...parsed, actor: session.actor }),
+ *   });
+ * }
+ * ```
+ */
+
+/** A resolved config, or a per-request factory (e.g. to pick an adapter). */
+type ChatConfig = ResolvedConfig | ((request: AuthorRequest) => ResolvedConfig | Promise<ResolvedConfig>);
+/** Bounds applied to the request body before authoring. */
+type ChatRequestLimits = {
+    /** Max accepted request-body size, in bytes. Default 1 MiB. */
+    maxBodyBytes?: number;
+    /** Max accepted `command` length, in characters. Default 8000. */
+    maxCommandLength?: number;
+};
+/**
+ * Parse a chat POST body into an {@link AuthorRequest}. Returns `null` when the
+ * body isn't a JSON object with a non-empty, length-bounded `command`, is over
+ * the size cap, or carries a malformed `currentGraph` (a non-object, or an
+ * array — `typeof [] === "object"`, so arrays are rejected explicitly).
+ *
+ * `actor` / `context` are passed through **as-is and untrusted** — a server
+ * that gates on the actor must override it (see `createChatStreamResponse`'s
+ * `buildRequest`) and/or verify it with a `@flowget/ai` authorizer.
+ */
+declare function parseChatRequest(req: Request, limits?: ChatRequestLimits): Promise<AuthorRequest | null>;
+/** Options for {@link createChatStreamResponse}. */
+type CreateChatStreamOptions = ChatRequestLimits & {
+    /**
+     * Rebuild the parsed request before authoring — the seam for injecting a
+     * **server-derived** actor / context (from the host's session/JWT) over the
+     * untrusted client-supplied values. Return the request to author.
+     */
+    buildRequest?: (parsed: AuthorRequest, req: Request) => AuthorRequest | Promise<AuthorRequest>;
+    /**
+     * Map a mid-stream error to a **client-safe** message. The raw error is
+     * always logged server-side; the client only ever sees this string. Defaults
+     * to a generic `"Authoring failed"`.
+     */
+    onError?: (err: unknown) => string;
+};
+/**
+ * Stream `authorStream` for a **pre-built** {@link AuthorRequest} as an SSE
+ * `Response`. The lower-level primitive: use this when you build/validate the
+ * request yourself; otherwise prefer {@link createChatStreamResponse}.
+ */
+declare function streamAuthorSSE(request: AuthorRequest, config: ChatConfig, options?: {
+    signal?: AbortSignal;
+    onError?: (err: unknown) => string;
+}): Response;
+/**
+ * Parse + (optionally) rebuild the request, then stream `authorStream` as SSE.
+ * `config` is the host's `@flowget/ai` `ResolvedConfig` (or a per-request
+ * factory). See {@link CreateChatStreamOptions} for the injection + error seams.
+ */
+declare function createChatStreamResponse(req: Request, config: ChatConfig, options?: CreateChatStreamOptions): Promise<Response>;
+
+export { type ChatConfig, type ChatRequestLimits, type CreateChatStreamOptions, createChatStreamResponse, parseChatRequest, streamAuthorSSE };

package/dist/server.d.ts

@@ -0,0 +1,91 @@
+import { ResolvedConfig, AuthorRequest } from '@flowget/ai';
+export { AuthorRequest, ResolvedConfig } from '@flowget/ai';
+
+/**
+ * `@flowget/ai-chat/server` — the BFF helper (React-free).
+ *
+ * Wraps `@flowget/ai`'s `authorStream()` and forwards it to the browser as SSE
+ * (one `data:`-framed event per line: `text-delta`* then a terminal
+ * `proposal | message`, or `error`), matching what `@flowget/ai-chat/react`'s
+ * default transport reads. The host owns the engine config (its node catalog,
+ * LLM adapter, guardrail, toolsets) and passes it in — this helper only does
+ * the streaming plumbing.
+ *
+ * ⚠️ **Unauthenticated by design.** This helper performs NO authn/authz and NO
+ * rate-limiting. The host MUST place its own auth + rate-limiting in front of
+ * the route, and — for any actor-scoped data access — inject a *server-derived*
+ * actor via `options.buildRequest` (never trust the client-supplied `actor`).
+ * See the README "Security" section.
+ *
+ * ```ts
+ * // e.g. in a Bun / Node / edge route
+ * import { createChatStreamResponse } from "@flowget/ai-chat/server";
+ * import { finalizeConfig, resolveCatalog, openaiAdapter } from "@flowget/ai";
+ *
+ * const catalog = await resolveCatalog({ registryDir });
+ * const config = finalizeConfig({ adapter: openaiAdapter({ apiKey }), catalog }, catalog);
+ *
+ * export async function POST(req: Request): Promise<Response> {
+ *   // your auth middleware has already run:
+ *   const session = await getSession(req);
+ *   if (!session) return new Response("Unauthorized", { status: 401 });
+ *   return createChatStreamResponse(req, config, {
+ *     // override the untrusted client actor with a server-derived one:
+ *     buildRequest: (parsed) => ({ ...parsed, actor: session.actor }),
+ *   });
+ * }
+ * ```
+ */
+
+/** A resolved config, or a per-request factory (e.g. to pick an adapter). */
+type ChatConfig = ResolvedConfig | ((request: AuthorRequest) => ResolvedConfig | Promise<ResolvedConfig>);
+/** Bounds applied to the request body before authoring. */
+type ChatRequestLimits = {
+    /** Max accepted request-body size, in bytes. Default 1 MiB. */
+    maxBodyBytes?: number;
+    /** Max accepted `command` length, in characters. Default 8000. */
+    maxCommandLength?: number;
+};
+/**
+ * Parse a chat POST body into an {@link AuthorRequest}. Returns `null` when the
+ * body isn't a JSON object with a non-empty, length-bounded `command`, is over
+ * the size cap, or carries a malformed `currentGraph` (a non-object, or an
+ * array — `typeof [] === "object"`, so arrays are rejected explicitly).
+ *
+ * `actor` / `context` are passed through **as-is and untrusted** — a server
+ * that gates on the actor must override it (see `createChatStreamResponse`'s
+ * `buildRequest`) and/or verify it with a `@flowget/ai` authorizer.
+ */
+declare function parseChatRequest(req: Request, limits?: ChatRequestLimits): Promise<AuthorRequest | null>;
+/** Options for {@link createChatStreamResponse}. */
+type CreateChatStreamOptions = ChatRequestLimits & {
+    /**
+     * Rebuild the parsed request before authoring — the seam for injecting a
+     * **server-derived** actor / context (from the host's session/JWT) over the
+     * untrusted client-supplied values. Return the request to author.
+     */
+    buildRequest?: (parsed: AuthorRequest, req: Request) => AuthorRequest | Promise<AuthorRequest>;
+    /**
+     * Map a mid-stream error to a **client-safe** message. The raw error is
+     * always logged server-side; the client only ever sees this string. Defaults
+     * to a generic `"Authoring failed"`.
+     */
+    onError?: (err: unknown) => string;
+};
+/**
+ * Stream `authorStream` for a **pre-built** {@link AuthorRequest} as an SSE
+ * `Response`. The lower-level primitive: use this when you build/validate the
+ * request yourself; otherwise prefer {@link createChatStreamResponse}.
+ */
+declare function streamAuthorSSE(request: AuthorRequest, config: ChatConfig, options?: {
+    signal?: AbortSignal;
+    onError?: (err: unknown) => string;
+}): Response;
+/**
+ * Parse + (optionally) rebuild the request, then stream `authorStream` as SSE.
+ * `config` is the host's `@flowget/ai` `ResolvedConfig` (or a per-request
+ * factory). See {@link CreateChatStreamOptions} for the injection + error seams.
+ */
+declare function createChatStreamResponse(req: Request, config: ChatConfig, options?: CreateChatStreamOptions): Promise<Response>;
+
+export { type ChatConfig, type ChatRequestLimits, type CreateChatStreamOptions, createChatStreamResponse, parseChatRequest, streamAuthorSSE };

package/dist/server.js

@@ -0,0 +1,114 @@
+import { authorStream } from '@flowget/ai';
+
+// src/server/index.ts
+var DEFAULT_MAX_BODY_BYTES = 1024 * 1024;
+var DEFAULT_MAX_COMMAND_LENGTH = 8e3;
+async function parseChatRequest(req, limits = {}) {
+  const maxBodyBytes = limits.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES;
+  const maxCommandLength = limits.maxCommandLength ?? DEFAULT_MAX_COMMAND_LENGTH;
+  const declared = Number(req.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > maxBodyBytes) return null;
+  let text;
+  try {
+    text = await req.text();
+  } catch {
+    return null;
+  }
+  if (text.length > maxBodyBytes) return null;
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (body === null || typeof body !== "object" || Array.isArray(body)) {
+    return null;
+  }
+  const record = body;
+  const command = typeof record.command === "string" ? record.command : "";
+  if (command.trim() === "" || command.length > maxCommandLength) return null;
+  const currentGraph = record.currentGraph !== null && typeof record.currentGraph === "object" && !Array.isArray(record.currentGraph) ? record.currentGraph : void 0;
+  const actor = record.actor !== null && typeof record.actor === "object" && !Array.isArray(record.actor) ? record.actor : void 0;
+  return {
+    command,
+    ...currentGraph !== void 0 ? { currentGraph } : {},
+    ...actor !== void 0 ? { actor } : {},
+    ...record.context !== void 0 ? { context: record.context } : {}
+  };
+}
+function sseFrame(event) {
+  return `data: ${JSON.stringify(event)}
+
+`;
+}
+var SSE_HEADERS = {
+  "content-type": "text/event-stream",
+  "cache-control": "no-cache, no-transform",
+  // Disable proxy buffering (nginx) so events flush as they're produced.
+  "x-accel-buffering": "no"
+};
+function streamAuthorSSE(request, config, options = {}) {
+  const { signal, onError } = options;
+  const stream = new ReadableStream({
+    async start(controller) {
+      const encoder = new TextEncoder();
+      let closed = false;
+      const send = (event) => {
+        if (closed) return;
+        try {
+          controller.enqueue(encoder.encode(sseFrame(event)));
+        } catch {
+          closed = true;
+        }
+      };
+      try {
+        const resolved = typeof config === "function" ? await config(request) : config;
+        for await (const event of authorStream(resolved, request, {
+          ...signal ? { signal } : {}
+        })) {
+          send(event);
+        }
+      } catch (err) {
+        console.error("[@flowget/ai-chat] authoring stream failed:", err);
+        send({
+          kind: "error",
+          error: onError ? onError(err) : "Authoring failed"
+        });
+      } finally {
+        closed = true;
+        try {
+          controller.close();
+        } catch {
+        }
+      }
+    }
+  });
+  return new Response(stream, { status: 200, headers: { ...SSE_HEADERS } });
+}
+async function createChatStreamResponse(req, config, options = {}) {
+  const { buildRequest, onError, ...limits } = options;
+  const parsed = await parseChatRequest(req, limits);
+  if (parsed === null) {
+    const body = sseFrame({ kind: "error", error: "Invalid request" });
+    return new Response(body, { status: 200, headers: { ...SSE_HEADERS } });
+  }
+  let request = parsed;
+  if (buildRequest) {
+    try {
+      request = await buildRequest(parsed, req);
+    } catch (err) {
+      console.error("[@flowget/ai-chat] buildRequest failed:", err);
+      const body = sseFrame({
+        kind: "error",
+        error: onError ? onError(err) : "Authoring failed"
+      });
+      return new Response(body, { status: 200, headers: { ...SSE_HEADERS } });
+    }
+  }
+  return streamAuthorSSE(request, config, {
+    ...req.signal ? { signal: req.signal } : {},
+    ...onError ? { onError } : {}
+  });
+}
+
+export { createChatStreamResponse, parseChatRequest, streamAuthorSSE };