@donghanh/hono 0.1.0

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@donghanh/hono",
+  "version": "0.1.0",
+  "description": "Hono routes for GPT Store and LLM chat — renderers for ChatGPT and OpenAI-compatible APIs",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rezzahub/donghanh",
+    "directory": "packages/hono"
+  },
+  "dependencies": {
+    "@donghanh/core": "workspace:*",
+    "hono": "^4.7.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  }
+}

package/src/chat.ts

@@ -0,0 +1,484 @@
+import type { Executor, Registry } from "@donghanh/core";
+import { executeOperation } from "@donghanh/core";
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import type { Authenticate } from "./middleware";
+import { isAuthError } from "./middleware";
+import { renderForLlm } from "./renderers/llm";
+
+export interface ChatRoutesConfig {
+  registry: Registry;
+  executor: Executor;
+  authenticate: Authenticate;
+  /** System prompt for the LLM */
+  systemPrompt?: string;
+  /** Hook to enrich data after operation execution (e.g. inject formatted balances) */
+  enrichData?: (
+    data: unknown,
+    context: {
+      operationId: string;
+      variables: Record<string, unknown>;
+      userId: string;
+    },
+  ) => Promise<void>;
+  /** LLM model identifier (e.g. "anthropic/claude-sonnet-4") */
+  model?: string;
+  /** OpenRouter API key */
+  apiKey?: string;
+  /** Base URL for OpenAI-compatible API (default: OpenRouter) */
+  baseUrl?: string;
+}
+
+export interface ChatMessage {
+  role: "user" | "assistant";
+  content: string;
+  actions?: Array<{
+    operation: string;
+    label: string;
+    variables?: Record<string, unknown>;
+  }>;
+}
+
+interface ChatAction {
+  operation: string;
+  label: string;
+  variables?: Record<string, unknown>;
+}
+
+// OpenAI-compatible types
+interface OaiTool {
+  type: "function";
+  function: {
+    name: string;
+    description: string;
+    parameters: object;
+  };
+}
+
+interface OaiMessage {
+  role: "system" | "user" | "assistant" | "tool";
+  content?: string | null;
+  tool_calls?: OaiToolCall[];
+  tool_call_id?: string;
+}
+
+interface OaiToolCall {
+  id: string;
+  type: "function";
+  function: { name: string; arguments: string };
+}
+
+interface OaiChoice {
+  message: {
+    role: "assistant";
+    content?: string | null;
+    tool_calls?: OaiToolCall[];
+  };
+  finish_reason: string;
+}
+
+interface OaiResponse {
+  choices: OaiChoice[];
+}
+
+interface OaiStreamChunk {
+  choices: Array<{
+    delta: { content?: string | null };
+    finish_reason: string | null;
+  }>;
+}
+
+export function chatRoutes(config: ChatRoutesConfig): Hono {
+  const { registry, executor, authenticate } = config;
+  const baseUrl = config.baseUrl ?? "https://openrouter.ai/api/v1";
+
+  const app = new Hono();
+
+  app.post("/", async (c) => {
+    const authResult = await authenticate(c.req.raw);
+    if (isAuthError(authResult)) return authResult.error;
+
+    const body = await c.req.json();
+    const messages: ChatMessage[] = body.messages ?? [];
+    const initOperation:
+      | { id: string; variables?: Record<string, unknown> }
+      | undefined = body.initOperation;
+    const action: ChatAction | undefined = body.action;
+
+    const operations = registry.list();
+    const tools: OaiTool[] = operations.map((op) => {
+      const detail = registry.detail(op.id);
+      return {
+        type: "function" as const,
+        function: {
+          name: op.id,
+          description: `${op.description}. ${detail?.instruction ?? ""}`.trim(),
+          parameters: detail?.input ?? { type: "object", properties: {} },
+        },
+      };
+    });
+
+    const model = config.model ?? "google/gemini-2.5-flash";
+    const systemPrompt =
+      config.systemPrompt ??
+      "You are a helpful assistant. Use the tools to help the user.";
+
+    // Init operation context
+    let initContext = "";
+    if (initOperation && messages.length <= 1) {
+      try {
+        const initVars = initOperation.variables ?? {};
+        const { data, brief } = await executeOperation({
+          registry,
+          operationId: initOperation.id,
+          variables: initVars,
+          executor,
+          context: { userId: authResult.userId, request: c.req.raw },
+        });
+        if (config.enrichData) {
+          await config.enrichData(data, {
+            operationId: initOperation.id,
+            variables: initVars,
+            userId: authResult.userId,
+          });
+        }
+        const rendered = renderForLlm(brief);
+        initContext = `\n\nUser context:\n${JSON.stringify(data)}\n\n${rendered.text}`;
+      } catch {
+        // continue without context
+      }
+    }
+
+    const llmMessages: OaiMessage[] = [
+      { role: "system", content: systemPrompt + initContext },
+      ...messages.map(
+        (m): OaiMessage => ({ role: m.role, content: m.content }),
+      ),
+    ];
+
+    let currentActions: ChatMessage["actions"] = [];
+
+    // If user clicked an action button, execute the operation directly
+    // and inject the result as a synthetic tool call for the LLM to explain
+    if (action) {
+      const toolCallId = `action-${Date.now()}`;
+
+      try {
+        const variables = action.variables ?? {};
+        const { data, brief } = await executeOperation({
+          registry,
+          operationId: action.operation,
+          variables,
+          executor,
+          context: { userId: authResult.userId, request: c.req.raw },
+        });
+
+        if (config.enrichData) {
+          await config.enrichData(data, {
+            operationId: action.operation,
+            variables,
+            userId: authResult.userId,
+          });
+        }
+
+        const rendered = renderForLlm(brief);
+        currentActions = rendered.actions.map((a) => ({
+          operation: a.operation,
+          label: a.label,
+          variables: a.variables,
+        }));
+
+        const resultContent = `Data: ${JSON.stringify(data)}\n\n${rendered.text}`;
+
+        // Inject as if the LLM called the tool itself
+        llmMessages.push({
+          role: "assistant",
+          content: null,
+          tool_calls: [
+            {
+              id: toolCallId,
+              type: "function",
+              function: {
+                name: action.operation,
+                arguments: JSON.stringify(variables),
+              },
+            },
+          ],
+        });
+        llmMessages.push({
+          role: "tool",
+          tool_call_id: toolCallId,
+          content: resultContent,
+        });
+      } catch (err: unknown) {
+        const error = err as { message?: string };
+        llmMessages.push({
+          role: "assistant",
+          content: null,
+          tool_calls: [
+            {
+              id: toolCallId,
+              type: "function",
+              function: {
+                name: action.operation,
+                arguments: JSON.stringify(action.variables ?? {}),
+              },
+            },
+          ],
+        });
+        llmMessages.push({
+          role: "tool",
+          tool_call_id: toolCallId,
+          content: `Error: ${error?.message ?? "Unknown error"}`,
+        });
+      }
+
+      // Stream the LLM's explanation of the result
+      return streamSSE(c, async (stream) => {
+        try {
+          for await (const chunk of streamLlmCall(
+            baseUrl,
+            config.apiKey!,
+            model,
+            llmMessages,
+            tools,
+          )) {
+            await stream.writeSSE({ event: "text", data: chunk });
+          }
+        } catch {
+          await stream.writeSSE({
+            event: "text",
+            data: "Something went wrong generating the response.",
+          });
+        }
+        if (currentActions && currentActions.length > 0) {
+          await stream.writeSSE({
+            event: "actions",
+            data: JSON.stringify(currentActions),
+          });
+        }
+        await stream.writeSSE({ event: "done", data: "" });
+      });
+    }
+
+    // Normal flow: LLM decides what tools to call
+    // Tool use loop — non-streaming
+    let llmResponse = await callLlm(
+      baseUrl,
+      config.apiKey!,
+      model,
+      llmMessages,
+      tools,
+    );
+
+    while (llmResponse.choices[0]?.finish_reason === "tool_calls") {
+      const choice = llmResponse.choices[0];
+      const toolCalls = choice.message.tool_calls ?? [];
+
+      llmMessages.push({
+        role: "assistant",
+        content: choice.message.content,
+        tool_calls: toolCalls,
+      });
+
+      for (const toolCall of toolCalls) {
+        const resultContent = await executeToolCall(
+          toolCall,
+          registry,
+          executor,
+          config,
+          authResult.userId,
+          c.req.raw,
+        );
+        currentActions = resultContent.actions;
+
+        llmMessages.push({
+          role: "tool",
+          tool_call_id: toolCall.id,
+          content: resultContent.text,
+        });
+      }
+
+      llmResponse = await callLlm(
+        baseUrl,
+        config.apiKey!,
+        model,
+        llmMessages,
+        tools,
+      );
+    }
+
+    // Final response — stream it
+    const hadToolCalls = llmMessages.length > messages.length + 1;
+
+    if (hadToolCalls) {
+      // Tool loop done — stream the LLM's final explanation
+      return streamSSE(c, async (stream) => {
+        try {
+          for await (const chunk of streamLlmCall(
+            baseUrl,
+            config.apiKey!,
+            model,
+            llmMessages,
+            tools,
+          )) {
+            await stream.writeSSE({ event: "text", data: chunk });
+          }
+        } catch {
+          await stream.writeSSE({
+            event: "text",
+            data: "Something went wrong generating the response.",
+          });
+        }
+        if (currentActions && currentActions.length > 0) {
+          await stream.writeSSE({
+            event: "actions",
+            data: JSON.stringify(currentActions),
+          });
+        }
+        await stream.writeSSE({ event: "done", data: "" });
+      });
+    }
+
+    // No tool calls — stream the response we already have, or re-request streaming
+    const existingText = llmResponse.choices[0]?.message.content;
+    return streamSSE(c, async (stream) => {
+      if (existingText) {
+        await stream.writeSSE({ event: "text", data: existingText });
+      }
+      await stream.writeSSE({ event: "done", data: "" });
+    });
+  });
+
+  return app;
+}
+
+// --- Helpers ---
+
+async function executeToolCall(
+  toolCall: OaiToolCall,
+  registry: Registry,
+  executor: Executor,
+  config: ChatRoutesConfig,
+  userId: string,
+  request: Request,
+): Promise<{ text: string; actions: ChatMessage["actions"] }> {
+  try {
+    const variables = JSON.parse(toolCall.function.arguments) as Record<
+      string,
+      unknown
+    >;
+
+    const { data, brief } = await executeOperation({
+      registry,
+      operationId: toolCall.function.name,
+      variables,
+      executor,
+      context: { userId, request },
+    });
+
+    if (config.enrichData) {
+      await config.enrichData(data, {
+        operationId: toolCall.function.name,
+        variables,
+        userId,
+      });
+    }
+
+    const rendered = renderForLlm(brief);
+    return {
+      text: `Data: ${JSON.stringify(data)}\n\n${rendered.text}`,
+      actions: rendered.actions.map((a) => ({
+        operation: a.operation,
+        label: a.label,
+        variables: a.variables,
+      })),
+    };
+  } catch (err: unknown) {
+    const error = err as { message?: string };
+    return {
+      text: `Error: ${error?.message ?? "Unknown error"}`,
+      actions: [],
+    };
+  }
+}
+
+async function callLlm(
+  baseUrl: string,
+  apiKey: string,
+  model: string,
+  messages: OaiMessage[],
+  tools: OaiTool[],
+): Promise<OaiResponse> {
+  const resp = await fetch(`${baseUrl}/chat/completions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({ model, messages, tools, max_tokens: 4096 }),
+  });
+
+  if (!resp.ok) {
+    const text = await resp.text();
+    throw new Error(`LLM API error (${resp.status}): ${text}`);
+  }
+
+  return resp.json();
+}
+
+async function* streamLlmCall(
+  baseUrl: string,
+  apiKey: string,
+  model: string,
+  messages: OaiMessage[],
+  tools: OaiTool[],
+): AsyncGenerator<string> {
+  const resp = await fetch(`${baseUrl}/chat/completions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      model,
+      messages,
+      tools,
+      max_tokens: 4096,
+      stream: true,
+    }),
+  });
+
+  if (!resp.ok) {
+    const text = await resp.text();
+    throw new Error(`LLM API error (${resp.status}): ${text}`);
+  }
+
+  const reader = resp.body!.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("data: ")) continue;
+      const data = trimmed.slice(6);
+      if (data === "[DONE]") return;
+
+      try {
+        const chunk: OaiStreamChunk = JSON.parse(data);
+        const content = chunk.choices[0]?.delta?.content;
+        if (content) yield content;
+      } catch {
+        // skip malformed chunks
+      }
+    }
+  }
+}

package/src/gpt.ts

@@ -0,0 +1,252 @@
+import type { Executor, Registry } from "@donghanh/core";
+import { executeOperation } from "@donghanh/core";
+import { Hono } from "hono";
+import type { Authenticate } from "./middleware";
+import { isAuthError } from "./middleware";
+import { renderForChatGpt } from "./renderers/chatgpt";
+
+export interface GptRoutesConfig {
+  registry: Registry;
+  executor: Executor;
+  authenticate: Authenticate;
+  encodeVariables?: (vars: Record<string, unknown>) => string;
+  responseSchemas?: Record<string, object>;
+  /** Hook to enrich the JSON response (e.g. inject display text) */
+  enrichResponse?: (
+    result: Record<string, unknown>,
+    opts: {
+      operationId: string;
+      data: unknown;
+      variables: Record<string, unknown>;
+      userId: string;
+      request: Request;
+    },
+  ) => Promise<void>;
+}
+
+function jsonError(message: string, status = 400): Response {
+  return new Response(JSON.stringify({ errors: [{ message }] }), {
+    status,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+export function gptRoutes(config: GptRoutesConfig): Hono {
+  const {
+    registry,
+    executor,
+    authenticate,
+    encodeVariables,
+    responseSchemas,
+    enrichResponse,
+  } = config;
+
+  const app = new Hono();
+
+  // List operations
+  app.get("/operations", (c) => {
+    const url = new URL(c.req.url);
+    const search = url.searchParams.get("search")?.toLowerCase();
+    const typeFilter = url.searchParams.get("type");
+
+    let operations = registry.list();
+
+    if (typeFilter || search) {
+      operations = operations.filter((op) => {
+        if (typeFilter && op.type !== typeFilter) return false;
+        if (search) {
+          return (
+            op.id.includes(search) ||
+            op.description.toLowerCase().includes(search)
+          );
+        }
+        return true;
+      });
+    }
+
+    return c.json({ operations });
+  });
+
+  // Operation detail
+  app.get("/operations/:name", (c) => {
+    const name = c.req.param("name");
+    const detail = registry.detail(name);
+
+    if (!detail) {
+      return c.json(
+        {
+          error: `Unknown operation "${name}". Call GET /api/gpt/operations to list available operations.`,
+        },
+        404,
+      );
+    }
+
+    return c.json(detail);
+  });
+
+  // Execute query
+  app.get("/query/:operation", async (c) => {
+    const authResult = await authenticate(c.req.raw);
+    if (isAuthError(authResult)) return authResult.error;
+
+    const operationId = c.req.param("operation");
+    const op = registry.get(operationId);
+
+    if (!op) {
+      return jsonError(
+        `Unknown operation "${operationId}". Call GET /api/gpt/operations to discover available operations.`,
+      );
+    }
+    if (op.operationConfig.type !== "query") {
+      return jsonError(
+        `"${operationId}" is a mutation. Use POST /api/gpt/mutate/${operationId} instead.`,
+      );
+    }
+
+    return handleExecution(c.req.raw, authResult.userId, operationId, () => {
+      const url = new URL(c.req.url);
+      return url.searchParams.get("$variables") ?? undefined;
+    });
+  });
+
+  // Execute mutation
+  app.post("/mutate/:operation", async (c) => {
+    const authResult = await authenticate(c.req.raw);
+    if (isAuthError(authResult)) return authResult.error;
+
+    const operationId = c.req.param("operation");
+    const op = registry.get(operationId);
+
+    if (!op) {
+      return jsonError(
+        `Unknown operation "${operationId}". Call GET /api/gpt/operations to discover available operations.`,
+      );
+    }
+    if (op.operationConfig.type !== "mutation") {
+      return jsonError(
+        `"${operationId}" is a query. Use GET /api/gpt/query/${operationId} instead.`,
+      );
+    }
+
+    return handleExecution(
+      c.req.raw,
+      authResult.userId,
+      operationId,
+      async () => {
+        const body = await c.req.json();
+        return body.$variables;
+      },
+    );
+  });
+
+  async function handleExecution(
+    request: Request,
+    userId: string,
+    operationId: string,
+    getVariables: () => string | undefined | Promise<string | undefined>,
+  ): Promise<Response> {
+    let rawVariables: string | undefined;
+    try {
+      rawVariables = await getVariables();
+    } catch {
+      return jsonError("Invalid request body");
+    }
+
+    let variables: Record<string, unknown> = {};
+    if (typeof rawVariables === "string" && encodeVariables) {
+      // Decode using the inverse - we expect TOON format
+      // The app provides its own decode in the executor or via a decode option
+      // For now, pass raw through and let the executor handle it
+    }
+
+    // We need a decode function. Let's accept raw variables as TOON or JSON.
+    if (typeof rawVariables === "string") {
+      try {
+        // Try JSON first
+        variables = JSON.parse(rawVariables);
+      } catch {
+        // Pass as-is, let the app's decode handle it
+        // Store raw so executor can decode
+        variables = { $raw: rawVariables };
+      }
+    }
+
+    try {
+      const { data, brief } = await executeOperation({
+        registry,
+        operationId,
+        variables,
+        executor,
+        context: { userId, request },
+      });
+
+      // Render JSX tree through ChatGPT renderer
+      const rendered = renderForChatGpt(brief, {
+        encodeVariables,
+        getOperationInput: (id) => {
+          const detail = registry.detail(id);
+          return detail?.input;
+        },
+      });
+
+      // Build response
+      const result: Record<string, unknown> = {
+        data: {
+          [registry.get(operationId)!.operationConfig.responseKey]: data,
+        },
+      };
+
+      if (rendered.suggestedActions.length > 0) {
+        result.suggestedActions = rendered.suggestedActions;
+      }
+      if (rendered.nextSteps) {
+        result.nextSteps = rendered.nextSteps;
+      }
+
+      // Enrich response (inject display, etc)
+      if (enrichResponse) {
+        await enrichResponse(result, {
+          operationId,
+          data,
+          variables,
+          userId,
+          request,
+        });
+      }
+
+      // Include response schema for start
+      if (operationId === "start" && responseSchemas?.start) {
+        result.responseSchema = responseSchemas.start;
+      }
+
+      // Always include operations list
+      result.operations = registry.list();
+
+      return new Response(JSON.stringify(result), {
+        headers: { "content-type": "application/json" },
+      });
+    } catch (err: any) {
+      const message = err?.message ?? "Internal error";
+
+      const errorResult: Record<string, unknown> = {
+        errors: [{ message }],
+      };
+
+      // Include operation detail for self-correction
+      const detail = registry.detail(operationId);
+      if (detail) {
+        errorResult.operationDetail = {
+          instruction: detail.instruction,
+          input: detail.input,
+        };
+      }
+
+      return new Response(JSON.stringify(errorResult), {
+        status: 400,
+        headers: { "content-type": "application/json" },
+      });
+    }
+  }
+
+  return app;
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export type { ChatMessage, ChatRoutesConfig } from "./chat";
+export { chatRoutes } from "./chat";
+export type { GptRoutesConfig } from "./gpt";
+export { gptRoutes } from "./gpt";
+export type { AuthError, Authenticate, AuthResult } from "./middleware";
+export { isAuthError } from "./middleware";
+export type { ChatGptResult, SuggestedAction } from "./renderers/chatgpt";
+export { renderForChatGpt } from "./renderers/chatgpt";
+export type { LlmAction, LlmResult } from "./renderers/llm";
+export { renderForLlm } from "./renderers/llm";

package/src/middleware.ts

@@ -0,0 +1,17 @@
+export interface AuthResult {
+  userId: string;
+}
+
+export interface AuthError {
+  error: Response;
+}
+
+export type Authenticate = (
+  request: Request,
+) => Promise<AuthResult | AuthError>;
+
+export function isAuthError(
+  result: AuthResult | AuthError,
+): result is AuthError {
+  return "error" in result;
+}

package/src/renderers/chatgpt.ts

@@ -0,0 +1,127 @@
+import type {
+  ActionNode,
+  BriefNode,
+  ChatNode,
+  ContextNode,
+  DisplayNode,
+  FormNode,
+  MessageNode,
+  Renderer,
+} from "@donghanh/core";
+import { renderNode } from "@donghanh/core";
+
+export interface ChatGptResult {
+  nextSteps?: string;
+  suggestedActions: SuggestedAction[];
+  display?: string;
+  context?: unknown[];
+}
+
+export interface SuggestedAction {
+  id: string;
+  type: string;
+  description: string;
+  variables?: Record<string, unknown>;
+  $variables?: string;
+  input?: object;
+}
+
+interface Fragment {
+  kind: "message" | "action" | "display" | "context";
+  value: unknown;
+}
+
+const chatGptRenderer: Renderer<Fragment | Fragment[]> = {
+  brief(_node: BriefNode, children: (Fragment | Fragment[])[]): Fragment[] {
+    return children.flat();
+  },
+
+  message(node: MessageNode): Fragment {
+    return { kind: "message", value: node.content };
+  },
+
+  action(node: ActionNode): Fragment {
+    const action: SuggestedAction = {
+      id: node.operation,
+      type: "action",
+      description: node.label,
+      variables: node.variables,
+    };
+    return { kind: "action", value: action };
+  },
+
+  form(_node: FormNode): Fragment {
+    // Forms are exposed via operation detail, not in response
+    return { kind: "context", value: null };
+  },
+
+  display(node: DisplayNode): Fragment {
+    return { kind: "display", value: node.data };
+  },
+
+  context(node: ContextNode): Fragment {
+    return { kind: "context", value: node.value };
+  },
+};
+
+export function renderForChatGpt(
+  brief: ChatNode,
+  opts?: {
+    encodeVariables?: (vars: Record<string, unknown>) => string;
+    getOperationInput?: (id: string) => object | undefined;
+  },
+): ChatGptResult {
+  const fragments = renderNode(brief, chatGptRenderer) as Fragment | Fragment[];
+  const flat = Array.isArray(fragments) ? fragments : [fragments];
+
+  const messages: string[] = [];
+  const actions: SuggestedAction[] = [];
+  const displays: unknown[] = [];
+  const contexts: unknown[] = [];
+
+  for (const f of flat) {
+    if (f.value == null) continue;
+    switch (f.kind) {
+      case "message":
+        messages.push(f.value as string);
+        break;
+      case "action": {
+        const action = f.value as SuggestedAction;
+        if (action.variables && opts?.encodeVariables) {
+          action.$variables = opts.encodeVariables(action.variables);
+        }
+        if (opts?.getOperationInput) {
+          action.input = opts.getOperationInput(action.id) ?? {};
+        }
+        actions.push(action);
+        break;
+      }
+      case "display":
+        displays.push(f.value);
+        break;
+      case "context":
+        contexts.push(f.value);
+        break;
+    }
+  }
+
+  const result: ChatGptResult = {
+    suggestedActions: actions,
+  };
+
+  if (messages.length > 0) {
+    result.nextSteps = messages.join(" ");
+  }
+
+  if (displays.length === 1) {
+    result.display = displays[0] as string;
+  } else if (displays.length > 1) {
+    result.display = displays as any;
+  }
+
+  if (contexts.length > 0) {
+    result.context = contexts;
+  }
+
+  return result;
+}

package/src/renderers/llm.ts

@@ -0,0 +1,106 @@
+import type {
+  ActionNode,
+  BriefNode,
+  ChatNode,
+  ContextNode,
+  DisplayNode,
+  FormNode,
+  MessageNode,
+  Renderer,
+} from "@donghanh/core";
+import { renderNode } from "@donghanh/core";
+
+export interface LlmResult {
+  text: string;
+  actions: LlmAction[];
+  context?: unknown[];
+}
+
+export interface LlmAction {
+  operation: string;
+  label: string;
+  variables?: Record<string, unknown>;
+}
+
+interface Fragment {
+  kind: "message" | "action" | "display" | "context";
+  value: unknown;
+}
+
+const llmRenderer: Renderer<Fragment | Fragment[]> = {
+  brief(_node: BriefNode, children: (Fragment | Fragment[])[]): Fragment[] {
+    return children.flat();
+  },
+
+  message(node: MessageNode): Fragment {
+    return { kind: "message", value: node.content };
+  },
+
+  action(node: ActionNode): Fragment {
+    const action: LlmAction = {
+      operation: node.operation,
+      label: node.label,
+      variables: node.variables,
+    };
+    return { kind: "action", value: action };
+  },
+
+  form(_node: FormNode): Fragment {
+    return { kind: "context", value: null };
+  },
+
+  display(node: DisplayNode): Fragment {
+    return { kind: "display", value: node.data };
+  },
+
+  context(node: ContextNode): Fragment {
+    return { kind: "context", value: node.value };
+  },
+};
+
+export function renderForLlm(brief: ChatNode): LlmResult {
+  const fragments = renderNode(brief, llmRenderer) as Fragment | Fragment[];
+  const flat = Array.isArray(fragments) ? fragments : [fragments];
+
+  const messages: string[] = [];
+  const actions: LlmAction[] = [];
+  const displays: string[] = [];
+  const contexts: unknown[] = [];
+
+  for (const f of flat) {
+    if (f.value == null) continue;
+    switch (f.kind) {
+      case "message":
+        messages.push(f.value as string);
+        break;
+      case "action":
+        actions.push(f.value as LlmAction);
+        break;
+      case "display":
+        displays.push(
+          typeof f.value === "string" ? f.value : JSON.stringify(f.value),
+        );
+        break;
+      case "context":
+        contexts.push(f.value);
+        break;
+    }
+  }
+
+  const parts: string[] = [];
+  if (messages.length > 0) parts.push(messages.join("\n"));
+  if (displays.length > 0) parts.push(displays.join("\n"));
+
+  if (actions.length > 0) {
+    const actionList = actions
+      .map((a) => `- ${a.label} (${a.operation})`)
+      .join("\n");
+    parts.push(`Suggested actions:\n${actionList}`);
+  }
+
+  return {
+    text: parts.join("\n\n"),
+    actions,
+    context: contexts.length > 0 ? contexts : undefined,
+  };
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "jsxImportSource": "@donghanh/core",
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}