@shwfed/config 2.11.6 → 2.12.1

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

@@ -1,5 +1,6 @@
 import { type ComputedRef } from 'vue';
 import { Schema } from 'effect';
+import type { UIMessage } from './parts.js';
 export interface GenerateTextInput {
     readonly prompt: string;
     readonly system?: string;
@@ -27,10 +28,19 @@ export interface GenerateObjectInput<A, I extends Record<string, unknown>> {
         readonly feedback: string;
     };
 }
+export interface StreamChatInput {
+    readonly messages: ReadonlyArray<UIMessage>;
+    readonly system?: string;
+    readonly tools?: ReadonlyArray<AgenticTool>;
+    readonly signal?: AbortSignal;
+    readonly maxTokens?: number;
+    readonly onMessageUpdate?: (assistant: UIMessage) => void;
+}
 export interface Ai {
     readonly available: ComputedRef<boolean>;
     readonly generateText: (input: GenerateTextInput) => Promise<string>;
     readonly generateObject: <A, I extends Record<string, unknown>>(input: GenerateObjectInput<A, I>) => Promise<A>;
+    readonly streamChat: (input: StreamChatInput) => Promise<UIMessage>;
 }
 export declare class StructuredOutputDecodeError extends Error {
     readonly rawOutput: unknown;

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

@@ -1,9 +1,11 @@
 import { computed } from "vue";
 import { JSONSchema, Schema } from "effect";
+import { createMessageId, isToolUIPart } from "./parts.js";
+import { coerceFromString } from "../../share/coerce-from-string.js";
 const ENDPOINT = "http://192.168.168.10/anthropic/v1/messages";
 const MODEL = "MiniMax-M2.7";
 const ANTHROPIC_VERSION = "2023-06-01";
-const DEFAULT_MAX_TOKENS = 8192;
+const DEFAULT_MAX_TOKENS = 32768;
 export class StructuredOutputDecodeError extends Error {
   rawOutput;
   constructor(rawOutput, cause) {
@@ -76,7 +78,7 @@ async function call(messages, system, options, signal) {
   }
   return await res.json();
 }
-async function callStream(messages, system, options, signal, onProgress) {
+async function callStream(messages, system, options, signal, onProgress, events) {
   const body = { ...buildBody(messages, system, options), stream: true };
   const res = await fetch(ENDPOINT, buildInit(body, signal));
   if (!res.ok) {
@@ -95,22 +97,26 @@ async function callStream(messages, system, options, signal, onProgress) {
     const p = payload;
     if (p.type === "content_block_start" && typeof p.index === "number" && p.content_block) {
       const cb = p.content_block;
-      blocks.set(p.index, {
+      const block = {
         type: cb.type === "tool_use" ? "tool_use" : "text",
         text: "",
         toolId: cb.id,
         toolName: cb.name,
         inputJson: ""
-      });
+      };
+      blocks.set(p.index, block);
+      events?.onStart?.(p.index, block);
     } else if (p.type === "content_block_delta" && typeof p.index === "number" && p.delta) {
       const cur = blocks.get(p.index);
       if (!cur) continue;
       if (p.delta.type === "text_delta" && p.delta.text) {
         cur.text += p.delta.text;
         onProgress();
+        events?.onDelta?.(p.index, cur);
       } else if (p.delta.type === "input_json_delta" && p.delta.partial_json) {
         cur.inputJson += p.delta.partial_json;
         onProgress();
+        events?.onDelta?.(p.index, cur);
       }
     } else if (p.type === "message_delta" && p.delta?.stop_reason) {
       stopReason = p.delta.stop_reason;
@@ -162,6 +168,33 @@ function appendRetry(messages, retry, toolName) {
     }]
   });
 }
+async function runToolResults(messages, assistantContent, toolUses, helperByName, onOutcome) {
+  messages.push({ role: "assistant", content: assistantContent });
+  const results = [];
+  for (const useBlock of toolUses) {
+    const tool = helperByName.get(useBlock.name);
+    if (!tool) {
+      const errorText = `Unknown tool: ${useBlock.name}`;
+      results.push({ type: "tool_result", tool_use_id: useBlock.id, content: errorText });
+      onOutcome?.(useBlock, { status: "output-error", errorText });
+      continue;
+    }
+    try {
+      const result = await tool.execute(useBlock.input ?? {});
+      results.push({
+        type: "tool_result",
+        tool_use_id: useBlock.id,
+        content: typeof result === "string" ? result : JSON.stringify(result)
+      });
+      onOutcome?.(useBlock, { status: "output-available", output: result });
+    } catch (err) {
+      const errorText = err instanceof Error ? err.message : String(err);
+      results.push({ type: "tool_result", tool_use_id: useBlock.id, content: errorText });
+      onOutcome?.(useBlock, { status: "output-error", errorText });
+    }
+  }
+  messages.push({ role: "user", content: results });
+}
 async function generateText(input) {
   const messages = buildUserMessages(input.prompt);
   const opts = input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {};
@@ -195,7 +228,7 @@ async function generateObject(input) {
   };
   const decode = (raw) => {
     try {
-      return Schema.decodeUnknownSync(input.schema)(raw);
+      return Schema.decodeUnknownSync(input.schema)(coerceFromString(raw, input.schema));
     } catch (cause) {
       throw new StructuredOutputDecodeError(raw, cause);
     }
@@ -217,41 +250,121 @@ async function generateObject(input) {
       const reason = response.stop_reason ? `\uFF08stop_reason=${response.stop_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: toolUses
+    await runToolResults(messages, toolUses, toolUses, helperByName);
+  }
+}
+function partsToText(parts) {
+  return parts.filter((p) => p.type === "text").map((p) => p.text).join("");
+}
+async function streamChat(input) {
+  const helperTools = input.tools ?? [];
+  const helperByName = new Map(helperTools.map((t) => [t.name, t]));
+  const tools = helperTools.length > 0 ? helperTools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.inputJsonSchema
+  })) : void 0;
+  const messages = input.messages.map(
+    (m) => ({ role: m.role, content: partsToText(m.parts) })
+  );
+  const opts = {
+    ...tools !== void 0 ? { tools } : {},
+    ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {}
+  };
+  const assistant = { id: createMessageId(), role: "assistant", parts: [] };
+  const publish = () => input.onMessageUpdate?.(assistant);
+  const MAX_TRUNCATION_STREAK = 3;
+  let truncationStreak = 0;
+  for (; ; ) {
+    const partByIndex = /* @__PURE__ */ new Map();
+    const response = await callStream(messages, input.system, opts, input.signal, () => {
+    }, {
+      onStart: (index, block) => {
+        const part = block.type === "tool_use" ? {
+          type: `tool-${block.toolName ?? ""}`,
+          toolCallId: block.toolId ?? "",
+          state: "input-streaming"
+        } : { type: "text", text: "", state: "streaming" };
+        assistant.parts.push(part);
+        partByIndex.set(index, part);
+        publish();
+      },
+      onDelta: (index, block) => {
+        const part = partByIndex.get(index);
+        if (part?.type === "text") {
+          part.text = block.text;
+          publish();
+        }
+      }
     });
-    const results = [];
-    for (const useBlock of toolUses) {
-      const tool = helperByName.get(useBlock.name);
-      if (!tool) {
-        results.push({
-          type: "tool_result",
-          tool_use_id: useBlock.id,
-          content: `Unknown tool: ${useBlock.name}`
-        });
-        continue;
+    response.content.forEach((block, i) => {
+      const part = partByIndex.get(i);
+      if (!part) return;
+      if (block.type === "text") {
+        if (part.type === "text") {
+          part.text = block.text;
+          part.state = "done";
+        }
+      } else if (part.type !== "text") {
+        part.input = block.input;
+        if (part.state === "input-streaming") part.state = "input-available";
       }
-      try {
-        const result = await tool.execute(useBlock.input ?? {});
-        results.push({
-          type: "tool_result",
-          tool_use_id: useBlock.id,
-          content: typeof result === "string" ? result : JSON.stringify(result)
-        });
-      } catch (err) {
-        results.push({
-          type: "tool_result",
-          tool_use_id: useBlock.id,
-          content: err instanceof Error ? err.message : String(err)
+    });
+    publish();
+    const toolUses = response.content.filter(
+      (b) => b.type === "tool_use"
+    );
+    if (toolUses.length === 0) {
+      if (response.stop_reason === "max_tokens") {
+        if (truncationStreak >= MAX_TRUNCATION_STREAK) {
+          throw new Error("\u6A21\u578B\u8FDE\u7EED\u591A\u8F6E\u5728\u4EA7\u51FA\u524D\u7528\u5C3D token \u9884\u7B97\uFF08max_tokens\uFF09\uFF0C\u5DF2\u505C\u6B62\u3002\u8BF7\u7F29\u5C0F\u672C\u6B21\u914D\u7F6E\u8303\u56F4\u6216\u62C6\u5206\u6307\u4EE4\u540E\u91CD\u8BD5\u3002");
+        }
+        truncationStreak++;
+        const echoable = response.content.filter(
+          (b) => !(b.type === "text" && b.text.length === 0)
+        );
+        const assistantEcho = echoable.length > 0 ? echoable : [{ type: "text", text: "\u2026" }];
+        messages.push({ role: "assistant", content: assistantEcho });
+        messages.push({
+          role: "user",
+          content: "\u4E0A\u4E00\u8F6E\u5728 max_tokens \u5904\u88AB\u622A\u65AD\u3002\u8BF7\u7528\u66F4\u5C0F\u7684\u6B65\u5B50\u7EE7\u7EED\uFF1A\u672C\u8F6E\u53EA\u505A\u4E00\u6B65\uFF08\u4E00\u4E2A\u5DE5\u5177\u8C03\u7528\uFF0C\u6216\u4E00\u6BB5\u7B80\u77ED\u56DE\u590D\uFF09\u3002"
         });
+        if (assistant.parts.length > 0) {
+          assistant.parts.push({ type: "step-start" });
+          publish();
+        }
+        continue;
       }
+      return assistant;
     }
-    messages.push({ role: "user", content: results });
+    truncationStreak = 0;
+    await runToolResults(
+      messages,
+      response.content,
+      toolUses,
+      helperByName,
+      (useBlock, outcome) => {
+        const part = assistant.parts.find(
+          (p) => isToolUIPart(p) && p.toolCallId === useBlock.id
+        );
+        if (!part) return;
+        if (outcome.status === "output-available") {
+          part.state = "output-available";
+          part.output = outcome.output;
+        } else {
+          part.state = "output-error";
+          part.errorText = outcome.errorText;
+        }
+        publish();
+      }
+    );
+    assistant.parts.push({ type: "step-start" });
+    publish();
   }
 }
 export const ai = {
   available: computed(() => true),
   generateText,
-  generateObject
+  generateObject,
+  streamChat
 };

package/dist/runtime/utils/ai/parts.d.ts

@@ -0,0 +1,30 @@
+export interface TextUIPart {
+    type: 'text';
+    text: string;
+    state?: 'streaming' | 'done';
+}
+export interface ReasoningUIPart {
+    type: 'reasoning';
+    text: string;
+    state?: 'streaming' | 'done';
+}
+export interface StepStartUIPart {
+    type: 'step-start';
+}
+export interface ToolUIPart {
+    type: `tool-${string}`;
+    toolCallId: string;
+    state: 'input-streaming' | 'input-available' | 'output-available' | 'output-error';
+    input?: unknown;
+    output?: unknown;
+    errorText?: string;
+}
+export type UIMessagePart = TextUIPart | ReasoningUIPart | StepStartUIPart | ToolUIPart;
+export interface UIMessage {
+    id: string;
+    role: 'user' | 'assistant';
+    parts: UIMessagePart[];
+}
+export declare function isToolUIPart(part: UIMessagePart): part is ToolUIPart;
+export declare function toolNameOf(part: ToolUIPart): string;
+export declare function createMessageId(): string;

package/dist/runtime/utils/ai/parts.js

@@ -0,0 +1,9 @@
+export function isToolUIPart(part) {
+  return part.type.startsWith("tool-");
+}
+export function toolNameOf(part) {
+  return part.type.slice("tool-".length);
+}
+export function createMessageId() {
+  return crypto.randomUUID();
+}

package/dist/runtime/utils/disabled-date.d.ts

@@ -0,0 +1,26 @@
+import type { DateValue } from 'reka-ui';
+/**
+ * Convert an `@internationalized/date` `DateValue` (what the picker's
+ * `disabledDate` callback receives) to a native JS `Date`, so user expressions
+ * see a plain `input: Date`. Mirrors `pickerValueToNative` in
+ * `ui/date-picker/DatePicker.vue` (minus the `Time` branch — the per-date
+ * predicate never receives a `Time`). For a `CalendarDate` (date/month/year
+ * panels) the time fields are absent and default to `0`; for `month` panels the
+ * candidate is the first of the month (`day` is `1`).
+ */
+export declare function dateValueToNative(d: DateValue): Date;
+/**
+ * Build the `(d: DateValue) => boolean` predicate the date pickers expect from a
+ * user-authored CEL expression. Centralizes three concerns shared by every date
+ * block: the `DateValue` → native `Date` conversion, the "expression returns
+ * `true` ⇒ date disabled" mapping (`false`/`undefined`/none ⇒ enabled — matching
+ * reka-ui's native `isDateDisabled`), and error containment (a throwing
+ * expression leaves the date enabled).
+ *
+ * Each runtime passes its own `evalWithInput` closure so its existing CEL scope
+ * is preserved verbatim — form fields evaluate against `{ form, input }`, table
+ * columns against `celScope(celContext, { input })`. Returns `undefined` when
+ * there's no expression, so the picker omits the prop and all dates stay
+ * selectable.
+ */
+export declare function makeDisabledDatePredicate(expr: string | undefined, evalWithInput: (input: Date) => boolean | undefined): ((d: DateValue) => boolean) | undefined;

package/dist/runtime/utils/disabled-date.js

@@ -0,0 +1,21 @@
+export function dateValueToNative(d) {
+  return new Date(
+    d.year,
+    d.month - 1,
+    "day" in d ? d.day : 1,
+    "hour" in d ? d.hour : 0,
+    "hour" in d ? d.minute : 0,
+    "hour" in d ? d.second : 0
+  );
+}
+export function makeDisabledDatePredicate(expr, evalWithInput) {
+  if (!expr) return void 0;
+  return (d) => {
+    try {
+      return evalWithInput(dateValueToNative(d)) === true;
+    } catch (e) {
+      console.error("[shwfed] disabledDate expression failed", e);
+      return false;
+    }
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shwfed/config",
-  "version": "2.11.6",
+  "version": "2.12.1",
   "description": "Configurable UI for SHWFED",
   "type": "module",
   "publishConfig": {
@@ -68,6 +68,7 @@
     "fx-fetch": "^1.1.2",
     "markdown-it": "^14.1.1",
     "reka-ui": "^2.9.7",
+    "remend": "^1.3.0",
     "tailwind-merge": "^3.6.0",
     "tailwindcss": "^4.3.0",
     "vaul-vue": "^0.4.1",