@shwfed/config 1.0.0

package/dist/runtime/plugins/ai/index.d.ts

@@ -0,0 +1,48 @@
+import { type ComputedRef, type Ref } from 'vue';
+import { Schema } from 'effect';
+import { type AiConfig } from './store.js';
+export interface GenerateTextInput {
+    readonly prompt: string;
+    readonly system?: string;
+    readonly signal?: AbortSignal;
+    readonly maxTokens?: number;
+    readonly onProgress?: () => void;
+}
+export interface AgenticTool {
+    readonly name: string;
+    readonly description: string;
+    readonly inputJsonSchema: unknown;
+    readonly execute: (input: unknown) => unknown | Promise<unknown>;
+}
+export interface GenerateObjectInput<A, I extends Record<string, unknown>> {
+    readonly prompt: string;
+    readonly system?: string;
+    readonly schema: Schema.Schema<A, I>;
+    readonly signal?: AbortSignal;
+    readonly objectName?: string;
+    readonly maxTokens?: number;
+    readonly onProgress?: () => void;
+    readonly tools?: ReadonlyArray<AgenticTool>;
+    readonly retry?: {
+        readonly previousOutput: unknown;
+        readonly feedback: string;
+    };
+}
+export interface Ai {
+    readonly available: ComputedRef<boolean>;
+    readonly config: Ref<AiConfig | null>;
+    readonly setConfig: (next: AiConfig | null) => void;
+    readonly openSettings: () => void;
+    readonly generateText: (input: GenerateTextInput) => Promise<string>;
+    readonly generateObject: <A, I extends Record<string, unknown>>(input: GenerateObjectInput<A, I>) => Promise<A>;
+}
+export declare class StructuredOutputDecodeError extends Error {
+    readonly rawOutput: unknown;
+    constructor(rawOutput: unknown, cause: unknown);
+}
+declare const _default: import("#app").Plugin<{
+    ai: Ai;
+}> & import("#app").ObjectPlugin<{
+    ai: Ai;
+}>;
+export default _default;

package/dist/runtime/plugins/ai/index.js

@@ -0,0 +1,522 @@
+import { defineNuxtPlugin } from "#app";
+import { computed } from "vue";
+import { JSONSchema, Schema } from "effect";
+import { isByokAllowed } from "./gate.js";
+import { createConfigRef, DEFAULT_MAX_TOKENS as CONFIG_DEFAULT_MAX_TOKENS } from "./store.js";
+import { settingsOpen } from "./settings-state.js";
+const DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-4-5-20250929";
+const DEFAULT_ANTHROPIC_ENDPOINT = "https://api.anthropic.com/v1/messages";
+const DEFAULT_OPENAI_MODEL = "gpt-4o-mini";
+const DEFAULT_OPENAI_ENDPOINT = "https://api.openai.com/v1/chat/completions";
+export class StructuredOutputDecodeError extends Error {
+  rawOutput;
+  constructor(rawOutput, cause) {
+    super(cause instanceof Error ? cause.message : String(cause));
+    this.name = "StructuredOutputDecodeError";
+    this.rawOutput = rawOutput;
+    if (cause !== void 0) this.cause = cause;
+  }
+}
+async function readError(res) {
+  try {
+    const body = await res.json();
+    if (typeof body.error === "string") return body.error;
+    return body.error?.message ?? "";
+  } catch {
+    return await res.text().catch(() => "");
+  }
+}
+async function* readSSE(res) {
+  if (!res.body) return;
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  for (; ; ) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+    buf = buf.replace(/\r\n/g, "\n");
+    let idx;
+    while ((idx = buf.indexOf("\n\n")) !== -1) {
+      const block = buf.slice(0, idx);
+      buf = buf.slice(idx + 2);
+      let event;
+      const dataLines = [];
+      for (const line of block.split("\n")) {
+        if (line.startsWith("event:")) event = line.slice(6).trim();
+        else if (line.startsWith("data:")) dataLines.push(line.slice(5).replace(/^ /, ""));
+      }
+      if (dataLines.length === 0) continue;
+      yield { event, data: dataLines.join("\n") };
+    }
+  }
+}
+function buildAnthropicClient(cfg) {
+  const endpoint = cfg.endpoint ?? DEFAULT_ANTHROPIC_ENDPOINT;
+  const model = cfg.model ?? DEFAULT_ANTHROPIC_MODEL;
+  const configuredMaxTokens = cfg.maxTokens ?? CONFIG_DEFAULT_MAX_TOKENS;
+  const RETRY_TOOL_USE_ID = "retry_call_0";
+  function buildBody(messages, options) {
+    return {
+      model,
+      max_tokens: options.maxTokens ?? configuredMaxTokens,
+      messages,
+      ...options.system !== void 0 ? { system: options.system } : {},
+      ...options.tools !== void 0 ? { tools: options.tools } : {},
+      ...options.toolChoice !== void 0 ? { tool_choice: options.toolChoice } : {}
+    };
+  }
+  function buildInitialMessages(prompt, retry) {
+    const messages = [{ role: "user", content: prompt }];
+    if (retry) {
+      messages.push({
+        role: "assistant",
+        content: [{
+          type: "tool_use",
+          id: RETRY_TOOL_USE_ID,
+          name: retry.toolName,
+          input: retry.previousOutput
+        }]
+      });
+      messages.push({
+        role: "user",
+        content: [{
+          type: "tool_result",
+          tool_use_id: RETRY_TOOL_USE_ID,
+          content: retry.feedback
+        }]
+      });
+    }
+    return messages;
+  }
+  function buildInit(body, signal) {
+    return {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-api-key": cfg.apiKey,
+        "anthropic-version": "2023-06-01",
+        // CORS opt-in for browser-direct calls. The name is deliberately
+        // scary — keys live in localStorage on dev/beta only, gated by gate.ts.
+        "anthropic-dangerous-direct-browser-access": "true"
+      },
+      body: JSON.stringify(body),
+      ...signal ? { signal } : {}
+    };
+  }
+  async function call(messages, options, signal) {
+    const res = await fetch(endpoint, buildInit(buildBody(messages, options), signal));
+    if (!res.ok) {
+      throw new Error(`Anthropic ${res.status}: ${await readError(res) || res.statusText}`);
+    }
+    return await res.json();
+  }
+  async function callStream(messages, options, signal, onProgress) {
+    const body = { ...buildBody(messages, options), stream: true };
+    const res = await fetch(endpoint, buildInit(body, signal));
+    if (!res.ok) {
+      throw new Error(`Anthropic ${res.status}: ${await readError(res) || res.statusText}`);
+    }
+    const blocks = /* @__PURE__ */ new Map();
+    for await (const ev of readSSE(res)) {
+      if (ev.event === "content_block_start") {
+        const data = JSON.parse(ev.data);
+        blocks.set(data.index, {
+          type: data.content_block.type,
+          id: data.content_block.id,
+          name: data.content_block.name,
+          text: "",
+          inputJson: ""
+        });
+      } else if (ev.event === "content_block_delta") {
+        const data = JSON.parse(ev.data);
+        const block = blocks.get(data.index);
+        if (!block) continue;
+        if (data.delta.type === "text_delta" && data.delta.text) {
+          block.text += data.delta.text;
+          onProgress();
+        } else if (data.delta.type === "input_json_delta" && data.delta.partial_json) {
+          block.inputJson += data.delta.partial_json;
+          onProgress();
+        }
+      }
+    }
+    const ordered = [...blocks.entries()].sort(([a], [b]) => a - b);
+    const content = ordered.map(([, block]) => {
+      if (block.type === "text") return { type: "text", text: block.text };
+      if (block.type === "tool_use") {
+        let input = {};
+        if (block.inputJson) {
+          try {
+            input = JSON.parse(block.inputJson);
+          } catch {
+          }
+        }
+        return {
+          type: "tool_use",
+          id: block.id ?? "",
+          name: block.name ?? "",
+          input
+        };
+      }
+      return { type: block.type };
+    });
+    return { content };
+  }
+  function extractText(response) {
+    return response.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+  }
+  return {
+    async generateText(input) {
+      const opts = {
+        ...input.system !== void 0 ? { system: input.system } : {},
+        ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {}
+      };
+      const messages = [{ role: "user", content: input.prompt }];
+      const response = input.onProgress ? await callStream(messages, opts, input.signal, input.onProgress) : await call(messages, opts, input.signal);
+      return extractText(response);
+    },
+    async generateObject(input) {
+      const toolName = input.objectName ?? "structured_output";
+      const structuredSchema = JSONSchema.make(input.schema);
+      const helperTools = input.tools ?? [];
+      const helperByName = new Map(helperTools.map((t) => [t.name, t]));
+      const tools = [
+        ...helperTools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          input_schema: t.inputJsonSchema
+        })),
+        {
+          name: toolName,
+          description: "Return the structured output as the tool input.",
+          input_schema: structuredSchema
+        }
+      ];
+      const toolChoice = helperTools.length > 0 ? { type: "any" } : { type: "tool", name: toolName };
+      const optsBase = {
+        ...input.system !== void 0 ? { system: input.system } : {},
+        ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {},
+        tools,
+        toolChoice
+      };
+      const messages = buildInitialMessages(
+        input.prompt,
+        input.retry !== void 0 ? { ...input.retry, toolName } : void 0
+      );
+      const decode = (raw) => {
+        try {
+          return Schema.decodeUnknownSync(input.schema)(raw);
+        } catch (cause) {
+          throw new StructuredOutputDecodeError(raw, cause);
+        }
+      };
+      for (; ; ) {
+        const response = input.onProgress ? await callStream(messages, optsBase, input.signal, input.onProgress) : await call(messages, optsBase, input.signal);
+        const structured = response.content.find(
+          (b) => b.type === "tool_use" && b.name === toolName
+        );
+        if (structured) return decode(structured.input);
+        const helperCalls = response.content.filter(
+          (b) => b.type === "tool_use"
+        );
+        if (helperCalls.length === 0) {
+          const text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+          throw new Error(`\u6A21\u578B\u672A\u8FD4\u56DE\u7ED3\u6784\u5316\u8F93\u51FA${text ? `: ${text.slice(0, 200)}` : ""}`);
+        }
+        const toolResults = [];
+        for (const callBlock of helperCalls) {
+          const tool = helperByName.get(callBlock.name);
+          if (!tool) {
+            toolResults.push({
+              type: "tool_result",
+              tool_use_id: callBlock.id,
+              content: `Unknown tool: ${callBlock.name}`,
+              is_error: true
+            });
+            continue;
+          }
+          try {
+            const result = await tool.execute(callBlock.input);
+            toolResults.push({
+              type: "tool_result",
+              tool_use_id: callBlock.id,
+              content: typeof result === "string" ? result : JSON.stringify(result)
+            });
+          } catch (err) {
+            toolResults.push({
+              type: "tool_result",
+              tool_use_id: callBlock.id,
+              content: err instanceof Error ? err.message : String(err),
+              is_error: true
+            });
+          }
+        }
+        messages.push({ role: "assistant", content: response.content });
+        messages.push({ role: "user", content: toolResults });
+      }
+    }
+  };
+}
+function buildOpenAIClient(cfg) {
+  const endpoint = cfg.endpoint ?? DEFAULT_OPENAI_ENDPOINT;
+  const model = cfg.model ?? DEFAULT_OPENAI_MODEL;
+  const configuredMaxTokens = cfg.maxTokens ?? CONFIG_DEFAULT_MAX_TOKENS;
+  function buildBody(messages, options) {
+    return {
+      model,
+      messages,
+      max_tokens: options.maxTokens ?? configuredMaxTokens,
+      ...options.tools !== void 0 ? { tools: options.tools } : {},
+      ...options.toolChoice !== void 0 ? { tool_choice: options.toolChoice } : {}
+    };
+  }
+  function buildInit(body, signal) {
+    return {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "authorization": `Bearer ${cfg.apiKey}`
+      },
+      body: JSON.stringify(body),
+      ...signal ? { signal } : {}
+    };
+  }
+  async function call(messages, options, signal) {
+    const res = await fetch(endpoint, buildInit(buildBody(messages, options), signal));
+    if (!res.ok) {
+      throw new Error(`OpenAI ${res.status}: ${await readError(res) || res.statusText}`);
+    }
+    return await res.json();
+  }
+  async function callStream(messages, options, signal, onProgress) {
+    const body = { ...buildBody(messages, options), stream: true };
+    const res = await fetch(endpoint, buildInit(body, signal));
+    if (!res.ok) {
+      throw new Error(`OpenAI ${res.status}: ${await readError(res) || res.statusText}`);
+    }
+    let content = "";
+    const tools = /* @__PURE__ */ new Map();
+    let finishReason;
+    for await (const ev of readSSE(res)) {
+      if (ev.data === "[DONE]") break;
+      let chunk;
+      try {
+        chunk = JSON.parse(ev.data);
+      } catch {
+        continue;
+      }
+      const choice = chunk.choices?.[0];
+      if (!choice) continue;
+      if (choice.finish_reason) finishReason = choice.finish_reason;
+      const delta = choice.delta;
+      if (!delta) continue;
+      if (delta.content) {
+        content += delta.content;
+        onProgress();
+      }
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          const idx = tc.index ?? 0;
+          const cur = tools.get(idx) ?? { arguments: "" };
+          if (tc.id) cur.id = tc.id;
+          if (tc.function?.name) cur.name = tc.function.name;
+          if (tc.function?.arguments) {
+            cur.arguments += tc.function.arguments;
+            onProgress();
+          }
+          tools.set(idx, cur);
+        }
+      }
+    }
+    const toolCalls = [...tools.entries()].sort(([a], [b]) => a - b).map(([, v]) => ({
+      id: v.id ?? "",
+      type: "function",
+      function: { name: v.name ?? "", arguments: v.arguments }
+    }));
+    return {
+      choices: [{
+        finish_reason: finishReason,
+        message: {
+          content: content || null,
+          ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+        }
+      }]
+    };
+  }
+  const RETRY_TOOL_CALL_ID = "retry_call_0";
+  function buildMessages(prompt, system) {
+    const messages = [];
+    if (system !== void 0) messages.push({ role: "system", content: system });
+    messages.push({ role: "user", content: prompt });
+    return messages;
+  }
+  function appendRetry(messages, retry, toolName) {
+    messages.push({
+      role: "assistant",
+      content: null,
+      tool_calls: [{
+        id: RETRY_TOOL_CALL_ID,
+        type: "function",
+        function: { name: toolName, arguments: JSON.stringify(retry.previousOutput) }
+      }]
+    });
+    messages.push({
+      role: "tool",
+      tool_call_id: RETRY_TOOL_CALL_ID,
+      content: retry.feedback
+    });
+  }
+  return {
+    async generateText(input) {
+      const messages = buildMessages(input.prompt, input.system);
+      const opts = input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {};
+      const response = input.onProgress ? await callStream(messages, opts, input.signal, input.onProgress) : await call(messages, opts, input.signal);
+      return response.choices[0]?.message.content ?? "";
+    },
+    async generateObject(input) {
+      const toolName = input.objectName ?? "structured_output";
+      const structuredParams = JSONSchema.make(input.schema);
+      const helperTools = input.tools ?? [];
+      const helperByName = new Map(helperTools.map((t) => [t.name, t]));
+      const tools = [
+        ...helperTools.map((t) => ({
+          type: "function",
+          function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.inputJsonSchema
+          }
+        })),
+        {
+          type: "function",
+          function: {
+            name: toolName,
+            description: "Return the structured output as the function arguments.",
+            parameters: structuredParams
+          }
+        }
+      ];
+      const toolChoice = helperTools.length > 0 ? "required" : { type: "function", function: { name: toolName } };
+      const messages = buildMessages(input.prompt, input.system);
+      if (input.retry) appendRetry(messages, input.retry, toolName);
+      const opts = {
+        tools,
+        toolChoice,
+        ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {}
+      };
+      const decodeArgs = (raw) => {
+        try {
+          return JSON.parse(raw);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          throw new Error(`\u65E0\u6CD5\u89E3\u6790\u6A21\u578B\u8FD4\u56DE\u7684\u7ED3\u6784\u5316\u6570\u636E: ${message}`);
+        }
+      };
+      const decode = (raw) => {
+        try {
+          return Schema.decodeUnknownSync(input.schema)(raw);
+        } catch (cause) {
+          throw new StructuredOutputDecodeError(raw, cause);
+        }
+      };
+      for (; ; ) {
+        const response = input.onProgress ? await callStream(messages, opts, input.signal, input.onProgress) : await call(messages, opts, input.signal);
+        const choice = response.choices[0];
+        const structured = choice?.message.tool_calls?.find((c) => c.function.name === toolName);
+        if (structured) {
+          return decode(decodeArgs(structured.function.arguments));
+        }
+        const helperCalls = choice?.message.tool_calls ?? [];
+        if (helperCalls.length === 0) {
+          if (choice?.finish_reason === "length") {
+            throw new Error("\u6A21\u578B\u5728\u4EA7\u51FA\u7ED3\u6784\u5316\u7ED3\u679C\u524D\u7528\u5C3D\u4E86 token \u9884\u7B97\uFF08finish_reason=length\uFF09\u3002\u8BF7\u63D0\u9AD8 maxTokens\uFF0C\u6216\u6362\u7528\u975E\u63A8\u7406\u6A21\u578B\u3002");
+          }
+          const text = choice?.message.content ?? "";
+          const reason = choice?.finish_reason ? `\uFF08finish_reason=${choice.finish_reason}\uFF09` : "";
+          throw new Error(`\u6A21\u578B\u672A\u8FD4\u56DE\u7ED3\u6784\u5316\u8F93\u51FA${reason}${text ? `: ${text.slice(0, 200)}` : ""}`);
+        }
+        messages.push({
+          role: "assistant",
+          content: null,
+          tool_calls: helperCalls
+        });
+        for (const callBlock of helperCalls) {
+          const tool = helperByName.get(callBlock.function.name);
+          if (!tool) {
+            messages.push({
+              role: "tool",
+              tool_call_id: callBlock.id,
+              content: `Unknown tool: ${callBlock.function.name}`
+            });
+            continue;
+          }
+          let parsedInput = {};
+          try {
+            parsedInput = callBlock.function.arguments ? JSON.parse(callBlock.function.arguments) : {};
+          } catch {
+          }
+          try {
+            const result = await tool.execute(parsedInput);
+            messages.push({
+              role: "tool",
+              tool_call_id: callBlock.id,
+              content: typeof result === "string" ? result : JSON.stringify(result)
+            });
+          } catch (err) {
+            messages.push({
+              role: "tool",
+              tool_call_id: callBlock.id,
+              content: err instanceof Error ? err.message : String(err)
+            });
+          }
+        }
+      }
+    }
+  };
+}
+function buildClient(cfg) {
+  switch (cfg.provider) {
+    case "anthropic":
+      return buildAnthropicClient(cfg);
+    case "openai":
+      return buildOpenAIClient(cfg);
+    default:
+      throw new Error(`unsupported AI provider: ${cfg.provider}`);
+  }
+}
+export default defineNuxtPlugin({
+  name: "shwfed:ai",
+  setup: () => {
+    const config = createConfigRef();
+    const allowed = isByokAllowed();
+    const available = computed(() => allowed && config.value !== null);
+    function setConfig(next) {
+      config.value = next;
+    }
+    function openSettings() {
+      settingsOpen.value = true;
+    }
+    async function generateText(input) {
+      const cfg = config.value;
+      if (!cfg) throw new Error("AI \u672A\u914D\u7F6E");
+      return buildClient(cfg).generateText(input);
+    }
+    async function generateObject(input) {
+      const cfg = config.value;
+      if (!cfg) throw new Error("AI \u672A\u914D\u7F6E");
+      return buildClient(cfg).generateObject(input);
+    }
+    const ai = {
+      available,
+      config,
+      setConfig,
+      openSettings,
+      generateText,
+      generateObject
+    };
+    return {
+      provide: { ai }
+    };
+  }
+});

package/dist/runtime/plugins/ai/settings-state.d.ts

@@ -0,0 +1 @@
+export declare const settingsOpen: import("vue").Ref<boolean, boolean>;

package/dist/runtime/plugins/ai/settings-state.js

@@ -0,0 +1,2 @@
+import { ref } from "vue";
+export const settingsOpen = ref(false);

package/dist/runtime/plugins/ai/store.d.ts

@@ -0,0 +1,17 @@
+import { type Ref } from 'vue';
+export type AiProvider = 'anthropic' | 'openai';
+export interface AiConfig {
+    provider: AiProvider;
+    apiKey: string;
+    model?: string;
+    endpoint?: string;
+    maxTokens?: number;
+}
+export declare const DEFAULT_MAX_TOKENS = 8192;
+export declare function loadConfig(): AiConfig | null;
+export declare function saveConfig(config: AiConfig | null): void;
+export declare function createConfigRef(): Ref<AiConfig | null>;
+export declare const PROVIDER_DEFAULTS: Record<AiProvider, {
+    model: string;
+    endpoint: string;
+}>;

package/dist/runtime/plugins/ai/store.js

@@ -0,0 +1,40 @@
+import { ref, watch } from "vue";
+export const DEFAULT_MAX_TOKENS = 8192;
+const STORAGE_KEY = "shwfed:ai:byok";
+function isProvider(v) {
+  return v === "anthropic" || v === "openai";
+}
+export function loadConfig() {
+  if (typeof window === "undefined") return null;
+  try {
+    const raw = window.localStorage.getItem(STORAGE_KEY);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    if (typeof parsed.apiKey !== "string" || parsed.apiKey.length === 0) return null;
+    if (!isProvider(parsed.provider)) return null;
+    return {
+      provider: parsed.provider,
+      apiKey: parsed.apiKey,
+      model: typeof parsed.model === "string" && parsed.model ? parsed.model : void 0,
+      endpoint: typeof parsed.endpoint === "string" && parsed.endpoint ? parsed.endpoint : void 0,
+      maxTokens: typeof parsed.maxTokens === "number" && Number.isFinite(parsed.maxTokens) && parsed.maxTokens > 0 ? Math.floor(parsed.maxTokens) : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+export function saveConfig(config) {
+  if (typeof window === "undefined") return;
+  if (config === null) window.localStorage.removeItem(STORAGE_KEY);
+  else window.localStorage.setItem(STORAGE_KEY, JSON.stringify(config));
+}
+export function createConfigRef() {
+  const r = ref(loadConfig());
+  watch(r, (next) => saveConfig(next), { deep: true });
+  return r;
+}
+export const PROVIDER_DEFAULTS = {
+  anthropic: { model: "claude-sonnet-4-5-20250929", endpoint: "https://api.anthropic.com/v1/messages" },
+  openai: { model: "gpt-4o-mini", endpoint: "https://api.openai.com/v1/chat/completions" }
+};

package/dist/runtime/plugins/cel/context.d.ts

@@ -0,0 +1,10 @@
+export type CELVar = {
+    type: string;
+    label: string;
+    description?: string;
+    value: unknown;
+};
+export type CELContext = Record<string, CELVar>;
+export declare function provideCELContext(context: CELContext): void;
+export declare function injectCELContext(): CELContext;
+export declare function celBindings(context: CELContext): Record<string, unknown>;

package/dist/runtime/plugins/cel/context.js

@@ -0,0 +1,17 @@
+import { injectLocal, provideLocal } from "@vueuse/core";
+import { defu } from "defu";
+const CEL_CONTEXT_KEY = Symbol("cel-context");
+export function provideCELContext(context) {
+  const parent = injectLocal(CEL_CONTEXT_KEY, {});
+  provideLocal(CEL_CONTEXT_KEY, defu(context, parent));
+}
+export function injectCELContext() {
+  return injectLocal(CEL_CONTEXT_KEY, {});
+}
+export function celBindings(context) {
+  const out = {};
+  for (const [name, entry] of Object.entries(context)) {
+    out[name] = typeof entry.value === "function" ? entry.value() : entry.value;
+  }
+  return out;
+}

package/dist/runtime/plugins/cel/http.d.ts

@@ -0,0 +1,8 @@
+import type { NuxtApp } from '#app';
+import type { Environment } from '../../vendor/cel-js/lib/index.js';
+declare class Http {
+    readonly brand: "http";
+}
+export declare const HTTP_INSTANCE: Http;
+export declare function registerHttpFunctions(env: Environment, http: NuxtApp['$http']): void;
+export {};