@revenexx/editor 0.1.0

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

@@ -0,0 +1,325 @@
+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,
+    // OpenAI's `input_tokens` includes cached tokens, so subtract them to emit
+    // the non-cached input count. (Anthropic's `input_tokens` already excludes
+    // cached tokens, so that provider emits it raw — both ultimately report the
+    // same non-cached `inputTokens` semantics.)
+    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/skills.js";
+import { preprocessPrompt } from "./helpers/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/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;

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

@@ -0,0 +1,86 @@
+import { z } from "zod";
+import { defineServerSideTool } from "../index.js";
+const schema = z.object({
+  title: z.string().describe("Short title for the plan"),
+  steps: z.array(
+    z.object({
+      label: z.string().describe('Short label shown to the user (e.g. "Add hero section")'),
+      description: z.string().describe(
+        "Detailed instructions for yourself on what to do in this step"
+      )
+    })
+  ).min(2).describe("The steps of the plan")
+});
+export default defineServerSideTool({
+  name: "create_plan",
+  description: "Create a step-by-step plan for a complex task. The user will review and approve the plan before you proceed. Each step needs a short label (shown to the user) and a detailed description (your notes on what to do). Do NOT create plans for simple tasks.",
+  inputSchema() {
+    return schema;
+  },
+  isAvailable(ctx) {
+    return !ctx.plan;
+  },
+  async handle(ctx, input) {
+    const title = input.title || "Plan";
+    const steps = input.steps.map((s) => ({
+      label: s.label,
+      description: s.description,
+      status: "pending"
+    }));
+    ctx.setPlan({ title, steps });
+    ctx.send({
+      type: "plan_update",
+      plan: ctx.toClientPlan()
+    });
+    ctx.send({
+      type: "server_tool_result",
+      tool: "create_plan",
+      label: title
+    });
+    ctx.commitMessagesEarly({
+      type: "tool_result",
+      tool_use_id: ctx.toolUseId,
+      content: JSON.stringify({
+        status: "awaiting_approval",
+        title,
+        steps: steps.map((s) => s.label)
+      })
+    });
+    const approved = await ctx.waitForPlanApproval();
+    if (approved) {
+      steps[0].status = "in_progress";
+      ctx.send({
+        type: "plan_update",
+        plan: ctx.toClientPlan()
+      });
+      ctx.updateLastToolResult(
+        ctx.toolUseId,
+        JSON.stringify({
+          approved: true,
+          message: "Plan approved. Start executing now.",
+          current_step: {
+            label: steps[0].label,
+            description: steps[0].description
+          }
+        })
+      );
+    } else {
+      ctx.updateLastToolResult(
+        ctx.toolUseId,
+        JSON.stringify({
+          approved: false,
+          message: "The user rejected the plan. Ask what they would like to change."
+        })
+      );
+      ctx.setPlan(null);
+      ctx.send({
+        type: "plan_update",
+        plan: null
+      });
+    }
+    return {
+      toolResults: [],
+      messagesCommitted: true
+    };
+  }
+});