@revenexx/editor 0.1.0

package/dist/modules/agent/runtime/server/helpers/routing.d.ts

@@ -0,0 +1,18 @@
+import type { ResolvedSkill } from '../skills/types.js';
+import type { UsageTurn } from '../../shared/types.js';
+export type RoutingResult = {
+    skills: string[];
+    tools: string[];
+    usage?: UsageTurn;
+};
+/**
+ * Pre-process the user's prompt to determine which skills and lazy tools
+ * should be pre-loaded before the main agent loop.
+ *
+ * Uses a fast/cheap model to analyze the prompt and return structured output.
+ * Returns null when routing is not configured, not applicable, or on error.
+ */
+export declare function preprocessPrompt(apiKey: string, prompt: string, resolvedSkills: ResolvedSkill[], lazyToolSummaries: {
+    name: string;
+    description: string;
+}[], signal?: AbortSignal): Promise<RoutingResult | null>;

package/dist/modules/agent/runtime/server/helpers/routing.js

@@ -0,0 +1,104 @@
+import { provider, models } from "#blokkli-build/agent-server";
+import { createUsageTurn } from "./models.js";
+function getRoutingModel() {
+  if (!models.length) return null;
+  return models.find((m) => m.routing) || models.find((m) => m.isDefault) || models[0];
+}
+export async function preprocessPrompt(apiKey, prompt, resolvedSkills, lazyToolSummaries, signal) {
+  const routingModelDef = getRoutingModel();
+  if (!routingModelDef) return null;
+  if (resolvedSkills.length === 0 && lazyToolSummaries.length === 0) return null;
+  const skillNames = resolvedSkills.map((s) => s.name);
+  const toolNames = lazyToolSummaries.map((t) => t.name);
+  const properties = {};
+  const required = [];
+  if (skillNames.length > 0) {
+    properties["skills"] = {
+      type: "array",
+      items: { type: "string", enum: skillNames },
+      description: "Skills to pre-load based on the user prompt."
+    };
+    required.push("skills");
+  }
+  if (toolNames.length > 0) {
+    properties["tools"] = {
+      type: "array",
+      items: { type: "string", enum: toolNames },
+      description: "Tools to pre-load based on the user prompt."
+    };
+    required.push("tools");
+  }
+  const routeTool = {
+    name: "route_prompt",
+    description: "Select which skills and tools are relevant for the user prompt.",
+    input_schema: {
+      type: "object",
+      properties,
+      required
+    }
+  };
+  const lines = [];
+  if (resolvedSkills.length > 0) {
+    lines.push("Available skills:");
+    for (const skill of resolvedSkills) {
+      lines.push(`- ${skill.name}: ${skill.description}`);
+    }
+    lines.push("");
+  }
+  if (lazyToolSummaries.length > 0) {
+    lines.push("Available tools:");
+    for (const tool of lazyToolSummaries) {
+      lines.push(`- ${tool.name}: ${tool.description}`);
+    }
+    lines.push("");
+  }
+  lines.push("User message:");
+  lines.push(prompt);
+  try {
+    let toolInput = "";
+    let usage;
+    const stream = provider.createStream(
+      { apiKey, model: routingModelDef.name },
+      {
+        systemPrompt: [
+          {
+            text: `You are a routing layer for an AI assistant embedded in bl\xF6kkli, a page editor for structured content (paragraphs/blocks). The assistant helps users create, edit, move, and manage page content using MCP tools and skills.
+
+Given the user's message, select which skills and tools should be pre-loaded. Only select items that are clearly relevant to the request. Select nothing if the message is a simple greeting or unrelated to the available options.`
+          }
+        ],
+        messages: [{ role: "user", content: lines.join("\n") }],
+        tools: [routeTool],
+        maxTokens: 256,
+        toolChoice: "any",
+        signal
+      }
+    );
+    for await (const event of stream) {
+      if (signal?.aborted) return null;
+      if (event.type === "tool_use_delta") {
+        toolInput += event.partial_json;
+      } else if (event.type === "message_end") {
+        usage = createUsageTurn(event, routingModelDef) ?? usage;
+      } else if (event.type === "error") {
+        console.warn("[blokkli:agent] Routing error:", event.error.message);
+        return null;
+      }
+    }
+    if (!toolInput) return null;
+    const parsed = JSON.parse(toolInput);
+    const validSkills = new Set(skillNames);
+    const validTools = new Set(toolNames);
+    return {
+      skills: (parsed.skills ?? []).filter((s) => validSkills.has(s)),
+      tools: (parsed.tools ?? []).filter((t) => validTools.has(t)),
+      usage
+    };
+  } catch (error) {
+    console.warn(
+      "[blokkli:agent] Routing failed:",
+      error instanceof Error ? error.message : error
+    );
+    return null;
+  }
+}

package/dist/modules/agent/runtime/server/helpers/security.d.ts

@@ -0,0 +1,22 @@
+import type { ConversationStateSnapshot, GenericMessage } from '../../shared/types.js';
+/**
+ * HMAC-based verification: agent auth tokens (WebSocket handshake) and
+ * conversation-state tamper detection. Both fail closed on a missing secret.
+ */
+/** Seconds an agent auth token remains valid after issuance. */
+export declare const TOKEN_EXPIRY_SECONDS = 300;
+/**
+ * Validate an HMAC auth token: well-formed `<timestamp>:<hmac>`, not expired,
+ * and HMAC matches. Does NOT track one-time use — `SessionManager` layers its
+ * replay check on top. Returns false (never throws) on any malformed input.
+ */
+export declare function validateToken(token: string, secret: string): boolean;
+/**
+ * Compute an HMAC-SHA256 hash for a conversation state snapshot.
+ */
+export declare function computeStateHash(messages: GenericMessage[], activatedLazyTools: string[], secret: string): string;
+/**
+ * Verify the HMAC hash of a conversation state snapshot.
+ * Uses timing-safe comparison to prevent timing attacks.
+ */
+export declare function verifyStateHash(snapshot: ConversationStateSnapshot, secret: string): boolean;

package/dist/modules/agent/runtime/server/helpers/security.js

@@ -0,0 +1,44 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+export const TOKEN_EXPIRY_SECONDS = 300;
+export function validateToken(token, secret) {
+  if (!secret || !token) return false;
+  const colonIndex = token.indexOf(":");
+  if (colonIndex === -1) return false;
+  const timestampStr = token.substring(0, colonIndex);
+  const providedHmac = token.substring(colonIndex + 1);
+  const timestamp = parseInt(timestampStr, 10);
+  if (isNaN(timestamp)) return false;
+  const now = Math.floor(Date.now() / 1e3);
+  if (Math.abs(now - timestamp) > TOKEN_EXPIRY_SECONDS) return false;
+  const expectedHmac = createHmac("sha256", secret).update(timestampStr).digest("hex");
+  if (providedHmac.length !== expectedHmac.length) return false;
+  try {
+    return timingSafeEqual(
+      Buffer.from(providedHmac, "hex"),
+      Buffer.from(expectedHmac, "hex")
+    );
+  } catch {
+    return false;
+  }
+}
+export function computeStateHash(messages, activatedLazyTools, secret) {
+  const payload = JSON.stringify(messages) + "|" + JSON.stringify(activatedLazyTools);
+  return createHmac("sha256", secret).update(payload).digest("hex");
+}
+export function verifyStateHash(snapshot, secret) {
+  if (!secret) return false;
+  const expected = computeStateHash(
+    snapshot.messages,
+    snapshot.activatedLazyTools,
+    secret
+  );
+  if (expected.length !== snapshot.hash.length) return false;
+  try {
+    return timingSafeEqual(
+      Buffer.from(expected, "hex"),
+      Buffer.from(snapshot.hash, "hex")
+    );
+  } catch {
+    return false;
+  }
+}

package/dist/modules/agent/runtime/server/helpers/skills.d.ts

@@ -0,0 +1,14 @@
+import type { PageContext } from '../../shared/types.js';
+import type { ResolvedSkill, SkillDefinition } from '../skills/types.js';
+/**
+ * Resolve the configured skills against the current page context.
+ */
+/**
+ * Resolve a skill label to a string, optionally using the given language.
+ */
+export declare function resolveSkillLabel(label: SkillDefinition['label'], language?: string): string;
+/**
+ * Resolve skills for the given page context.
+ * Calls getContents on each skill and filters out nulls.
+ */
+export declare function resolveSkills(context: PageContext): ResolvedSkill[];

package/dist/modules/agent/runtime/server/helpers/skills.js

@@ -0,0 +1,22 @@
+import { skills } from "#blokkli-build/agent-server";
+export function resolveSkillLabel(label, language) {
+  if (typeof label === "string") return label;
+  if (language && language in label) {
+    return label[language] || label.en;
+  }
+  return label.en;
+}
+export function resolveSkills(context) {
+  return skills.map((skill) => {
+    const content = skill.getContents(context);
+    if (content === null) return null;
+    return {
+      name: skill.name,
+      label: resolveSkillLabel(skill.label, context.interfaceLanguage),
+      englishLabel: resolveSkillLabel(skill.label),
+      description: skill.description,
+      content,
+      tools: skill.tools ?? []
+    };
+  }).filter((s) => s !== null);
+}

package/dist/modules/agent/runtime/server/helpers/socket.d.ts

@@ -0,0 +1,4 @@
+import type { Peer } from 'crossws';
+import type { ServerMessage } from '../../shared/types.js';
+/** Serialize and send a server message to a connected WebSocket peer. */
+export declare function send(peer: Peer, message: ServerMessage): void;

package/dist/modules/agent/runtime/server/helpers/socket.js

@@ -0,0 +1,3 @@
+export function send(peer, message) {
+  peer.send(JSON.stringify(message));
+}

package/dist/modules/agent/runtime/server/helpers/text.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Transform text before sending to client or storing in conversation.
+ * Replaces ß with ss for Swiss German audiences.
+ */
+export declare function transformText(text: string): string;

package/dist/modules/agent/runtime/server/helpers/text.js

@@ -0,0 +1,3 @@
+export function transformText(text) {
+  return text.replace(/ß/g, "ss");
+}

package/dist/modules/agent/runtime/server/providers/anthropic.d.ts

@@ -0,0 +1,12 @@
+import type { AIProvider, ProviderConfig, StreamOptions, StreamEvent } from './types.js';
+/**
+ * Anthropic/Claude AI provider implementation.
+ */
+export declare class AnthropicProvider implements AIProvider {
+    readonly name = "anthropic";
+    createStream(config: ProviderConfig, options: StreamOptions): AsyncIterable<StreamEvent>;
+}
+/**
+ * Create an Anthropic provider instance.
+ */
+export declare function createAnthropicProvider(): AIProvider;

package/dist/modules/agent/runtime/server/providers/anthropic.js

@@ -0,0 +1,151 @@
+import Anthropic from "@anthropic-ai/sdk";
+function convertMessages(messages) {
+  return messages.map((msg) => {
+    if (typeof msg.content === "string") {
+      return {
+        role: msg.role,
+        content: msg.content
+      };
+    }
+    const content = msg.content.filter((block) => block.type !== "reasoning").map((block) => {
+      switch (block.type) {
+        case "text":
+        case "skill":
+          return { type: "text", text: block.text };
+        case "tool_use":
+          return {
+            type: "tool_use",
+            id: block.id,
+            name: block.name,
+            input: block.input
+          };
+        case "tool_result":
+          return {
+            type: "tool_result",
+            tool_use_id: block.tool_use_id,
+            content: block.content,
+            is_error: block.is_error
+          };
+      }
+    });
+    return {
+      role: msg.role,
+      content
+    };
+  });
+}
+function convertSystemPrompt(blocks) {
+  return blocks.map((block) => {
+    const param = { type: "text", text: block.text };
+    if (block.cacheHint) {
+      ;
+      param.cache_control = {
+        type: block.cacheHint
+      };
+    }
+    return param;
+  });
+}
+function convertTools(tools) {
+  return tools.map((tool, i) => {
+    const converted = {
+      name: tool.name,
+      description: tool.description,
+      input_schema: tool.input_schema
+    };
+    if (i === tools.length - 1) {
+      converted.cache_control = { type: "ephemeral" };
+    }
+    return converted;
+  });
+}
+export class AnthropicProvider {
+  name = "anthropic";
+  async *createStream(config, options) {
+    const client = new Anthropic({ apiKey: config.apiKey });
+    const messages = convertMessages(options.messages);
+    const tools = convertTools(options.tools);
+    const requestParams = {
+      model: config.model,
+      max_tokens: options.maxTokens ?? 4096,
+      system: convertSystemPrompt(options.systemPrompt),
+      messages,
+      tools,
+      ...options.toolChoice === "any" ? { tool_choice: { type: "any" } } : {}
+    };
+    if (import.meta.dev) {
+      yield { type: "debug_request", payload: requestParams };
+    }
+    const stream = client.messages.stream(requestParams, {
+      signal: options.signal
+    });
+    let messageEnded = false;
+    let openBlockType = null;
+    try {
+      for await (const event of stream) {
+        if (options.signal?.aborted) {
+          break;
+        }
+        switch (event.type) {
+          case "content_block_start":
+            if (event.content_block.type === "text") {
+              openBlockType = "text";
+              yield { type: "text_start" };
+            } else if (event.content_block.type === "tool_use") {
+              openBlockType = "tool_use";
+              yield {
+                type: "tool_use_start",
+                id: event.content_block.id,
+                name: event.content_block.name
+              };
+            }
+            break;
+          case "content_block_delta":
+            if (event.delta.type === "text_delta") {
+              yield { type: "text_delta", text: event.delta.text };
+            } else if (event.delta.type === "input_json_delta") {
+              yield {
+                type: "tool_use_delta",
+                partial_json: event.delta.partial_json
+              };
+            }
+            break;
+          case "content_block_stop":
+            if (openBlockType === "text") {
+              yield { type: "text_end" };
+            } else if (openBlockType === "tool_use") {
+              yield { type: "tool_use_end" };
+            }
+            openBlockType = null;
+            break;
+          case "message_stop": {
+            const finalMessage = await stream.finalMessage();
+            yield {
+              type: "message_end",
+              stop_reason: finalMessage.stop_reason,
+              // Anthropic's `input_tokens` already excludes cached tokens
+              // (cache reads/writes are reported separately below), so it is
+              // emitted raw. OpenAI's `input_tokens` includes cached tokens, so
+              // that provider subtracts them — both ultimately emit the
+              // non-cached input count for `inputTokens`.
+              inputTokens: finalMessage.usage?.input_tokens,
+              outputTokens: finalMessage.usage?.output_tokens,
+              cacheCreationInputTokens: finalMessage.usage?.cache_creation_input_tokens ?? void 0,
+              cacheReadInputTokens: finalMessage.usage?.cache_read_input_tokens ?? void 0
+            };
+            messageEnded = true;
+            break;
+          }
+        }
+      }
+      if (!messageEnded && !options.signal?.aborted) {
+        yield { type: "message_end", stop_reason: "end_turn" };
+      }
+    } catch (error) {
+      yield { type: "error", error };
+    }
+  }
+}
+export function createAnthropicProvider() {
+  return new AnthropicProvider();
+}

package/dist/modules/agent/runtime/server/providers/openai.d.ts

@@ -0,0 +1,12 @@
+import type { AIProvider, ProviderConfig, StreamOptions, StreamEvent } from './types.js';
+/**
+ * OpenAI provider using the Responses API.
+ */
+export declare class OpenAIProvider implements AIProvider {
+    readonly name = "openai";
+    createStream(config: ProviderConfig, options: StreamOptions): AsyncIterable<StreamEvent>;
+}
+/**
+ * Create an OpenAI provider instance.
+ */
+export declare function createOpenAIProvider(): AIProvider;