@blokkli/editor 2.0.0-alpha.5 → 2.0.0-alpha.50

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

@@ -0,0 +1,321 @@
+import OpenAI from "openai";
+function convertMessages(messages) {
+  const result = [];
+  for (const msg of messages) {
+    if (typeof msg.content === "string") {
+      result.push({
+        role: msg.role,
+        content: msg.content
+      });
+      continue;
+    }
+    if (msg.role === "assistant") {
+      const textParts = [];
+      for (const block of msg.content) {
+        if (block.type === "text" || block.type === "skill") {
+          textParts.push(block.text);
+        } else if (block.type === "reasoning") {
+          if (textParts.length > 0) {
+            result.push({
+              role: "assistant",
+              content: textParts.join("\n")
+            });
+            textParts.length = 0;
+          }
+          const reasoningItem = {
+            type: "reasoning",
+            id: block.id,
+            summary: [{ type: "summary_text", text: block.text }]
+          };
+          if (block.encryptedContent) {
+            reasoningItem.encrypted_content = block.encryptedContent;
+          }
+          result.push(reasoningItem);
+        } else if (block.type === "tool_use") {
+          if (textParts.length > 0) {
+            result.push({
+              role: "assistant",
+              content: textParts.join("\n")
+            });
+            textParts.length = 0;
+          }
+          result.push({
+            type: "function_call",
+            call_id: block.id,
+            name: block.name,
+            arguments: JSON.stringify(block.input)
+          });
+        }
+      }
+      if (textParts.length > 0) {
+        result.push({
+          role: "assistant",
+          content: textParts.join("\n")
+        });
+      }
+    } else if (msg.role === "user") {
+      const textParts = [];
+      for (const block of msg.content) {
+        if (block.type === "text" || block.type === "skill") {
+          textParts.push(block.text);
+        } else if (block.type === "tool_result") {
+          if (textParts.length > 0) {
+            result.push({ role: "user", content: textParts.join("\n") });
+            textParts.length = 0;
+          }
+          result.push({
+            type: "function_call_output",
+            call_id: block.tool_use_id,
+            output: block.content
+          });
+        }
+      }
+      if (textParts.length > 0) {
+        result.push({ role: "user", content: textParts.join("\n") });
+      }
+    }
+  }
+  return result;
+}
+function convertTools(tools) {
+  return tools.map((tool) => ({
+    type: "function",
+    name: tool.name,
+    description: tool.description ?? null,
+    parameters: tool.input_schema,
+    strict: false
+  }));
+}
+export class OpenAIProvider {
+  name = "openai";
+  async *createStream(config, options) {
+    const client = new OpenAI({ apiKey: config.apiKey });
+    const input = convertMessages(options.messages);
+    const tools = convertTools(options.tools);
+    const instructions = options.systemPrompt.map((b) => b.text).join("\n\n");
+    const requestParams = {
+      model: config.model,
+      instructions,
+      input,
+      tools: tools.length > 0 ? tools : void 0,
+      max_output_tokens: options.maxTokens ?? 4096,
+      store: false,
+      include: ["reasoning.encrypted_content"],
+      parallel_tool_calls: false,
+      reasoning: { effort: "low", summary: "auto" },
+      ...options.toolChoice === "any" ? { tool_choice: "required" } : {}
+    };
+    if (import.meta.dev) {
+      yield { type: "debug_request", payload: requestParams };
+    }
+    try {
+      const stream = await client.responses.create(
+        { ...requestParams, stream: true },
+        { signal: options.signal }
+      );
+      let hasFunctionCalls = false;
+      let inTextBlock = false;
+      let currentToolCallId = null;
+      let currentReasoningContent = "";
+      for await (const event of stream) {
+        if (options.signal?.aborted) break;
+        switch (event.type) {
+          // Text streaming
+          case "response.content_part.added":
+            if (event.part.type === "output_text") {
+              inTextBlock = true;
+              yield { type: "text_start" };
+            }
+            break;
+          case "response.output_text.delta":
+            yield { type: "text_delta", text: event.delta };
+            break;
+          case "response.output_text.done":
+            inTextBlock = false;
+            yield { type: "text_end" };
+            break;
+          // Refusal streaming — map to text events so the user sees the
+          // refusal message instead of getting an empty/silent response.
+          case "response.refusal.delta":
+            if (!inTextBlock) {
+              inTextBlock = true;
+              yield { type: "text_start" };
+            }
+            yield { type: "text_delta", text: event.delta };
+            break;
+          case "response.refusal.done":
+            if (inTextBlock) {
+              inTextBlock = false;
+              yield { type: "text_end" };
+            }
+            break;
+          // Tool call streaming
+          case "response.output_item.added":
+            if (event.item.type === "function_call") {
+              hasFunctionCalls = true;
+              currentToolCallId = event.item.call_id;
+              yield {
+                type: "tool_use_start",
+                id: event.item.call_id,
+                name: event.item.name
+              };
+            }
+            break;
+          case "response.function_call_arguments.delta":
+            yield { type: "tool_use_delta", partial_json: event.delta };
+            break;
+          case "response.function_call_arguments.done":
+            currentToolCallId = null;
+            yield { type: "tool_use_end" };
+            break;
+          // Safety net: if a function_call item completes but we still
+          // have an open tool call (e.g. arguments.done was missed),
+          // close it here. Also flush accumulated reasoning when the
+          // reasoning output item completes.
+          case "response.output_item.done":
+            if (event.item.type === "function_call" && currentToolCallId === event.item.call_id) {
+              currentToolCallId = null;
+              yield { type: "tool_use_end" };
+            } else if (event.item.type === "reasoning") {
+              yield {
+                type: "reasoning_summary",
+                id: event.item.id,
+                text: currentReasoningContent,
+                encryptedContent: event.item.encrypted_content ?? void 0
+              };
+              currentReasoningContent = "";
+            }
+            break;
+          // Completion
+          case "response.completed": {
+            const usage = event.response.usage;
+            let stopReason = void 0;
+            if (hasFunctionCalls) {
+              stopReason = buildMessageEnd("tool_use", usage);
+            } else if (event.response.status === "incomplete") {
+              stopReason = buildMessageEnd("max_tokens", usage);
+            } else {
+              stopReason = buildMessageEnd("end_turn", usage);
+            }
+            yield stopReason;
+            break;
+          }
+          // Truncated response (max_output_tokens, content filter).
+          // Unlike response.completed, this fires when the response
+          // could not finish normally. Close any open blocks and yield
+          // message_end so Session.ts can continue the agent loop.
+          case "response.incomplete": {
+            if (inTextBlock) {
+              inTextBlock = false;
+              yield { type: "text_end" };
+            }
+            if (currentToolCallId) {
+              currentToolCallId = null;
+              yield { type: "tool_use_end" };
+            }
+            const usage = event.response.usage;
+            const stopReason = hasFunctionCalls ? "tool_use" : "max_tokens";
+            yield buildMessageEnd(stopReason, usage);
+            break;
+          }
+          case "response.failed": {
+            const errorMsg = event.response?.error?.message || "OpenAI response failed";
+            yield {
+              type: "error",
+              error: new Error(errorMsg)
+            };
+            break;
+          }
+          // Streaming error event (distinct from response.failed).
+          case "error":
+            yield {
+              type: "error",
+              error: new Error(event.message || "OpenAI stream error")
+            };
+            break;
+          // Lifecycle events — no action needed.
+          // Lifecycle, redundant completions, audio, built-in tools,
+          // image generation, server-side MCP, custom hosted tools,
+          // and internal reasoning/CoT — all not used.
+          case "response.created":
+          case "response.in_progress":
+          case "response.queued":
+          case "response.content_part.done":
+          case "response.output_text.annotation.added":
+          case "response.audio.delta":
+          case "response.audio.done":
+          case "response.audio.transcript.delta":
+          case "response.audio.transcript.done":
+          case "response.code_interpreter_call.completed":
+          case "response.code_interpreter_call.in_progress":
+          case "response.code_interpreter_call.interpreting":
+          case "response.code_interpreter_call_code.delta":
+          case "response.code_interpreter_call_code.done":
+          case "response.file_search_call.completed":
+          case "response.file_search_call.in_progress":
+          case "response.file_search_call.searching":
+          case "response.web_search_call.completed":
+          case "response.web_search_call.in_progress":
+          case "response.web_search_call.searching":
+          case "response.image_generation_call.completed":
+          case "response.image_generation_call.generating":
+          case "response.image_generation_call.in_progress":
+          case "response.image_generation_call.partial_image":
+          case "response.mcp_call.completed":
+          case "response.mcp_call.failed":
+          case "response.mcp_call.in_progress":
+          case "response.mcp_call_arguments.delta":
+          case "response.mcp_call_arguments.done":
+          case "response.mcp_list_tools.completed":
+          case "response.mcp_list_tools.failed":
+          case "response.mcp_list_tools.in_progress":
+          case "response.custom_tool_call_input.delta":
+          case "response.custom_tool_call_input.done":
+            console.debug("[blokkli:agent] Unhandled response event: ", event);
+            break;
+          // Reasoning summary — capture and yield so Session.ts can
+          // persist it in the conversation history for multi-turn coherence.
+          case "response.reasoning_summary_part.added":
+            break;
+          case "response.reasoning_summary_text.delta":
+            currentReasoningContent += event.delta;
+            break;
+          case "response.reasoning_summary_text.done":
+            break;
+          case "response.reasoning_summary_part.done":
+            break;
+          // Internal reasoning (encrypted CoT) — not used.
+          case "response.reasoning_text.delta":
+          case "response.reasoning_text.done":
+            break;
+          default:
+            console.error(
+              `[blokkli:agent] Unhandled OpenAI stream event type: ${event.type}`
+            );
+            break;
+        }
+      }
+      if (inTextBlock) {
+        yield { type: "text_end" };
+      }
+      if (currentToolCallId) {
+        yield { type: "tool_use_end" };
+      }
+    } catch (error) {
+      yield { type: "error", error };
+    }
+  }
+}
+function buildMessageEnd(stopReason, usage) {
+  const cachedTokens = usage?.input_tokens_details?.cached_tokens ?? 0;
+  return {
+    type: "message_end",
+    stop_reason: stopReason,
+    inputTokens: usage ? usage.input_tokens - cachedTokens : void 0,
+    outputTokens: usage?.output_tokens,
+    cacheReadInputTokens: cachedTokens || void 0
+  };
+}
+export function createOpenAIProvider() {
+  return new OpenAIProvider();
+}

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

@@ -0,0 +1,81 @@
+import type { ClientToolDefinition, GenericMessage } from '../../shared/types.js';
+import type { SystemPromptBlock } from '../system-prompts/types.js';
+export type { GenericTextBlock, GenericToolUseBlock, GenericToolResultBlock, GenericReasoningBlock, GenericContentBlock, GenericMessage, } from '../../shared/types.js';
+/**
+ * Normalized stream events that all providers emit.
+ * The agent handler processes these uniformly regardless of provider.
+ */
+export type StreamEvent = {
+    type: 'text_start';
+} | {
+    type: 'text_delta';
+    text: string;
+} | {
+    type: 'text_end';
+} | {
+    type: 'tool_use_start';
+    id: string;
+    name: string;
+} | {
+    type: 'tool_use_delta';
+    partial_json: string;
+} | {
+    type: 'tool_use_end';
+} | {
+    type: 'reasoning_summary';
+    id: string;
+    text: string;
+    encryptedContent?: string;
+} | {
+    type: 'message_end';
+    stop_reason: 'end_turn' | 'tool_use' | 'max_tokens' | 'stop';
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheCreationInputTokens?: number;
+    cacheReadInputTokens?: number;
+} | {
+    type: 'error';
+    error: Error;
+} | {
+    type: 'debug_request';
+    payload: unknown;
+};
+/**
+ * Configuration passed to provider when creating a stream.
+ */
+export type ProviderConfig = {
+    /** API key for the provider */
+    apiKey: string;
+    /** Model to use (provider-specific) */
+    model: string;
+};
+/**
+ * Options for creating a stream.
+ */
+export type StreamOptions = {
+    /** System prompt blocks with optional cache hints */
+    systemPrompt: SystemPromptBlock[];
+    /** Conversation messages */
+    messages: GenericMessage[];
+    /** Available tools */
+    tools: ClientToolDefinition[];
+    /** Maximum tokens to generate */
+    maxTokens?: number;
+    /** Abort signal for cancellation */
+    signal?: AbortSignal;
+    /** Force tool use. 'any' = model must call a tool. */
+    toolChoice?: 'auto' | 'any';
+};
+/**
+ * Interface that all AI providers must implement.
+ */
+export interface AIProvider {
+    /** Provider name for identification */
+    readonly name: string;
+    /**
+     * Create a stream of events for the given messages.
+     * The provider converts generic messages to its native format,
+     * calls the API, and yields normalized StreamEvents.
+     */
+    createStream(config: ProviderConfig, options: StreamOptions): AsyncIterable<StreamEvent>;
+}

package/dist/modules/agent/runtime/server/route.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/modules/agent/runtime/server/route.js

@@ -0,0 +1,40 @@
+import { defineEventHandler, readBody, useRuntimeConfig } from "#imports";
+import { toolDefinitions } from "#blokkli-build/agent-server";
+import { resolveSkills } from "./helpers.js";
+import { preprocessPrompt } from "./routing.js";
+const config = useRuntimeConfig();
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+  const empty = {
+    skills: [],
+    tools: [],
+    usage: null
+  };
+  const apiKey = config.blokkli?.agent?.apiKey;
+  if (!apiKey) {
+    return empty;
+  }
+  const toolDefMap = new Map(toolDefinitions.map((t) => [t.name, t]));
+  const lazyToolSummaries = [];
+  for (const name of body.toolNames) {
+    const def = toolDefMap.get(name);
+    if (def?.lazy) {
+      lazyToolSummaries.push({ name: def.name, description: def.description });
+    }
+  }
+  const resolvedSkills = resolveSkills(body.pageContext);
+  const result = await preprocessPrompt(
+    apiKey,
+    body.prompt,
+    resolvedSkills,
+    lazyToolSummaries
+  );
+  if (!result) {
+    return empty;
+  }
+  return {
+    skills: result.skills,
+    tools: result.tools,
+    usage: result.usage ?? null
+  };
+});

package/dist/modules/agent/runtime/server/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/routing.js

@@ -0,0 +1,111 @@
+import { provider, models } from "#blokkli-build/agent-server";
+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") {
+        if (event.inputTokens !== void 0 && event.outputTokens !== void 0) {
+          usage = {
+            inputTokens: event.inputTokens,
+            outputTokens: event.outputTokens,
+            cacheCreationInputTokens: event.cacheCreationInputTokens ?? 0,
+            cacheReadInputTokens: event.cacheReadInputTokens ?? 0,
+            pricing: routingModelDef.pricing ?? null
+          };
+        }
+      } 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/server-tools/complete_plan_step/index.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+declare const _default: import("..").ServerSideTool<z.ZodObject<{}, z.core.$strip>>;
+export default _default;

package/dist/modules/agent/runtime/server/server-tools/complete_plan_step/index.js

@@ -0,0 +1,94 @@
+import { z } from "zod";
+import { defineServerSideTool } from "../index.js";
+const schema = z.object({});
+export default defineServerSideTool({
+  name: "complete_plan_step",
+  description: "Mark the current plan step as completed and get the next step. Call this when you have finished all work for the current step.",
+  inputSchema() {
+    return schema;
+  },
+  isAvailable(ctx) {
+    return !!ctx.plan && ctx.plan.steps.some(
+      (s) => s.status === "in_progress" || s.status === "pending"
+    );
+  },
+  handle(ctx) {
+    const currentStep = ctx.plan?.steps.find((s) => s.status === "in_progress");
+    if (!ctx.plan || !currentStep) {
+      return {
+        toolResults: [
+          {
+            type: "tool_result",
+            tool_use_id: ctx.toolUseId,
+            content: JSON.stringify({ error: "No active plan step" }),
+            is_error: true
+          }
+        ]
+      };
+    }
+    if (!ctx.planStepHasWork) {
+      return {
+        toolResults: [
+          {
+            type: "tool_result",
+            tool_use_id: ctx.toolUseId,
+            content: JSON.stringify({
+              error: "You have not performed any work for this step yet. Use the appropriate tools to complete the step before marking it as done."
+            }),
+            is_error: true
+          }
+        ]
+      };
+    }
+    currentStep.status = "completed";
+    const nextStep = ctx.plan.steps.find((s) => s.status === "pending");
+    if (nextStep) {
+      nextStep.status = "in_progress";
+    }
+    ctx.resetPlanStepWork();
+    ctx.send({
+      type: "server_tool_result",
+      tool: "complete_plan_step",
+      label: currentStep.label
+    });
+    ctx.send({
+      type: "plan_update",
+      plan: ctx.toClientPlan()
+    });
+    if (nextStep) {
+      return {
+        toolResults: [
+          {
+            type: "tool_result",
+            tool_use_id: ctx.toolUseId,
+            content: JSON.stringify({
+              completed: currentStep.label,
+              next_step: {
+                label: nextStep.label,
+                description: nextStep.description
+              }
+            })
+          }
+        ]
+      };
+    }
+    ctx.setPlan(null);
+    ctx.send({
+      type: "plan_update",
+      plan: null
+    });
+    return {
+      toolResults: [
+        {
+          type: "tool_result",
+          tool_use_id: ctx.toolUseId,
+          content: JSON.stringify({
+            completed: currentStep.label,
+            all_steps_completed: true,
+            message: "All plan steps are completed. Summarize what was done."
+          })
+        }
+      ]
+    };
+  }
+});

package/dist/modules/agent/runtime/server/server-tools/create_plan/index.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+declare const _default: import("..").ServerSideTool<z.ZodObject<{
+    title: z.ZodString;
+    steps: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+export default _default;