@timurproko/a1 0.1.8-dev.472 → 0.1.8-dev.508

package/dist/integrations/pi/engine/message-values.d.ts

@@ -0,0 +1,29 @@
+/** Pure readers over Pi's untyped session messages and the blocks projected from them. */
+import type { OwnedUiModelInfo, OwnedUiThinkingLevel, OwnedUiTranscriptBlock } from "../../../contracts/owned-ui/index.js";
+export declare function stringValue(value: unknown): string | undefined;
+export declare function messageFallbackKey(message: unknown, fallbackIndex: number): string;
+/** A later error may restate a declaration, but cannot make completed arguments incomplete. */
+export declare function retainCompletedArguments(current: OwnedUiTranscriptBlock, next: OwnedUiTranscriptBlock): OwnedUiTranscriptBlock;
+/**
+ * Whether two blocks say the same thing. A block that says what it already said is not a
+ * new revision: the shell renders a block once per revision, so bumping one it did not
+ * need re-renders it for nothing.
+ */
+export declare function sameBlockContent(left: OwnedUiTranscriptBlock, right: OwnedUiTranscriptBlock): boolean;
+export declare function sameValue(left: unknown, right: unknown): boolean;
+export declare function textFromContent(content: unknown): string;
+export declare function assistantContent(content: readonly unknown[]): readonly Record<string, unknown>[];
+export declare function contentImageCount(content: unknown): number;
+export declare function jsonSummary(value: unknown): {
+    readonly summary: string;
+    readonly json: unknown;
+};
+export declare function sanitizeJson(value: unknown, depth?: number): unknown;
+export declare function finiteNumber(value: unknown): number;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function dynamicObject(value: unknown, key?: string): Record<string, unknown>;
+export declare function requireCapability<T>(capability: T | undefined, name: string): T;
+export declare function readModel(value: unknown): OwnedUiModelInfo | null;
+export declare function readThinkingLevel(value: unknown): OwnedUiThinkingLevel;
+export declare function stringProperty(value: unknown, key: string): string | undefined;
+export declare function readStringArray(value: unknown): readonly string[];

package/dist/integrations/pi/engine/message-values.js

@@ -0,0 +1,168 @@
+export function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+export function messageFallbackKey(message, fallbackIndex) {
+    if (!isRecord(message))
+        return `message-unknown-${fallbackIndex}`;
+    const timestamp = typeof message.timestamp === "number" && Number.isSafeInteger(message.timestamp)
+        ? message.timestamp
+        : `index-${fallbackIndex}`;
+    return `message-${stringValue(message.role) ?? "unknown"}-${timestamp}`;
+}
+/** A later error may restate a declaration, but cannot make completed arguments incomplete. */
+export function retainCompletedArguments(current, next) {
+    if (current.toolState?.argsComplete !== true || next.toolState === undefined || next.toolState.argsComplete)
+        return next;
+    return { ...next, toolState: { ...next.toolState, argsComplete: true },
+        ...(next.toolRendering === undefined || current.toolRendering === undefined ? {} : {
+            toolRendering: { ...next.toolRendering, arguments: current.toolRendering.arguments },
+        }),
+        payload: { ...(isRecord(next.payload) ? next.payload : {}), argsComplete: true } };
+}
+/**
+ * Whether two blocks say the same thing. A block that says what it already said is not a
+ * new revision: the shell renders a block once per revision, so bumping one it did not
+ * need re-renders it for nothing.
+ */
+export function sameBlockContent(left, right) {
+    return left.kind === right.kind
+        && left.status === right.status
+        && left.title === right.title
+        && left.text === right.text
+        && sameValue(left.toolState, right.toolState)
+        && sameValue(left.toolRendering, right.toolRendering)
+        && sameValue(left.payload, right.payload)
+        && sameValue(left.imageReferences ?? [], right.imageReferences ?? []);
+}
+export function sameValue(left, right) {
+    if (left === right)
+        return true;
+    if (typeof left !== typeof right || left === null || right === null)
+        return false;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length)
+            return false;
+        return left.every((value, index) => sameValue(value, right[index]));
+    }
+    if (typeof left !== "object")
+        return false;
+    const leftKeys = Object.keys(left);
+    const rightRecord = right;
+    if (leftKeys.length !== Object.keys(rightRecord).length)
+        return false;
+    return leftKeys.every(key => Object.hasOwn(rightRecord, key) && sameValue(left[key], rightRecord[key]));
+}
+export function textFromContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map(item => isRecord(item) && item.type === "text" ? stringValue(item.text) ?? "" : "")
+        .filter(text => text.length > 0)
+        .join("\n");
+}
+export function assistantContent(content) {
+    const result = [];
+    for (const item of content) {
+        if (!isRecord(item))
+            continue;
+        if (item.type === "text")
+            result.push({ type: "text", text: stringValue(item.text) ?? "" });
+        else if (item.type === "thinking") {
+            result.push({
+                type: "thinking",
+                thinking: stringValue(item.thinking) ?? "",
+                ...(item.redacted === true ? { redacted: true } : {}),
+            });
+        }
+        else if (item.type === "toolCall") {
+            result.push({
+                type: "toolCall",
+                id: stringValue(item.id) ?? "",
+                name: stringValue(item.name) ?? "unknown",
+                arguments: sanitizeJson(item.arguments),
+            });
+        }
+    }
+    return result;
+}
+export function contentImageCount(content) {
+    return Array.isArray(content)
+        ? content.filter(item => isRecord(item) && item.type === "image").length
+        : 0;
+}
+export function jsonSummary(value) {
+    const json = sanitizeJson(value);
+    let summary = "";
+    try {
+        summary = JSON.stringify(json);
+    }
+    catch {
+        summary = String(value);
+    }
+    if (summary.length > 512)
+        summary = `${summary.slice(0, 509)}...`;
+    return { summary, json };
+}
+export function sanitizeJson(value, depth = 0) {
+    if (typeof value === "bigint")
+        return value.toString();
+    if (value === null || ["string", "number", "boolean"].includes(typeof value))
+        return value;
+    if (depth >= 8)
+        return "[truncated]";
+    if (Array.isArray(value))
+        return value.slice(0, 100).map(item => sanitizeJson(item, depth + 1));
+    if (isRecord(value)) {
+        const output = {};
+        for (const [key, item] of Object.entries(value).slice(0, 100)) {
+            output[key] = sanitizeJson(item, depth + 1);
+        }
+        return output;
+    }
+    return String(value);
+}
+export function finiteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+export function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+export function dynamicObject(value, key) {
+    const candidate = key === undefined ? value : isRecord(value) ? value[key] : undefined;
+    return isRecord(candidate) ? candidate : {};
+}
+export function requireCapability(capability, name) {
+    if (typeof capability !== "function")
+        throw new Error(`Pi workflow capability is unavailable: ${name}`);
+    return capability;
+}
+export function readModel(value) {
+    if (!isRecord(value))
+        return null;
+    const providerId = stringValue(value.provider) ?? stringValue(value.providerId);
+    const modelId = stringValue(value.id) ?? stringValue(value.modelId);
+    if (!providerId || !modelId)
+        return null;
+    return {
+        providerId,
+        modelId,
+        displayName: stringValue(value.name) ?? modelId,
+    };
+}
+export function readThinkingLevel(value) {
+    return value === "off" || value === "minimal" || value === "low" || value === "medium"
+        || value === "high" || value === "xhigh"
+        ? value
+        : "medium";
+}
+export function stringProperty(value, key) {
+    if (!isRecord(value))
+        return undefined;
+    const item = value[key];
+    return typeof item === "string" && item.length > 0 ? item : undefined;
+}
+export function readStringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}

package/dist/integrations/pi/engine/pending-delivery.d.ts

@@ -6,8 +6,8 @@ export declare function replaceableEventKey(event: OwnedUiEvent): string | null;
 /** Intrusive FIFO + segment index: replacement unlinks in O(1), never changes source ordering. */
 export declare class PendingEngineDelivery {
     #private;
-    private readonly retain?;
-    constructor(retain?: ((event: OwnedUiEvent) => () => void) | undefined);
+    private readonly retain;
+    constructor(retain?: (event: OwnedUiEvent) => () => void);
     get size(): number;
     diagnostics(): {
         pending: number;

package/dist/integrations/pi/engine/pending-delivery.js

@@ -25,7 +25,6 @@ export function replaceableEventKey(event) {
 }
 /** Intrusive FIFO + segment index: replacement unlinks in O(1), never changes source ordering. */
 export class PendingEngineDelivery {
-    retain;
     #replaceable = new Map();
     #head;
     #tail;
@@ -36,9 +35,8 @@ export class PendingEngineDelivery {
     #superseded = 0;
     #peakNodes = 0;
     #peakBytes = 0;
-    constructor(retain) {
-        this.retain = retain;
-    }
+    retain;
+    constructor(retain) { this.retain = retain; }
     get size() { return this.#size; }
     diagnostics() {
         return { pending: this.#size, bytes: this.#bytes, protected: this.#protected,