@code-yeongyu/senpi-ai 2026.10.25-4 → 2026.10.26-2

package/dist/utils/assistant-capture.js

@@ -0,0 +1,327 @@
+const captures = new WeakMap();
+const readers = new WeakMap();
+const writers = new WeakMap();
+/** `undefined` until a capture-enabled stream's first push decides it, `null` once decided off. */
+const states = new WeakMap();
+const demanded = new WeakSet();
+const warned = new WeakSet();
+const NO_CHANGE = Object.freeze({});
+let subscribers = 0;
+let capturedAny = false;
+/** While held, every capture-enabled stream whose first push comes after it builds capture records. */
+export function subscribeAssistantCapture() {
+    subscribers++;
+    let held = true;
+    return () => {
+        if (held)
+            subscribers--;
+        held = false;
+    };
+}
+export function setAssistantReader(owner, reader) {
+    readers.set(owner, reader);
+}
+export function setAssistantProgressWriter(owner, writer) {
+    writers.set(owner, writer);
+}
+export function enableAssistantCapture(owner) {
+    if (!states.has(owner))
+        states.set(owner, undefined);
+}
+/** Decided once, at the first push, so a stream never starts capturing midway with partial offsets. */
+function activeState(owner) {
+    const state = states.get(owner);
+    if (state !== undefined || !states.has(owner))
+        return state ?? undefined;
+    const decided = subscribers > 0 || demanded.has(owner)
+        ? { positions: new Map(), metadata: new Map(), insertCopies: new Map(), failedBlocks: new Set() }
+        : null;
+    capturedAny ||= decided !== null;
+    states.set(owner, decided);
+    return decided ?? undefined;
+}
+/** A capture failure never reaches the provider stream: the block loses its records and one warning is logged. */
+function dropCapture(owner, error, state, contentIndex) {
+    if (contentIndex !== undefined)
+        state?.failedBlocks.add(contentIndex);
+    if (warned.has(owner))
+        return;
+    warned.add(owner);
+    console.warn("[assistant-capture] could not build an internal capture record; that block's records are dropped", error);
+}
+export function pushAssistantProgress(owner, progress) {
+    const writer = writers.get(owner);
+    if (!writer)
+        return;
+    // A forwarded record is already a frozen public copy, made by the stream that captured it.
+    if (Object.isFrozen(progress)) {
+        writer(progress);
+        return;
+    }
+    const state = activeState(owner);
+    if (!state || state.failedBlocks.has(progress.contentIndex))
+        return;
+    try {
+        writer(freezeProgress(state, progress));
+    }
+    catch (error) {
+        dropCapture(owner, error, state, progress.contentIndex);
+    }
+}
+function freezeProgress(state, progress) {
+    if (progress.type === "message_tool_arguments_reset")
+        state.positions.set(progress.contentIndex, {
+            offset: progress.rawArgumentPrefix.length,
+            parsedThrough: progress.parsedThrough,
+        });
+    if (progress.type !== "message_block_state")
+        return Object.freeze({ ...progress });
+    const previous = state.insertCopies.get(progress.contentIndex);
+    const current = publicBlock(progress.block);
+    const block = previous !== undefined && sameValue(current, previous) ? previous : freezeCapture(current);
+    if (progress.phase === "insert")
+        state.insertCopies.set(progress.contentIndex, block);
+    else
+        state.insertCopies.delete(progress.contentIndex);
+    return Object.freeze({ ...progress, block });
+}
+/** A text or thinking signature replaced without a public event; an unchanged or empty one records nothing. */
+export function pushAssistantSignature(owner, contentIndex, block, signature) {
+    if (!signature || signature === (block.type === "text" ? block.textSignature : block.thinkingSignature))
+        return;
+    pushAssistantProgress(owner, {
+        type: "message_block_metadata",
+        contentIndex,
+        ...(block.type === "text" ? { textSignature: signature } : { thinkingSignature: signature }),
+    });
+}
+/** A block appended complete with no public event: its unchanged end reuses the insert's frozen copy. */
+export function pushAssistantCompleteBlock(owner, contentIndex, block) {
+    for (const phase of ["insert", "end"])
+        pushAssistantProgress(owner, { type: "message_block_state", contentIndex, phase, block });
+}
+/** Internal consumption is explicit; ordinary iterators are the downgrade boundary. Attached before the first push, it turns capture on. */
+export function assistantRecords(source) {
+    demanded.add(source);
+    const read = readers.get(source);
+    return {
+        [Symbol.asyncIterator]: () => read?.((entry) => ({
+            value: "event" in entry ? entry.event : entry.progress,
+            done: false,
+        })) ?? source[Symbol.asyncIterator](),
+    };
+}
+/** Events only; each progress record goes to `onProgress` as it is read, so a forwarder spends no turn on it. */
+export function assistantEvents(source, onProgress) {
+    const read = readers.get(source);
+    return {
+        [Symbol.asyncIterator]: () => read?.((entry) => {
+            if ("event" in entry)
+                return { value: entry.event, done: false };
+            onProgress(entry.progress);
+            return undefined;
+        }) ?? source[Symbol.asyncIterator](),
+    };
+}
+/** Internal readers address a block by `capture.contentIndex ?? event.contentIndex`; the public index can drift (Google/Vertex). */
+export function getAssistantCapture(event) {
+    return captures.get(event);
+}
+export function isAssistantProgress(event) {
+    return (event.type === "message_block_state" ||
+        event.type === "message_block_metadata" ||
+        event.type === "message_tool_arguments_reset");
+}
+export function freezeCapture(value) {
+    const freeze = (part) => {
+        if (part === null || typeof part !== "object" || Object.isFrozen(part))
+            return;
+        for (const child of Object.values(part))
+            freeze(child);
+        Object.freeze(part);
+    };
+    const copy = structuredClone(value);
+    freeze(copy);
+    return copy;
+}
+/** Only declared public fields survive; provider scratch and symbols never enter a seed. */
+export function publicBlock(block) {
+    const fields = {
+        text: ["type", "text", "audience", "textSignature"],
+        thinking: ["type", "thinking", "thinkingSignature", "redacted", "startedAt", "endedAt"],
+        toolCall: ["type", "id", "name", "arguments", "incomplete", "errorMessage", "thoughtSignature", "namespace"],
+        providerNative: ["type", "subtype", "raw"],
+    };
+    return Object.fromEntries(fields[block.type].filter((key) => key in block).map((key) => [key, Reflect.get(block, key)]));
+}
+/** Structural equality over plain data; any other object counts as changed, so a reused copy is never stale. */
+function sameValue(left, right) {
+    if (left === right)
+        return true;
+    if (!isPlainData(left) || !isPlainData(right) || Array.isArray(left) !== Array.isArray(right))
+        return false;
+    const keys = Object.keys(left);
+    return (keys.length === Object.keys(right).length &&
+        keys.every((key) => Object.hasOwn(right, key) && sameValue(Reflect.get(left, key), Reflect.get(right, key))));
+}
+function isPlainData(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === Array.prototype || prototype === null;
+}
+export function dropAssistantCapture(event) {
+    if (capturedAny)
+        captures.delete(event);
+}
+export function carryAssistantCapture(source, target, terminal) {
+    const capture = captures.get(source);
+    if (!capture)
+        return target;
+    try {
+        captures.set(target, terminal ? terminalCapture(capture, terminal) : capture);
+    }
+    catch (error) {
+        dropCapture(source, error);
+    }
+    return target;
+}
+/** A terminal replaced downstream: its usage and message, plus every scalar that differs from the source terminal. */
+function terminalCapture(capture, terminal) {
+    const metadata = { ...capture.metadata };
+    const previous = capture.message ?? {};
+    for (const key of new Set([...Object.keys(previous), ...Object.keys(terminal)])) {
+        if (key === "content" || key === "usage")
+            continue;
+        const value = Reflect.get(terminal, key);
+        if (!sameValue(value, Reflect.get(previous, key)))
+            metadata[key] = key in terminal ? value : null;
+    }
+    return Object.freeze({
+        usage: frozenUsage(terminal.usage),
+        metadata: freezeCapture(metadata),
+        message: freezeCapture({ ...terminal, content: terminal.content.map(publicBlock) }),
+        ...(capture.rewrittenFrom === undefined ? {} : { rewrittenFrom: capture.rewrittenFrom }),
+    });
+}
+/** Never parses or traverses a block on a delta, including a no-growth delta. */
+export function captureAssistantEvent(owner, event, hint = {}) {
+    const state = activeState(owner);
+    // A relay of a source that captured nothing, or captured a drifted index, gets no record: lack, never wrong.
+    if (!state || captures.has(event) || hint.carried === null || hint.carried?.contentIndex !== undefined)
+        return;
+    const contentIndex = "contentIndex" in event ? (hint.contentIndex ?? event.contentIndex) : undefined;
+    if (contentIndex !== undefined && state.failedBlocks.has(contentIndex))
+        return;
+    try {
+        const capture = buildCapture(state, event, hint);
+        if (capture)
+            captures.set(event, capture);
+    }
+    catch (error) {
+        dropCapture(owner, error, state, contentIndex);
+    }
+}
+function buildCapture(state, event, hint) {
+    const message = event.type === "done" ? event.message : event.type === "error" ? event.error : event.partial;
+    const usage = usageCopy(state, message.usage);
+    if (!("contentIndex" in event)) {
+        return Object.freeze({
+            usage,
+            metadata: changedMetadata(state, message),
+            message: freezeCapture({ ...message, content: message.content.map(publicBlock) }),
+            ...(hint.rewrittenFrom === undefined ? {} : { rewrittenFrom: hint.rewrittenFrom }),
+        });
+    }
+    const index = hint.contentIndex ?? event.contentIndex;
+    const own = index === event.contentIndex ? {} : { contentIndex: index };
+    const carried = hint.carried;
+    if ("delta" in event) {
+        if (carried) {
+            const { parsedThrough } = carried;
+            return Object.freeze({
+                usage,
+                offset: carried.offset,
+                ...(parsedThrough === undefined ? {} : { parsedThrough }),
+            });
+        }
+        const position = state.positions.get(index) ?? { offset: 0, parsedThrough: 0 };
+        const offset = hint.offset ?? position.offset;
+        position.offset = offset + event.delta.length;
+        if (event.type === "toolcall_delta" && event.delta.length > 0) {
+            position.parsedThrough = hint.parsedThrough ?? Math.max(position.parsedThrough, position.offset);
+        }
+        state.positions.set(index, position);
+        return Object.freeze({
+            usage,
+            offset,
+            ...own,
+            ...(event.type === "toolcall_delta" ? { parsedThrough: position.parsedThrough } : {}),
+        });
+    }
+    const metadata = changedMetadata(state, message);
+    if (carried) {
+        const { usage: _usage, metadata: _metadata, message: _message, offset: _offset, ...facts } = carried;
+        return Object.freeze({ ...facts, usage, metadata });
+    }
+    const starts = event.type === "text_start" || event.type === "thinking_start" || event.type === "toolcall_start";
+    const source = event.type === "toolcall_end" ? event.toolCall : message.content[index];
+    // A start announced before its block is appended has no seed to freeze yet.
+    if (starts && source === undefined)
+        return undefined;
+    const block = freezeCapture(publicBlock(source));
+    if (!starts)
+        return Object.freeze({ usage, metadata, block, ...own });
+    const rawArgumentPrefix = hint.rawArgumentPrefix ?? "";
+    const coveredCodeUnits = block.type === "text"
+        ? block.text.length
+        : block.type === "thinking"
+            ? block.thinking.length
+            : rawArgumentPrefix.length;
+    const parsedThrough = hint.parsedThrough ?? 0;
+    state.positions.set(index, { offset: hint.offset ?? coveredCodeUnits, parsedThrough });
+    return Object.freeze({
+        usage,
+        metadata,
+        block,
+        coveredCodeUnits,
+        ...own,
+        ...(block.type === "toolCall" ? { rawArgumentPrefix, parsedThrough } : {}),
+    });
+}
+function usageCopy(state, usage) {
+    if (state.usage !== undefined && sameValue(usage, state.usage))
+        return state.usage;
+    state.usage = frozenUsage(usage);
+    return state.usage;
+}
+function frozenUsage(usage) {
+    return Object.freeze({
+        ...usage,
+        cost: Object.freeze({ ...usage.cost }),
+        ...(usage.contextUsage ? { contextUsage: Object.freeze({ ...usage.contextUsage }) } : {}),
+    });
+}
+/** Scalar message fields changed since the last non-delta capture; the baseline moves only once its copy exists. */
+function changedMetadata(state, message) {
+    const changed = {};
+    for (const key of Object.keys(message)) {
+        if (key === "content" || key === "usage")
+            continue;
+        const value = Reflect.get(message, key);
+        if (!state.metadata.has(key) || state.metadata.get(key) !== value)
+            changed[key] = value;
+    }
+    for (const key of state.metadata.keys())
+        if (!(key in message))
+            changed[key] = null;
+    const frozen = Object.keys(changed).length === 0 ? NO_CHANGE : freezeCapture(changed);
+    for (const key of Object.keys(changed)) {
+        if (key in message)
+            state.metadata.set(key, Reflect.get(message, key));
+        else
+            state.metadata.delete(key);
+    }
+    return frozen;
+}
+//# sourceMappingURL=assistant-capture.js.map

package/dist/utils/event-stream.d.ts

@@ -1,8 +1,14 @@
 import type { AssistantMessage, AssistantMessageEvent } from "../types.ts";
+import { type AssistantProgress, type CaptureHint } from "./assistant-capture.ts";
+type OrderedEntry<T> = {
+    event: T;
+} | {
+    progress: AssistantProgress;
+};
 export declare class EventStream<T, R = T> implements AsyncIterable<T> {
     #private;
     private waiting;
-    private done;
+    protected done: boolean;
     private finalResultPromise;
     private resolveFinalResult;
     private rejectFinalResult;
@@ -11,9 +17,11 @@ export declare class EventStream<T, R = T> implements AsyncIterable<T> {
     constructor(isComplete: (event: T) => boolean, extractResult: (event: T) => R);
     get queue(): T[];
     push(event: T): void;
+    protected enqueueProgress(progress: AssistantProgress): void;
     end(result?: R): void;
     fail(error: unknown): void;
     [Symbol.asyncIterator](): AsyncIterator<T>;
+    protected mapIterator<V>(project: (entry: OrderedEntry<T>) => IteratorResult<V> | undefined): AsyncIterator<V>;
     result(): Promise<R>;
     /**
      * Track a locally executing unit of work (for example a server-requested
@@ -27,8 +35,13 @@ export declare class EventStream<T, R = T> implements AsyncIterable<T> {
     hasPendingLocalWork(): boolean;
 }
 export declare class AssistantMessageEventStream extends EventStream<AssistantMessageEvent, AssistantMessage> {
-    constructor();
+    constructor(options?: {
+        readonly captureBlocks?: boolean;
+    });
+    push(event: AssistantMessageEvent, hint?: CaptureHint): void;
+    [Symbol.asyncIterator](): AsyncIterator<AssistantMessageEvent>;
 }
 /** Factory function for AssistantMessageEventStream (for use in extensions) */
 export declare function createAssistantMessageEventStream(): AssistantMessageEventStream;
+export {};
 //# sourceMappingURL=event-stream.d.ts.map

package/dist/utils/event-stream.js

@@ -1,3 +1,4 @@
+import { captureAssistantEvent, dropAssistantCapture, enableAssistantCapture, setAssistantProgressWriter, setAssistantReader, } from "./assistant-capture.js";
 class FifoQueue {
     constructor() {
         this.incoming = [];
@@ -9,6 +10,9 @@ class FifoQueue {
     enqueue(value) {
         this.incoming.push(value);
     }
+    prepend(value) {
+        this.outgoing.push(value);
+    }
     dequeue() {
         if (this.outgoing.length === 0) {
             while (this.incoming.length > 0) {
@@ -41,7 +45,7 @@ export class EventStream {
         this.finalResultPromise.catch(() => { });
     }
     get queue() {
-        return this.#queue.slice(this.#queueHead);
+        return this.#queue.slice(this.#queueHead).flatMap((entry) => ("event" in entry ? [entry.event] : []));
     }
     #enqueue(event) {
         this.#queue.push(event);
@@ -65,13 +69,19 @@ export class EventStream {
             this.done = true;
             this.resolveFinalResult(this.extractResult(event));
         }
-        // Deliver to waiting consumer or queue it
+        this.#deliver({ event });
+    }
+    enqueueProgress(progress) {
+        if (!this.done)
+            this.#deliver({ progress });
+    }
+    #deliver(entry) {
         const waiter = this.waiting.dequeue();
         if (waiter) {
-            waiter.resolve({ value: event, done: false });
+            waiter.resolve({ value: entry, done: false });
         }
         else {
-            this.#enqueue(event);
+            this.#enqueue(entry);
         }
     }
     end(result) {
@@ -100,10 +110,15 @@ export class EventStream {
         }
     }
     [Symbol.asyncIterator]() {
+        return this.mapIterator((entry) => ("event" in entry ? { value: entry.event, done: false } : undefined));
+    }
+    mapIterator(project) {
         return {
             next: () => {
-                if (this.#queueHead < this.#queue.length) {
-                    return Promise.resolve({ value: this.#dequeue(), done: false });
+                while (this.#queueHead < this.#queue.length) {
+                    const result = project(this.#dequeue());
+                    if (result)
+                        return Promise.resolve(result);
                 }
                 if (this.#failed) {
                     return Promise.reject(this.#error);
@@ -111,7 +126,19 @@ export class EventStream {
                 if (this.done) {
                     return Promise.resolve({ value: undefined, done: true });
                 }
-                return new Promise((resolve, reject) => this.waiting.enqueue({ resolve, reject }));
+                return new Promise((resolve, reject) => {
+                    const waiter = {
+                        reject,
+                        resolve: (next) => {
+                            const result = next.done ? { value: undefined, done: true } : project(next.value);
+                            if (result)
+                                resolve(result);
+                            else
+                                this.waiting.prepend(waiter);
+                        },
+                    };
+                    this.waiting.enqueue(waiter);
+                });
             },
         };
     }
@@ -140,7 +167,7 @@ export class EventStream {
     }
 }
 export class AssistantMessageEventStream extends EventStream {
-    constructor() {
+    constructor(options = {}) {
         super((event) => event.type === "done" || event.type === "error", (event) => {
             if (event.type === "done") {
                 return event.message;
@@ -150,6 +177,28 @@ export class AssistantMessageEventStream extends EventStream {
             }
             throw new Error("Unexpected event type for final result");
         });
+        if (options.captureBlocks)
+            enableAssistantCapture(this);
+        setAssistantProgressWriter(this, (progress) => this.enqueueProgress(progress));
+        // A subclass that replaces iteration (cancellation, snapshots, remapping) stays unaware unless it registers a reader;
+        // one that remaps contentIndex in push must register its own reader too, or progress keeps the unmapped indices.
+        if (new.target.prototype[Symbol.asyncIterator] === AssistantMessageEventStream.prototype[Symbol.asyncIterator])
+            setAssistantReader(this, (project) => this.mapIterator(project));
+    }
+    push(event, hint) {
+        if (this.done)
+            return;
+        captureAssistantEvent(this, event, hint);
+        super.push(event);
+    }
+    [Symbol.asyncIterator]() {
+        return this.mapIterator((entry) => {
+            if (!("event" in entry))
+                return undefined;
+            // Unaware wrappers may snapshot, remap, buffer or discard this event. Never forward its carrier.
+            dropAssistantCapture(entry.event);
+            return { value: entry.event, done: false };
+        });
     }
 }
 /** Factory function for AssistantMessageEventStream (for use in extensions) */

package/dist/utils/tool-argument-coercion.d.ts

@@ -0,0 +1,2 @@
+export declare function coercePrimitiveByType(value: unknown, type: string): unknown;
+//# sourceMappingURL=tool-argument-coercion.d.ts.map

package/dist/utils/tool-argument-coercion.js

@@ -0,0 +1,74 @@
+export function coercePrimitiveByType(value, type) {
+    switch (type) {
+        case "number": {
+            if (value === null) {
+                return 0;
+            }
+            if (typeof value === "string" && value.trim() !== "") {
+                const parsed = Number(value);
+                if (Number.isFinite(parsed)) {
+                    return parsed;
+                }
+            }
+            if (typeof value === "boolean") {
+                return value ? 1 : 0;
+            }
+            return value;
+        }
+        case "integer": {
+            if (value === null) {
+                return 0;
+            }
+            if (typeof value === "string" && value.trim() !== "") {
+                const parsed = Number(value);
+                if (Number.isInteger(parsed)) {
+                    return parsed;
+                }
+            }
+            if (typeof value === "boolean") {
+                return value ? 1 : 0;
+            }
+            return value;
+        }
+        case "boolean": {
+            if (value === null) {
+                return false;
+            }
+            if (typeof value === "string") {
+                if (value === "true") {
+                    return true;
+                }
+                if (value === "false") {
+                    return false;
+                }
+            }
+            if (typeof value === "number") {
+                if (value === 1) {
+                    return true;
+                }
+                if (value === 0) {
+                    return false;
+                }
+            }
+            return value;
+        }
+        case "string": {
+            if (value === null) {
+                return "";
+            }
+            if (typeof value === "number" || typeof value === "boolean") {
+                return String(value);
+            }
+            return value;
+        }
+        case "null": {
+            if (value === "" || value === 0 || value === false) {
+                return null;
+            }
+            return value;
+        }
+        default:
+            return value;
+    }
+}
+//# sourceMappingURL=tool-argument-coercion.js.map

package/dist/utils/tool-argument-validator.d.ts

@@ -0,0 +1,20 @@
+import type { TSchema } from "typebox";
+export interface ToolArgumentValidationError {
+    readonly instancePath: string;
+    readonly keyword: string;
+    readonly message?: string;
+    readonly params: {
+        readonly [key: string]: unknown;
+        readonly missingProperty?: string;
+        readonly requiredProperties?: string[];
+    };
+}
+interface ToolArgumentValidator {
+    (value: unknown): boolean;
+    errors?: readonly ToolArgumentValidationError[] | null;
+}
+/** A protocol may own validation without permitting local argument coercion. */
+export declare function registerToolArgumentValidator(schema: TSchema, validate: ToolArgumentValidator): void;
+export declare function getToolArgumentValidator(schema: TSchema): ToolArgumentValidator | undefined;
+export {};
+//# sourceMappingURL=tool-argument-validator.d.ts.map

package/dist/utils/tool-argument-validator.js

@@ -0,0 +1,9 @@
+const validators = new WeakMap();
+/** A protocol may own validation without permitting local argument coercion. */
+export function registerToolArgumentValidator(schema, validate) {
+    validators.set(schema, validate);
+}
+export function getToolArgumentValidator(schema) {
+    return validators.get(schema);
+}
+//# sourceMappingURL=tool-argument-validator.js.map

package/dist/utils/tool-schema-compat.d.ts

@@ -4,6 +4,11 @@
  * subset that rejects a sibling `type` keyword on schemas that also declare
  * `anyOf` / `oneOf` / `allOf`. This helper removes that redundancy while
  * preserving the schema's semantics.
+ *
+ * This is provider wire adaptation, not an MCP schema conversion or argument
+ * validator. MCP supplies its full schema (boolean roots use the equivalent
+ * allOf container); the original schema and model arguments are never rewritten.
+ * Root-union conversion below is explicitly lossy for object-only providers.
  */
 export type ToolSchemaFlavor = "moonshot-mfjs";
 /**

package/dist/utils/tool-schema-compat.js

@@ -4,6 +4,11 @@
  * subset that rejects a sibling `type` keyword on schemas that also declare
  * `anyOf` / `oneOf` / `allOf`. This helper removes that redundancy while
  * preserving the schema's semantics.
+ *
+ * This is provider wire adaptation, not an MCP schema conversion or argument
+ * validator. MCP supplies its full schema (boolean roots use the equivalent
+ * allOf container); the original schema and model arguments are never rewritten.
+ * Root-union conversion below is explicitly lossy for object-only providers.
  */
 const COMBINER_KEYS = ["anyOf", "oneOf", "allOf"];
 const SCHEMA_MAP_KEYS = ["properties", "patternProperties", "$defs", "definitions"];

package/dist/utils/validation.d.ts

@@ -1,4 +1,5 @@
 import type { Tool, ToolCall } from "../types.ts";
+export { registerToolArgumentValidator } from "./tool-argument-validator.ts";
 /**
  * Finds a tool by name and validates the tool call arguments against its TypeBox schema
  * @param tools Array of tool definitions