@blokkli/editor 2.0.0-alpha.32 → 2.0.0-alpha.34

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

@@ -0,0 +1,352 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+import { skills } from "#blokkli-build/agent-server";
+export function send(peer, message) {
+  peer.send(JSON.stringify(message));
+}
+export const KEEP_RECENT_TURNS = 8;
+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
+    };
+  }).filter((s) => s !== null);
+}
+export function transformText(text) {
+  return text.replace(/ß/g, "ss");
+}
+export function classifyError(error) {
+  if (!(error instanceof Error)) {
+    return {
+      errorType: "unknown",
+      message: "An unexpected error occurred."
+    };
+  }
+  const detail = error.message || void 0;
+  const status = error.status;
+  if (status === void 0) {
+    if (error.constructor.name === "APIConnectionError") {
+      return {
+        errorType: "connection",
+        message: "Could not connect to the AI service.",
+        detail
+      };
+    }
+    return {
+      errorType: "unknown",
+      message: error.message || "An unexpected error occurred.",
+      detail
+    };
+  }
+  switch (status) {
+    case 401:
+      return {
+        errorType: "authentication",
+        message: "API authentication failed. Please check your API key.",
+        detail
+      };
+    case 400:
+      return {
+        errorType: "bad_request",
+        message: "The request to the AI service was invalid.",
+        detail
+      };
+    case 404:
+      return {
+        errorType: "not_found",
+        message: "The configured AI model was not found. Please check the configuration.",
+        detail
+      };
+    case 429:
+      return {
+        errorType: "rate_limit",
+        message: "Rate limit exceeded. Please wait a moment before trying again.",
+        detail
+      };
+    case 529:
+    case 503:
+      return {
+        errorType: "overloaded",
+        message: "The AI service is currently overloaded. Please try again in a moment.",
+        detail
+      };
+    default:
+      return {
+        errorType: "unknown",
+        message: `API error (${status}).`,
+        detail
+      };
+  }
+}
+export function findToolNameForResult(messages, userMsgIndex, toolUseId) {
+  for (let i = userMsgIndex - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
+    for (const block of msg.content) {
+      if (block.type === "tool_use" && block.id === toolUseId) {
+        return block.name;
+      }
+    }
+    break;
+  }
+  return void 0;
+}
+export function compressToolResult(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed._summary) {
+      return JSON.stringify({ summary: parsed._summary });
+    }
+    if (parsed.label) {
+      return JSON.stringify({ summary: parsed.label });
+    }
+    if (parsed.error) {
+      return JSON.stringify({ error: parsed.error });
+    }
+    if (parsed.success !== void 0) {
+      return JSON.stringify({ success: parsed.success });
+    }
+    if (parsed.selected !== void 0) {
+      return JSON.stringify({ selected: parsed.selected });
+    }
+    return JSON.stringify({ summary: "completed" });
+  } catch {
+    return content.length > 100 ? content.slice(0, 100) + "..." : content;
+  }
+}
+function compressVolatileToolResult(content) {
+  try {
+    const parsed = JSON.parse(content);
+    const summary = parsed._summary || "page state has changed since this query";
+    return JSON.stringify({ stale: true, summary });
+  } catch {
+    return JSON.stringify({
+      stale: true,
+      summary: "page state has changed since this query"
+    });
+  }
+}
+function hasMutationBetween(messages, afterIndex, beforeIndex, toolMetadata) {
+  for (let i = afterIndex + 1; i < beforeIndex; i++) {
+    const msg = messages[i];
+    if (msg.role !== "user" || !Array.isArray(msg.content)) continue;
+    for (const block of msg.content) {
+      if (block.type !== "tool_result") continue;
+      const toolName = findToolNameForResult(messages, i, block.tool_use_id);
+      if (!toolName) continue;
+      const meta = toolMetadata.get(toolName);
+      if (meta?.volatile) continue;
+      try {
+        const parsed = JSON.parse(block.content);
+        if (parsed.success !== void 0) return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+export function pruneMessages(messages, keepRecentTurns, toolMetadata) {
+  if (messages.length === 0) {
+    return;
+  }
+  const metadata = toolMetadata || /* @__PURE__ */ new Map();
+  let turnCount = 0;
+  const turnStartIndices = [];
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role === "user") {
+      const content = msg.content;
+      const containsToolResult = Array.isArray(content) && content.length > 0 && content.some(
+        (block) => typeof block === "object" && block !== null && "type" in block && block.type === "tool_result"
+      );
+      if (!containsToolResult) {
+        turnCount++;
+        turnStartIndices.push(i);
+      }
+    }
+  }
+  if (turnCount <= keepRecentTurns) {
+    return;
+  }
+  const cutoffTurnIndex = turnCount - keepRecentTurns;
+  const cutoffMessageIndex = turnStartIndices[cutoffTurnIndex] ?? messages.length;
+  for (let i = 0; i < cutoffMessageIndex; i++) {
+    const msg = messages[i];
+    const content = msg.content;
+    if (!Array.isArray(content)) {
+      continue;
+    }
+    if (msg.role === "assistant") {
+      for (const block of content) {
+        if (block.type === "tool_use") {
+          block.input = { _pruned: true };
+        }
+      }
+      continue;
+    }
+    for (let j = content.length - 1; j >= 0; j--) {
+      const block = content[j];
+      if (block.type === "tool_result") {
+        const toolName = findToolNameForResult(messages, i, block.tool_use_id);
+        const meta = toolName ? metadata.get(toolName) : void 0;
+        if (meta?.volatile && hasMutationBetween(messages, i, messages.length, metadata)) {
+          block.content = compressVolatileToolResult(block.content);
+        } else {
+          block.content = compressToolResult(block.content);
+        }
+      } else if (block.type === "text" || block.type === "skill") {
+        content.splice(j, 1);
+      }
+    }
+  }
+}
+const PERSISTENCE_KEEP_TURNS = 7;
+export function pruneForPersistence(messages, keepTurns = PERSISTENCE_KEEP_TURNS) {
+  if (messages.length === 0) return [];
+  const cloned = JSON.parse(JSON.stringify(messages));
+  let turnCount = 0;
+  const turnStartIndices = [];
+  for (let i = 0; i < cloned.length; i++) {
+    const msg = cloned[i];
+    if (msg.role === "user") {
+      const content = msg.content;
+      const containsToolResult = Array.isArray(content) && content.length > 0 && content.some(
+        (block) => typeof block === "object" && block !== null && "type" in block && block.type === "tool_result"
+      );
+      if (!containsToolResult) {
+        turnCount++;
+        turnStartIndices.push(i);
+      }
+    }
+  }
+  let startIndex = 0;
+  if (turnCount > keepTurns) {
+    const cutoffTurnIndex = turnCount - keepTurns;
+    startIndex = turnStartIndices[cutoffTurnIndex] ?? 0;
+  }
+  const trimmed = cloned.slice(startIndex);
+  let lastTurnStart = 0;
+  for (let i = trimmed.length - 1; i >= 0; i--) {
+    const msg = trimmed[i];
+    if (msg.role === "user") {
+      const content = msg.content;
+      const containsToolResult = Array.isArray(content) && content.length > 0 && content.some(
+        (block) => typeof block === "object" && block !== null && "type" in block && block.type === "tool_result"
+      );
+      if (!containsToolResult) {
+        lastTurnStart = i;
+        break;
+      }
+    }
+  }
+  for (let i = 0; i < trimmed.length; i++) {
+    const msg = trimmed[i];
+    const content = msg.content;
+    if (!Array.isArray(content)) continue;
+    if (msg.role === "assistant") {
+      if (i < lastTurnStart) {
+        for (const block of content) {
+          if (block.type === "tool_use") {
+            block.input = { _pruned: true };
+          }
+        }
+      }
+      continue;
+    }
+    for (let j = content.length - 1; j >= 0; j--) {
+      const block = content[j];
+      if (block.type === "tool_result") {
+        block.content = compressToolResult(block.content);
+      } else if (block.type === "text" && i < lastTurnStart) {
+        content.splice(j, 1);
+      }
+    }
+  }
+  return trimmed;
+}
+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) {
+  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;
+  }
+}
+export function validateMessages(messages) {
+  const issues = [];
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (i > 0 && messages[i - 1].role === msg.role) {
+      issues.push(
+        `Consecutive ${msg.role} messages at indices ${i - 1} and ${i}`
+      );
+    }
+    if (Array.isArray(msg.content) && msg.content.length === 0) {
+      issues.push(`Empty content array in ${msg.role} message at index ${i}`);
+    }
+    if (msg.role === "user" && Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === "tool_result") {
+          const toolName = findToolNameForResult(messages, i, block.tool_use_id);
+          if (!toolName) {
+            issues.push(
+              `Orphaned tool_result for ${block.tool_use_id} at message index ${i}`
+            );
+          }
+        }
+      }
+    }
+    if (msg.role === "assistant" && Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === "tool_use") {
+          const nextMsg = messages[i + 1];
+          if (!nextMsg || nextMsg.role !== "user") {
+            issues.push(
+              `tool_use "${block.name}" (${block.id}) at message index ${i} has no following user message`
+            );
+            continue;
+          }
+          if (!Array.isArray(nextMsg.content)) {
+            issues.push(
+              `tool_use "${block.name}" (${block.id}) at message index ${i} has no matching tool_result`
+            );
+            continue;
+          }
+          const hasResult = nextMsg.content.some(
+            (b) => b.type === "tool_result" && b.tool_use_id === block.id
+          );
+          if (!hasResult) {
+            issues.push(
+              `tool_use "${block.name}" (${block.id}) at message index ${i} has no matching tool_result`
+            );
+          }
+        }
+      }
+    }
+  }
+  return issues;
+}

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,128 @@
+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.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);
+    yield { type: "debug_request", tools };
+    const stream = client.messages.stream({
+      model: config.model,
+      max_tokens: options.maxTokens ?? 4096,
+      system: convertSystemPrompt(options.systemPrompt),
+      messages,
+      tools
+    });
+    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") {
+              yield { type: "text_start" };
+            } else if (event.content_block.type === "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":
+            yield { type: "text_end" };
+            yield { type: "tool_use_end" };
+            break;
+          case "message_stop": {
+            const finalMessage = await stream.finalMessage();
+            yield {
+              type: "message_end",
+              stop_reason: finalMessage.stop_reason,
+              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
+            };
+            break;
+          }
+        }
+      }
+    } 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;

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

@@ -0,0 +1,165 @@
+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 === "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);
+    yield { type: "debug_request", tools };
+    const instructions = options.systemPrompt.map((b) => b.text).join("\n\n");
+    try {
+      const stream = await client.responses.create(
+        {
+          model: config.model,
+          instructions,
+          input,
+          tools: tools.length > 0 ? tools : void 0,
+          max_output_tokens: options.maxTokens ?? 4096,
+          stream: true,
+          store: false
+        },
+        { signal: options.signal }
+      );
+      let hasFunctionCalls = false;
+      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") {
+              yield { type: "text_start" };
+            }
+            break;
+          case "response.output_text.delta":
+            yield { type: "text_delta", text: event.delta };
+            break;
+          case "response.output_text.done":
+            yield { type: "text_end" };
+            break;
+          // Tool call streaming
+          case "response.output_item.added":
+            if (event.item.type === "function_call") {
+              hasFunctionCalls = true;
+              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":
+            yield { type: "tool_use_end" };
+            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;
+          }
+          case "response.failed":
+            yield {
+              type: "error",
+              error: new Error("OpenAI response failed")
+            };
+            break;
+        }
+      }
+    } 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();
+}