@shwfed/config 2.11.5 → 2.12.0

package/dist/runtime/components/ui/stream-markdown/StreamMarkdown.d.vue.ts

@@ -0,0 +1,15 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    source: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    source: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/runtime/components/ui/stream-markdown/StreamMarkdown.vue

@@ -0,0 +1,22 @@
+<script>
+import { useRuntimeConfig } from "#app";
+import remend from "remend";
+import { computed, defineComponent, h } from "vue";
+import { md } from "../../../utils/markdown";
+const REMEND_OPTIONS = {
+  linkMode: "text-only",
+  katex: false,
+  inlineKatex: false
+};
+export default defineComponent({
+  name: "UiStreamMarkdown",
+  props: {
+    source: { type: String, required: true }
+  },
+  setup(props) {
+    const env = { base: useRuntimeConfig().app.baseURL || "/" };
+    const html = computed(() => md.render(remend(props.source, REMEND_OPTIONS), env));
+    return () => h("div", { "data-slot": "stream-markdown", "innerHTML": html.value });
+  }
+});
+</script>

package/dist/runtime/components/ui/stream-markdown/StreamMarkdown.vue.d.ts

@@ -0,0 +1,15 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    source: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    source: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/runtime/components/ui/stream-markdown/index.d.ts

@@ -0,0 +1 @@
+export { default as StreamMarkdown } from './StreamMarkdown.vue.js';

package/dist/runtime/components/ui/stream-markdown/index.js

@@ -0,0 +1 @@
+export { default as StreamMarkdown } from "./StreamMarkdown.vue";

package/dist/runtime/share/coerce-from-string.d.ts

@@ -0,0 +1,62 @@
+import { SchemaAST } from 'effect';
+/**
+ * Coerce AI tool-call outputs that the model accidentally stringified.
+ *
+ * The AI tool-call loop accumulates `partial_json` deltas and concatenates them
+ * into one JSON string, then `JSON.parse`s it. When the model is unsure about a
+ * field's wire shape — does `size` want a number or a string? — it sometimes
+ * stringifies the value, so the parser hands us e.g. `size: "120"` while the
+ * column schema declares `Schema.Number.pipe(Schema.finite(), Schema.positive())`.
+ *
+ * `Schema.decodeUnknownSync` then rejects with `Expected number, actual string`,
+ * the chat loop can't recover, and the user sees the "改写配置中…" card spin
+ * forever. The same bug also affects `grow` (Boolean), `gap` (Number),
+ * `expandAll` (Boolean), every column/button/block schema's primitive fields —
+ * per-schema `Schema.transform` workarounds would touch dozens of files and
+ * pollute the JSON Schema we hand back to the model (it would advertise
+ * `oneOf: [number, string]` and tell the model "strings are OK", which they
+ * aren't).
+ *
+ * This helper takes a different path: walk the raw value in parallel with the
+ * schema's AST, and silently coerce string → number / boolean based on what the
+ * schema expects. The schema is never modified, so:
+ *
+ *   - `JSONSchema.make(schema)` still emits `type: number` / `type: boolean`
+ *     for the model (it sees the canonical types and is asked to honor them).
+ *   - Existing `Schema.suspend(Schema.transform(...))` wrappers (e.g. `Locale`,
+ *     which already forgives stringified tuples) keep working — this preprocessor
+ *     passes strings through for fields whose schema accepts strings.
+ *   - Effect 3.21.2's `Schema.optionalWith` quirk (it strips peer property
+ *     Transformation wrappers — see the `Locale` fix) cannot fire, because we
+ *     never add a Transformation anywhere.
+ *
+ * Apply this at the AI decode chokepoint, BEFORE `Schema.decodeUnknownSync`.
+ * After preprocessing, the raw value is structurally compatible with the
+ * schema, and the schema's own validators (finite/positive/etc.) still run.
+ */
+/**
+ * Pre-process `raw` so it decodes cleanly against `schema`. The schema is read
+ * but never modified — this is a pure transformation of the value side.
+ *
+ * Safe to call on already-typed values (numbers stay numbers, etc.); the only
+ * change is `string → number` when the schema expects a number, and the
+ * equivalent for booleans. JSON-stringified object/array payloads are also
+ * parsed once, mirroring the `Locale` tuple fix at the general level.
+ *
+ * `S` is inferred from the call site. We don't pin it to one of Effect's
+ * bundled `Schema.Any` / `Schema.All` aliases because their third type
+ * parameter (Context / R) collides between `never` and `unknown` under
+ * strict mode, making any of them reject callers that pass the other.
+ */
+export declare function coerceFromString<S extends {
+    readonly ast: SchemaAST.AST;
+}>(raw: unknown, schema: S): unknown;
+/**
+ * Build a JSON Schema with the same shape as `JSONSchema.make(schema)` —
+ * exposed only for the test suite to lock in the "no JSONSchema pollution"
+ * guarantee. If this drifts from `JSONSchema.make`, the implementation
+ * accidentally changed the schema and the model will be misled.
+ */
+export declare function peekJsonSchema<S extends {
+    ast: SchemaAST.AST;
+}>(schema: S): unknown;

package/dist/runtime/share/coerce-from-string.js

@@ -0,0 +1,154 @@
+import { JSONSchema, SchemaAST } from "effect";
+export function coerceFromString(raw, schema) {
+  return preprocess(raw, schema.ast);
+}
+function preprocess(value, ast) {
+  const shape = unwrap(ast);
+  if (value === null || value === void 0) return value;
+  if (typeof value !== "object") return value;
+  if (Array.isArray(value)) {
+    if (shape._tag === "TupleType") {
+      const elements = shape.elements;
+      const restAst = shape.rest[0]?.type ?? SchemaAST.unknownKeyword;
+      return value.map((v, i) => {
+        const elementType = i < elements.length ? elements[i].type : restAst;
+        return preprocessField(v, elementType);
+      });
+    }
+    return value.map((v) => preprocessField(v, shape));
+  }
+  if (shape._tag === "TypeLiteral") {
+    return preprocessStruct(value, shape);
+  }
+  return value;
+}
+function preprocessStruct(value, ast) {
+  const result = {};
+  for (const ps of ast.propertySignatures) {
+    const key = ps.name;
+    if (!(key in value)) continue;
+    result[key] = preprocessField(value[key], ps.type);
+  }
+  for (const key of Object.keys(value)) {
+    if (!(key in result)) result[key] = value[key];
+  }
+  return result;
+}
+function preprocessField(value, ast) {
+  if (typeof value === "string") {
+    const parsedJson = tryParseJson(value, ast);
+    if (parsedJson !== void 0) return preprocess(parsedJson, ast);
+  }
+  if (typeof value === "string") {
+    if (expectsNumber(ast)) {
+      if (value.trim() !== "") return Number(value);
+      return value;
+    }
+    if (expectsBoolean(ast)) {
+      if (value === "true") return true;
+      if (value === "false") return false;
+      return value;
+    }
+  }
+  if (ast._tag === "TypeLiteral" && isPlainObject(value)) {
+    return preprocessStruct(value, ast);
+  }
+  if (ast._tag === "TupleType" && Array.isArray(value)) {
+    const elements = ast.elements;
+    const restAst = ast.rest[0]?.type ?? SchemaAST.unknownKeyword;
+    return value.map((v, i) => {
+      const elementType = i < elements.length ? elements[i].type : restAst;
+      return preprocessField(v, elementType);
+    });
+  }
+  if (ast._tag === "Union") {
+    if (typeof value === "string") {
+      const wantsNumber = ast.types.some(expectsNumber);
+      const wantsBoolean = ast.types.some(expectsBoolean);
+      if (wantsNumber && !wantsBoolean) {
+        if (value.trim() !== "") return Number(value);
+        return value;
+      }
+      if (wantsBoolean && !wantsNumber) {
+        return value === "true";
+      }
+    }
+    return value;
+  }
+  if (ast._tag === "Refinement") return preprocessField(value, ast.from);
+  if (ast._tag === "Suspend") return preprocessField(value, ast.f());
+  if (ast._tag === "Declaration") {
+    return preprocessField(value, ast.typeParameters[0] ?? ast);
+  }
+  if (ast._tag === "Transformation") {
+    return preprocessField(value, ast.from);
+  }
+  return value;
+}
+function unwrap(ast) {
+  switch (ast._tag) {
+    case "Suspend":
+      return unwrap(ast.f());
+    case "Refinement":
+      return unwrap(ast.from);
+    case "Declaration":
+      return unwrap(ast.typeParameters[0] ?? ast);
+    case "Transformation":
+      return unwrap(ast.from);
+    default:
+      return ast;
+  }
+}
+function expectsNumber(ast) {
+  switch (ast._tag) {
+    case "NumberKeyword":
+      return true;
+    case "Refinement":
+      return expectsNumber(ast.from);
+    case "Suspend":
+      return expectsNumber(ast.f());
+    case "Declaration":
+      return expectsNumber(ast.typeParameters[0] ?? ast);
+    case "Union":
+      return ast.types.some(expectsNumber);
+    case "Transformation":
+      return expectsNumber(ast.from);
+    default:
+      return false;
+  }
+}
+function expectsBoolean(ast) {
+  switch (ast._tag) {
+    case "BooleanKeyword":
+      return true;
+    case "Refinement":
+      return expectsBoolean(ast.from);
+    case "Suspend":
+      return expectsBoolean(ast.f());
+    case "Declaration":
+      return expectsBoolean(ast.typeParameters[0] ?? ast);
+    case "Union":
+      return ast.types.some(expectsBoolean);
+    case "Transformation":
+      return expectsBoolean(ast.from);
+    default:
+      return false;
+  }
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function tryParseJson(value, ast) {
+  const unwrapped = unwrap(ast);
+  if (unwrapped._tag !== "TypeLiteral" && unwrapped._tag !== "TupleType") return void 0;
+  const trimmed = value.trimStart();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+export function peekJsonSchema(schema) {
+  return JSONSchema.make(schema);
+}

package/dist/runtime/share/locale.d.ts

@@ -1,11 +1,17 @@
 import { Schema } from 'effect';
-export declare const Locale: Schema.TupleType<readonly [Schema.Struct<{
-    locale: Schema.Literal<["zh"]>;
-    message: Schema.SchemaClass<string, string, never>;
-}>], [Schema.Struct<{
-    locale: Schema.Literal<["ja", "en", "ko"]>;
-    message: Schema.SchemaClass<string, string, never>;
-}>]>;
+export declare const Locale: Schema.suspend<readonly [{
+    readonly locale: "zh";
+    readonly message: string;
+}, ...{
+    readonly locale: "en" | "ja" | "ko";
+    readonly message: string;
+}[]], string | readonly [{
+    readonly locale: "zh";
+    readonly message: string;
+}, ...{
+    readonly locale: "en" | "ja" | "ko";
+    readonly message: string;
+}[]], never>;
 export type LocaleValue = Schema.Schema.Type<typeof Locale>;
 export declare function hasVisibleLocaleValue(value: LocaleValue | undefined): boolean;
 export declare function getLocalizedText(messages: LocaleValue | undefined, locale: string): string | undefined;

package/dist/runtime/share/locale.js

@@ -15,13 +15,35 @@ const OtherLocaleItem = Schema.Struct({
     description: "\u9488\u5BF9\u8BE5\u8BED\u8A00\u7684 UI \u6587\u672C"
   })
 });
-export const Locale = Schema.Tuple(
+const LocaleTuple = Schema.Tuple(
   [ZhLocaleItem],
   OtherLocaleItem
-).annotations({
-  title: "Locale",
-  description: "\u672C\u5730\u5316\u6587\u672C\u5217\u8868\uFF0Czh \u5FC5\u987B\u4E3A\u9996\u9879"
-});
+);
+function coerceStringToLocale(input) {
+  if (input.trimStart().startsWith("[")) {
+    try {
+      const parsed = JSON.parse(input);
+      if (Array.isArray(parsed)) return parsed;
+    } catch {
+    }
+  }
+  return [{ locale: "zh", message: input }];
+}
+export const Locale = Schema.suspend(
+  () => Schema.transform(
+    Schema.Union(LocaleTuple, Schema.String),
+    LocaleTuple,
+    {
+      strict: true,
+      decode: (input) => typeof input === "string" ? coerceStringToLocale(input) : input,
+      encode: (input) => input
+    }
+  ).annotations({
+    identifier: "Locale",
+    title: "Locale",
+    description: "\u672C\u5730\u5316\u6587\u672C\u5217\u8868\uFF0Czh \u5FC5\u987B\u4E3A\u9996\u9879\uFF1B\u63A5\u53D7\u7EAF\u5B57\u7B26\u4E32\uFF08\u82E5\u662F JSON-encoded tuple \u5219\u89E3\u6790\u5B83\uFF0C\u5426\u5219\u5F53\u4F5C zh \u6587\u672C\u6765\u7528\uFF09"
+  })
+);
 export function hasVisibleLocaleValue(value) {
   return value?.some((item) => item.message.trim().length > 0) ?? false;
 }

package/dist/runtime/share/use-persisted-chat.d.ts

@@ -0,0 +1,30 @@
+import { type Ref } from 'vue';
+import type { UIMessage } from '../utils/ai/parts.js';
+/**
+ * Mirrors a table editor's AI-chat history into `sessionStorage`, keyed on the
+ * table's stable `config.id`, so the conversation survives both the chat
+ * component unmounting — switching away from the "AI 生成" section `v-if`-
+ * unmounts `<TableAiGenerate>`, dropping its local `ref<UIMessage[]>` — and a
+ * page reload. It clears when the browser tab is closed (`sessionStorage`
+ * lifetime), giving each table a per-instance, session-scoped chat memory.
+ *
+ * Modeled on `usePersistedQuery`: every access is SSR-guarded and guarded
+ * against unavailable storage (privacy modes). With no `tableId()` persistence
+ * is a no-op (in-memory only) so id-less drafts can't collide on a shared key.
+ *
+ * - `restore()` seeds `messages` from the stored snapshot. Call it in
+ *   `onMounted`, after the fresh component's empty ref exists, so a remount
+ *   rehydrates the prior conversation.
+ * - `clear()` drops the stored snapshot (for a future "new conversation"
+ *   affordance / a hard reset).
+ * - A deep watch persists committed turns; an emptied history removes the key
+ *   rather than storing `"[]"`.
+ *
+ * Restored turns keep their tool-call parts for display, but `streamChat`
+ * replays history as prose only (`partsToText` in `utils/ai`), so a continued
+ * conversation never re-sends a dangling tool_use across the restore boundary.
+ */
+export declare function usePersistedChat(tableId: () => string | undefined, messages: Ref<UIMessage[]>): {
+    restore: () => void;
+    clear: () => void;
+};

package/dist/runtime/share/use-persisted-chat.js

@@ -0,0 +1,34 @@
+import { watch } from "vue";
+const STORAGE_PREFIX = "shwfed.table.ai-chat.";
+export function usePersistedChat(tableId, messages) {
+  const key = () => `${STORAGE_PREFIX}${tableId()}`;
+  const active = () => Boolean(tableId()) && typeof window !== "undefined";
+  function restore() {
+    if (!active()) return;
+    try {
+      const raw = window.sessionStorage.getItem(key());
+      if (!raw) return;
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) messages.value = parsed;
+    } catch {
+    }
+  }
+  function clear() {
+    if (typeof window === "undefined") return;
+    const id = tableId();
+    if (!id) return;
+    try {
+      window.sessionStorage.removeItem(`${STORAGE_PREFIX}${id}`);
+    } catch {
+    }
+  }
+  watch(messages, (next) => {
+    if (!active()) return;
+    try {
+      if (next.length === 0) window.sessionStorage.removeItem(key());
+      else window.sessionStorage.setItem(key(), JSON.stringify(next));
+    } catch {
+    }
+  }, { deep: true });
+  return { restore, clear };
+}

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,5 +1,7 @@
 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";
@@ -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,98 @@ 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
-    });
-    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;
+    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);
+  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();
+        }
       }
-      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)
-        });
+    });
+    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";
       }
+    });
+    publish();
+    const toolUses = response.content.filter(
+      (b) => b.type === "tool_use"
+    );
+    if (toolUses.length === 0) {
+      return assistant;
     }
-    messages.push({ role: "user", content: results });
+    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
 };