@blokkli/editor 2.0.0-alpha.58 → 2.0.0-alpha.59

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

@@ -76,7 +76,11 @@ export class AnthropicProvider {
     if (import.meta.dev) {
       yield { type: "debug_request", payload: requestParams };
     }
-    const stream = client.messages.stream(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) {
@@ -85,8 +89,10 @@ export class AnthropicProvider {
         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,
@@ -105,23 +111,36 @@ export class AnthropicProvider {
             }
             break;
           case "content_block_stop":
-            yield { type: "text_end" };
-            yield { type: "tool_use_end" };
+            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 };
     }

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

@@ -311,6 +311,10 @@ function buildMessageEnd(stopReason, usage) {
   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

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

@@ -1,7 +1,7 @@
 import { defineEventHandler, readBody, useRuntimeConfig } from "#imports";
 import { toolDefinitions } from "#blokkli-build/agent-server";
-import { resolveSkills } from "./helpers.js";
-import { preprocessPrompt } from "./routing.js";
+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);

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

@@ -27,6 +27,8 @@ export type ToolDefinitionContext = {
         name: string;
         description: string;
     }[];
+    /** All lazy tool names, including ones already activated. */
+    lazyToolNames: string[];
 };
 /**
  * Context passed to `handle()` — provides access to session state

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

@@ -5,11 +5,7 @@ export default defineServerSideTool({
   description: 'Load additional tools by name before using them. You must call this before using any tool listed under "Additional Tools" in the system prompt.',
   inputSchema(ctx) {
     return z.object({
-      tools: z.array(
-        z.enum(
-          ctx.unloadedLazyTools.map((t) => t.name)
-        )
-      ).describe("Tool names to activate")
+      tools: z.array(z.enum(ctx.lazyToolNames)).describe("Tool names to activate")
     });
   },
   isAvailable(ctx) {

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

@@ -4,30 +4,16 @@ import {
   readBody,
   useRuntimeConfig
 } from "#imports";
-import { createHmac, timingSafeEqual } from "node:crypto";
 import { provider, models, skills } from "#blokkli-build/agent-server";
-import { FieldStreamParser } from "./streamParser.js";
+import {
+  FieldStreamParser
+} from "./classes/FieldStreamParser/index.js";
 import { resolveTemplate } from "./templates/index.js";
-const TOKEN_EXPIRY_SECONDS = 300;
+import { validateToken } from "./helpers/security.js";
+import { getDefaultModel, createUsageTurn } from "./helpers/models.js";
 const config = useRuntimeConfig();
 const authSecret = config.blokkli?.agent?.authSecret || "";
 const apiKey = config.blokkli?.agent?.apiKey || "";
-function validateToken(token, authSecret2) {
-  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", authSecret2).update(timestampStr).digest("hex");
-  if (providedHmac.length !== expectedHmac.length) return false;
-  return timingSafeEqual(
-    Buffer.from(providedHmac, "hex"),
-    Buffer.from(expectedHmac, "hex")
-  );
-}
 function writeSSE(res, event, data) {
   res.write(`event: ${event}
 data: ${JSON.stringify(data)}
@@ -159,16 +145,7 @@ export default defineEventHandler(async (event) => {
         emitParserEvents(parser.feed(streamEvent.text));
       }
       if (streamEvent.type === "message_end") {
-        if (streamEvent.inputTokens !== void 0 && streamEvent.outputTokens !== void 0) {
-          const defaultModel = models.find((m) => m.isDefault) || models[0];
-          usage = {
-            inputTokens: streamEvent.inputTokens,
-            outputTokens: streamEvent.outputTokens,
-            cacheCreationInputTokens: streamEvent.cacheCreationInputTokens ?? 0,
-            cacheReadInputTokens: streamEvent.cacheReadInputTokens ?? 0,
-            pricing: defaultModel?.pricing ?? null
-          };
-        }
+        usage = createUsageTurn(streamEvent, getDefaultModel(models)) ?? usage;
       }
       if (streamEvent.type === "error") {
         writeSSE(res, "error", {

package/dist/modules/agent/runtime/shared/toolParams.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+/**
+ * A boolean parameter that also accepts the strings `"true"` / `"false"` (any
+ * case), coercing them to real booleans. LLMs frequently send a stringified
+ * boolean (e.g. `requireApproval: "false"`) and would otherwise fail validation
+ * on the first call. The generated JSON Schema still advertises a boolean, so
+ * the model is guided toward the real type while the string form is accepted as
+ * a fallback. Mirrors `stringArrayParam` / `z.coerce.number()` used elsewhere.
+ *
+ * Type-aware on purpose: it only fires where a boolean is expected, so a string
+ * param that happens to equal `"false"` is never clobbered. Genuinely invalid
+ * values (e.g. `"maybe"`) still fail validation rather than being swallowed.
+ *
+ * Lives in `shared/` so both client tools and server-only tools build the same
+ * coercion into their respective bundles from one source.
+ */
+export declare function booleanParam(description: string): z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>;
+/**
+ * Coerce double-serialized array/object params back to their real values.
+ *
+ * LLMs sometimes send e.g. `"[\"x\"]"` (a string) instead of `["x"]` (an array).
+ * This walks the params and attempts `JSON.parse` on any string that looks like
+ * a JSON array or object.
+ *
+ * Pure utility shared by the client (tool execution) and the server (tool
+ * validation/dispatch), so both sides coerce identically.
+ */
+export declare function coerceStringifiedParams(params: Record<string, unknown>): Record<string, unknown>;

package/dist/modules/agent/runtime/shared/toolParams.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+export function booleanParam(description) {
+  return z.preprocess((value) => {
+    if (typeof value === "string") {
+      const lower = value.trim().toLowerCase();
+      if (lower === "true") return true;
+      if (lower === "false") return false;
+    }
+    return value;
+  }, z.boolean().describe(description));
+}
+export function coerceStringifiedParams(params) {
+  const result = {};
+  for (const key of Object.keys(params)) {
+    const value = params[key];
+    if (typeof value === "string" && (value[0] === "[" || value[0] === "{")) {
+      try {
+        result[key] = JSON.parse(value);
+      } catch {
+        result[key] = value;
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}

package/dist/modules/agent/runtime/shared/toolResult.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Typed value object for a single tool result.
+ *
+ * A tool result crosses the wire as an opaque JSON **string** (both LLM provider
+ * APIs require `tool_result.content` to be a string). Historically the pruning
+ * code re-`JSON.parse`d that string and inspected untyped fields
+ * (`parsed._summary`, `.label`, `.success`, ...) to decide how to compress it.
+ * `ToolResult` does that classification ONCE, into a typed {@link ToolResultEnvelope},
+ * and exposes pure, deterministic transforms used by the conversation projection.
+ *
+ * It keeps the original wire string verbatim (`raw`) so an un-compressed result
+ * re-serialises byte-identically (important for Anthropic prompt-cache prefix
+ * matching); compressed/stale forms are tiny fixed-shape objects.
+ *
+ * Pure utility shared by the client-facing protocol and the server projection,
+ * mirroring the `shared/toolParams.ts` precedent. No client-tool Zod schemas are
+ * imported here — classification is field-driven, matching the fact that results
+ * are never validated against their schema server-side.
+ */
+/**
+ * Typed classification of a tool result, derived once from its wire content.
+ * The `summaryText` carried on several variants is the explicit summary the
+ * client/tool provided (`_summary ?? label ?? summary`), which takes precedence
+ * when compressing — preserving the historical compression precedence.
+ */
+export type ToolResultEnvelope = {
+    kind: 'opaque';
+    text: string;
+} | {
+    kind: 'stale';
+    summary: string;
+} | {
+    kind: 'error';
+    message: string;
+    summaryText?: string;
+} | {
+    kind: 'mutationSuccess';
+    summaryText?: string;
+} | {
+    kind: 'mutationRejected';
+    summaryText?: string;
+} | {
+    kind: 'selection';
+    selected: unknown;
+    summaryText?: string;
+} | {
+    kind: 'summary';
+    summary: string;
+};
+export declare class ToolResult {
+    /** The original (or compressed) wire string, emitted verbatim by `toWire`. */
+    private readonly raw;
+    private readonly envelope;
+    private readonly isError;
+    /** Summary used when this result is evicted as stale (`_summary ?? summary`). */
+    private readonly staleSummary;
+    private constructor();
+    /**
+     * Classify a wire string (the form stored in a `tool_result` block) once.
+     * Mirrors the historical `compressToolResult` precedence.
+     */
+    static fromWire(content: string, isError?: boolean): ToolResult;
+    /**
+     * Build from a live client result object (server tool-dispatch path).
+     * Applies the `agentMessage → label` rewrite and serialises with the same
+     * bytes the previous code produced, then classifies.
+     */
+    static fromClientResult(result: unknown, opts?: {
+        isError?: boolean;
+    }): ToolResult;
+    /** An explicit error result (malformed input, loop guard, validation, ...). */
+    static error(message: string): ToolResult;
+    /** The wire string for this result — verbatim original, or the compressed form. */
+    toWire(): string;
+    isErrorResult(): boolean;
+    /** True for an applied mutation (`{ success: true }`), independent of summary. */
+    isMutationSuccess(): boolean;
+    /** Best human-readable summary of this result. */
+    summary(): string;
+    /** Estimated token cost of the full wire content (~4 chars per token). */
+    estimatedTokens(): number;
+    /**
+     * Compressed form: collapse to the minimal payload. Pure (returns a new
+     * `ToolResult`) and idempotent. Replicates the historical `compressToolResult`
+     * precedence: an explicit `summaryText` wins; otherwise the kind-specific
+     * minimal shape (`{error}` / `{success}` / `{selected}`) is kept.
+     */
+    compressed(): ToolResult;
+    /**
+     * Stale form: a volatile query whose data is outdated because a mutation
+     * happened after it. Pure and idempotent.
+     */
+    stale(): ToolResult;
+}

package/dist/modules/agent/runtime/shared/toolResult.js

@@ -0,0 +1,155 @@
+const STALE_FALLBACK = "page state has changed since this query";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asText(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+export class ToolResult {
+  constructor(raw, envelope, isError, staleSummary) {
+    this.raw = raw;
+    this.envelope = envelope;
+    this.isError = isError;
+    this.staleSummary = staleSummary;
+  }
+  /**
+   * Classify a wire string (the form stored in a `tool_result` block) once.
+   * Mirrors the historical `compressToolResult` precedence.
+   */
+  static fromWire(content, isError) {
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch {
+      return new ToolResult(
+        content,
+        { kind: "opaque", text: content },
+        !!isError,
+        STALE_FALLBACK
+      );
+    }
+    if (!isRecord(parsed)) {
+      return new ToolResult(
+        content,
+        { kind: "opaque", text: content },
+        !!isError,
+        STALE_FALLBACK
+      );
+    }
+    const staleSummary = asText(parsed._summary) ?? asText(parsed.summary) ?? STALE_FALLBACK;
+    const summaryText = asText(parsed._summary) ?? asText(parsed.label) ?? (typeof parsed.summary === "string" ? parsed.summary : void 0);
+    let envelope;
+    let errorFlag = !!isError;
+    if (parsed.stale === true) {
+      envelope = {
+        kind: "stale",
+        summary: asText(parsed.summary) ?? staleSummary
+      };
+    } else if (asText(parsed.error)) {
+      envelope = { kind: "error", message: parsed.error, summaryText };
+      errorFlag = true;
+    } else if (parsed.success === true) {
+      envelope = { kind: "mutationSuccess", summaryText };
+    } else if (parsed.success === false) {
+      envelope = { kind: "mutationRejected", summaryText };
+    } else if (parsed.selected !== void 0) {
+      envelope = { kind: "selection", selected: parsed.selected, summaryText };
+    } else if (summaryText !== void 0) {
+      envelope = { kind: "summary", summary: summaryText };
+    } else {
+      envelope = { kind: "summary", summary: "completed" };
+    }
+    return new ToolResult(content, envelope, errorFlag, staleSummary);
+  }
+  /**
+   * Build from a live client result object (server tool-dispatch path).
+   * Applies the `agentMessage → label` rewrite and serialises with the same
+   * bytes the previous code produced, then classifies.
+   */
+  static fromClientResult(result, opts) {
+    let value = result;
+    if (isRecord(value) && "agentMessage" in value) {
+      const { agentMessage, ...rest } = value;
+      value = { ...rest, label: agentMessage };
+    }
+    const content = JSON.stringify(value) ?? "null";
+    return ToolResult.fromWire(content, opts?.isError);
+  }
+  /** An explicit error result (malformed input, loop guard, validation, ...). */
+  static error(message) {
+    return ToolResult.fromWire(JSON.stringify({ error: message }), true);
+  }
+  /** The wire string for this result — verbatim original, or the compressed form. */
+  toWire() {
+    return this.raw;
+  }
+  isErrorResult() {
+    return this.isError;
+  }
+  /** True for an applied mutation (`{ success: true }`), independent of summary. */
+  isMutationSuccess() {
+    return this.envelope.kind === "mutationSuccess";
+  }
+  /** Best human-readable summary of this result. */
+  summary() {
+    const env = this.envelope;
+    switch (env.kind) {
+      case "opaque":
+        return env.text;
+      case "stale":
+      case "summary":
+        return env.summary;
+      case "error":
+        return env.summaryText ?? env.message;
+      default:
+        return env.summaryText ?? "completed";
+    }
+  }
+  /** Estimated token cost of the full wire content (~4 chars per token). */
+  estimatedTokens() {
+    return this.raw.length / 4;
+  }
+  /**
+   * Compressed form: collapse to the minimal payload. Pure (returns a new
+   * `ToolResult`) and idempotent. Replicates the historical `compressToolResult`
+   * precedence: an explicit `summaryText` wins; otherwise the kind-specific
+   * minimal shape (`{error}` / `{success}` / `{selected}`) is kept.
+   */
+  compressed() {
+    const env = this.envelope;
+    switch (env.kind) {
+      case "opaque": {
+        const text = env.text.length > 100 ? env.text.slice(0, 100) + "..." : env.text;
+        return new ToolResult(
+          text,
+          { kind: "opaque", text },
+          this.isError,
+          this.staleSummary
+        );
+      }
+      case "stale":
+        return this;
+      // already minimal + sticky
+      case "summary":
+        return ToolResult.fromWire(JSON.stringify({ summary: env.summary }));
+      case "error":
+        return env.summaryText !== void 0 ? ToolResult.fromWire(JSON.stringify({ summary: env.summaryText })) : ToolResult.fromWire(JSON.stringify({ error: env.message }), true);
+      case "mutationSuccess":
+        return env.summaryText !== void 0 ? ToolResult.fromWire(JSON.stringify({ summary: env.summaryText })) : ToolResult.fromWire(JSON.stringify({ success: true }));
+      case "mutationRejected":
+        return env.summaryText !== void 0 ? ToolResult.fromWire(JSON.stringify({ summary: env.summaryText })) : ToolResult.fromWire(JSON.stringify({ success: false }));
+      case "selection":
+        return env.summaryText !== void 0 ? ToolResult.fromWire(JSON.stringify({ summary: env.summaryText })) : ToolResult.fromWire(JSON.stringify({ selected: env.selected }));
+    }
+  }
+  /**
+   * Stale form: a volatile query whose data is outdated because a mutation
+   * happened after it. Pure and idempotent.
+   */
+  stale() {
+    if (this.envelope.kind === "stale") return this;
+    return ToolResult.fromWire(
+      JSON.stringify({ stale: true, summary: this.staleSummary })
+    );
+  }
+}

package/dist/modules/agent/runtime/shared/types.d.ts

@@ -418,6 +418,7 @@ export declare const clientMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         toolName: z.ZodString;
         params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.core.$strip>>>;
+    rollbackToUserMessageIndex: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"tool_result">;
     callId: z.ZodString;
@@ -493,9 +494,6 @@ export type ServerMessage = {
 } | {
     type: 'thinking';
     content?: string;
-} | {
-    type: 'text';
-    content: string;
 } | {
     type: 'text_delta';
     content: string;

package/dist/modules/agent/runtime/shared/types.js

@@ -157,7 +157,14 @@ export const clientMessageSchema = z.discriminatedUnion("type", [
         toolName: z.string(),
         params: z.record(z.string(), z.unknown())
       })
-    ).optional()
+    ).optional(),
+    /**
+     * When present, the server truncates Session.messages so that the Nth
+     * real user turn and everything after it are removed before processing
+     * this prompt. Used by retry/edit to rewind the conversation.
+     * 0-based index, counts only true user turns (not tool-result relays).
+     */
+    rollbackToUserMessageIndex: z.number().int().nonnegative().optional()
   }),
   z.object({
     type: z.literal("tool_result"),

package/dist/modules/charts/index.d.mts

@@ -1,22 +1,12 @@
-import { B as BlokkliModule } from '../../shared/editor.Bpw1EP57.mjs';
+import { B as BlokkliModule } from '../../shared/editor.D28NbXr3.mjs';
 import 'nuxt/schema';
 import 'consola';
 import '../../../dist/global/types/definitions.js';
 import '../../../dist/global/types/theme.js';
+import '../../../dist/global/types/colorOptions.js';
 import '@nuxt/kit';
 import '../../../dist/global/types/features.js';
 
-type ChartColor = {
-    /**
-     * A valid CSS color value, e.g. '#ff0000', 'rgb(255, 0, 0)',
-     * or 'rgb(var(--theme-color-primary))' for CSS custom properties.
-     */
-    color: string;
-    /**
-     * The label of the color.
-     */
-    label: string;
-};
 type ChartsModuleOptions = {
     /**
      * Provide the path to a custom component to render charts.
@@ -24,12 +14,8 @@ type ChartsModuleOptions = {
      * @todo not yet implemented
      */
     chartRenderComponent?: string;
-    /**
-     * The available chart colors.
-     */
-    colors: Record<string, ChartColor>;
 };
 
-declare const _default: (options: ChartsModuleOptions) => BlokkliModule<ChartsModuleOptions>;
+declare const _default: (options?: ChartsModuleOptions | undefined) => BlokkliModule<ChartsModuleOptions>;
 
 export { _default as default };