@pasko70/pibo 1.1.0 → 1.2.0

package/dist/apps/chat/output-compactor.js

@@ -0,0 +1,126 @@
+import { assistantOutputKey, isLiveOnlyOutputEvent, thinkingOutputKey, toolOutputKey } from "./output-event-policy.js";
+export class OutputCompactor {
+    assistantBuffers = new Map();
+    thinkingBuffers = new Map();
+    toolSnapshots = new Map();
+    compact(event) {
+        const persistedEvents = [];
+        const snapshots = [];
+        switch (event.type) {
+            case "assistant_delta": {
+                const key = assistantOutputKey(event);
+                const previous = this.assistantBuffers.get(key);
+                const text = `${previous?.text ?? ""}${event.text}`;
+                this.assistantBuffers.set(key, { event, text });
+                snapshots.push({ ...event, text });
+                break;
+            }
+            case "assistant_message": {
+                const key = assistantOutputKey(event);
+                const buffered = this.assistantBuffers.get(key);
+                this.assistantBuffers.delete(key);
+                persistedEvents.push({ ...event, text: event.text || buffered?.text || "" });
+                break;
+            }
+            case "thinking_started": {
+                const key = thinkingOutputKey(event);
+                this.thinkingBuffers.set(key, { base: event, text: "" });
+                persistedEvents.push(event);
+                break;
+            }
+            case "thinking_delta": {
+                const key = thinkingOutputKey(event);
+                const previous = this.thinkingBuffers.get(key);
+                const text = `${previous?.text ?? ""}${event.text}`;
+                this.thinkingBuffers.set(key, { base: previous?.base ?? event, text });
+                snapshots.push({ ...event, text });
+                break;
+            }
+            case "thinking_finished": {
+                const key = thinkingOutputKey(event);
+                const buffered = this.thinkingBuffers.get(key);
+                this.thinkingBuffers.delete(key);
+                persistedEvents.push({ ...event, text: event.text || buffered?.text || "" });
+                break;
+            }
+            case "tool_execution_updated": {
+                this.toolSnapshots.set(toolOutputKey(event), event);
+                snapshots.push(event);
+                break;
+            }
+            case "tool_execution_finished": {
+                this.toolSnapshots.delete(toolOutputKey(event));
+                persistedEvents.push(event);
+                break;
+            }
+            case "message_finished":
+            case "session_error": {
+                persistedEvents.push(...this.flushForBoundary(event));
+                persistedEvents.push(event);
+                break;
+            }
+            default:
+                if (!isLiveOnlyOutputEvent(event))
+                    persistedEvents.push(event);
+                break;
+        }
+        return { liveEvents: [event], persistedEvents, snapshots };
+    }
+    snapshotsForSession(piboSessionId) {
+        const snapshots = [];
+        for (const buffer of this.assistantBuffers.values()) {
+            if (buffer.event.piboSessionId === piboSessionId)
+                snapshots.push({ ...buffer.event, text: buffer.text });
+        }
+        for (const buffer of this.thinkingBuffers.values()) {
+            if (buffer.base.piboSessionId !== piboSessionId)
+                continue;
+            if (buffer.base.type === "thinking_delta")
+                snapshots.push({ ...buffer.base, text: buffer.text });
+            else
+                snapshots.push({ ...buffer.base, type: "thinking_delta", text: buffer.text });
+        }
+        for (const event of this.toolSnapshots.values()) {
+            if (event.piboSessionId === piboSessionId)
+                snapshots.push(event);
+        }
+        return snapshots;
+    }
+    flushForBoundary(event) {
+        const flushed = [];
+        for (const [key, buffer] of Array.from(this.assistantBuffers.entries())) {
+            if (!matchesBoundary(buffer.event, event))
+                continue;
+            this.assistantBuffers.delete(key);
+            flushed.push({
+                type: "assistant_message",
+                piboSessionId: buffer.event.piboSessionId,
+                eventId: buffer.event.eventId,
+                assistantIndex: buffer.event.assistantIndex,
+                contentIndex: buffer.event.contentIndex,
+                text: buffer.text,
+            });
+        }
+        for (const [key, buffer] of Array.from(this.thinkingBuffers.entries())) {
+            if (!matchesBoundary(buffer.base, event))
+                continue;
+            this.thinkingBuffers.delete(key);
+            flushed.push({
+                type: "thinking_finished",
+                piboSessionId: buffer.base.piboSessionId,
+                eventId: buffer.base.eventId,
+                thinkingIndex: "thinkingIndex" in buffer.base ? buffer.base.thinkingIndex : undefined,
+                contentIndex: buffer.base.contentIndex,
+                text: buffer.text,
+            });
+        }
+        return flushed;
+    }
+}
+function matchesBoundary(bufferEvent, boundary) {
+    if (bufferEvent.piboSessionId !== boundary.piboSessionId)
+        return false;
+    if (boundary.type === "session_error")
+        return !boundary.eventId || bufferEvent.eventId === boundary.eventId;
+    return bufferEvent.eventId === boundary.eventId;
+}

package/dist/apps/chat/output-event-policy.js

@@ -0,0 +1,17 @@
+export function isLiveOnlyOutputEvent(event) {
+    return event.type === "assistant_delta" || event.type === "thinking_delta" || event.type === "tool_execution_updated";
+}
+export function isPersistableOutputEvent(event) {
+    return !isLiveOnlyOutputEvent(event);
+}
+export function assistantOutputKey(event) {
+    const partIndex = event.assistantIndex ?? event.contentIndex ?? 0;
+    return [event.piboSessionId, event.eventId ?? "", partIndex].join(":");
+}
+export function thinkingOutputKey(event) {
+    const partIndex = event.thinkingIndex ?? event.contentIndex ?? 0;
+    return [event.piboSessionId, event.eventId ?? "", partIndex].join(":");
+}
+export function toolOutputKey(event) {
+    return [event.piboSessionId, event.eventId ?? "", event.toolCallId].join(":");
+}

package/dist/apps/chat/project-workflow-human-actions.js

@@ -0,0 +1,347 @@
+import { responseJson } from "../../web/http.js";
+import { sanitizeWorkflowDiagnostics } from "./workflow-persistence.js";
+export function projectWorkflowPendingHumanActionFromToken(token, humanActionOptions) {
+    const diagnostics = [];
+    const availableActions = token.actions.map((action, index) => {
+        const registered = humanActionOptions.find((option) => option.id === action.id);
+        if (!registered) {
+            diagnostics.push({
+                code: "WorkflowGraphError.unknownHumanActionRef",
+                message: `Workflow wait token '${token.id}' references human action '${action.id}', but it is not registered in the Workflow Registry.`,
+                severity: "error",
+                path: `$.waitToken.actions.${index}.id`,
+                registryRef: action.id,
+                hint: "Resolve waits with registered approve/reject/resume/cancel action refs only.",
+            });
+        }
+        if (registered && action.kind && action.kind !== registered.kind) {
+            diagnostics.push({
+                code: "WorkflowGraphError.humanActionKindMismatch",
+                message: `Workflow wait token '${token.id}' action '${action.id}' declares kind '${action.kind}', but the registry defines kind '${registered.kind}'.`,
+                severity: "error",
+                path: `$.waitToken.actions.${index}.kind`,
+                registryRef: action.id,
+                hint: "Keep wait-token action refs aligned with their registered action definitions.",
+            });
+        }
+        return {
+            id: action.id,
+            kind: action.kind ?? registered?.kind ?? "unknown",
+            displayName: registered?.displayName ?? action.id,
+            ...(registered?.description ? { description: registered.description } : {}),
+            paramsSchema: registered?.paramsSchema ?? null,
+            registered: Boolean(registered),
+        };
+    });
+    return {
+        waitTokenId: token.id,
+        workflowRunId: token.workflowRunId,
+        ...(token.nodeAttemptId ? { nodeAttemptId: token.nodeAttemptId } : {}),
+        ...(token.humanNodeId ? { humanNodeId: token.humanNodeId } : {}),
+        prompt: token.prompt,
+        ...(token.schema ? { schema: token.schema } : {}),
+        status: "pending",
+        payloadRequirements: {
+            required: Boolean(token.schema),
+            ...(token.schema ? { schema: token.schema } : {}),
+            description: token.schema
+                ? "Resume requires a JSON payload that matches this wait token schema."
+                : "Approve, reject, resume, and cancel do not require a payload for this wait token.",
+        },
+        availableActions,
+        diagnostics,
+        createdAt: token.createdAt,
+        ...(token.expiresAt ? { expiresAt: token.expiresAt } : {}),
+    };
+}
+export function projectWorkflowHumanActionLifecyclePayload(request) {
+    const payload = { waitTokenId: request.waitTokenId };
+    if (request.actionId)
+        payload.actionId = request.actionId;
+    if (request.kind)
+        payload.kind = request.kind;
+    return payload;
+}
+export function projectWorkflowHumanActionSubmittedLifecyclePayload(waitTokenId, action) {
+    const payload = {
+        waitTokenId,
+        kind: action.kind,
+        decision: action.kind === "cancel" ? "cancelled" : "resumed",
+    };
+    if (action.actionId)
+        payload.actionId = action.actionId;
+    return payload;
+}
+export function normalizeProjectWorkflowHumanActionBody(body) {
+    const diagnostics = [];
+    const waitTokenId = typeof body.waitTokenId === "string" && body.waitTokenId.trim() ? body.waitTokenId.trim() : undefined;
+    const actionId = typeof body.actionId === "string" && body.actionId.trim() ? body.actionId.trim() : undefined;
+    const kind = typeof body.kind === "string" && body.kind.trim() ? body.kind.trim() : undefined;
+    if (!waitTokenId) {
+        diagnostics.push({
+            code: "WorkflowRuntimeError.waitTokenIdRequired",
+            message: "Human action requests must include a waitTokenId.",
+            severity: "error",
+            path: "$.waitTokenId",
+            hint: "Submit a pending wait token returned by Project workflow inspection.",
+        });
+    }
+    if (!actionId && !kind) {
+        diagnostics.push({
+            code: "WorkflowRuntimeError.humanActionRequired",
+            message: "Human action requests must include an actionId or action kind.",
+            severity: "error",
+            path: "$.actionId",
+            hint: "Use one of the wait token's registered approve/reject/resume/cancel actions.",
+        });
+    }
+    if (body.payload !== undefined && !isJsonValue(body.payload)) {
+        diagnostics.push({
+            code: "WorkflowRuntimeError.invalidHumanActionPayload",
+            message: "Human action payload must be valid JSON data.",
+            severity: "error",
+            path: "$.payload",
+            hint: "Submit a JSON value that matches the wait token payload requirements.",
+        });
+    }
+    if (!waitTokenId)
+        return { diagnostics };
+    return {
+        request: {
+            waitTokenId,
+            ...(actionId ? { actionId } : {}),
+            ...(kind ? { kind } : {}),
+            ...(body.payload !== undefined && isJsonValue(body.payload) ? { payload: body.payload } : {}),
+        },
+        diagnostics,
+    };
+}
+export function validateProjectWorkflowHumanActionRequest(input) {
+    const checkedAt = new Date().toISOString();
+    const diagnostics = [];
+    if (!input.waitToken) {
+        diagnostics.push({
+            code: "WorkflowRuntimeError.unknownWaitToken",
+            message: `Workflow wait token '${input.request.waitTokenId}' does not exist.`,
+            severity: "error",
+            path: "$.waitTokenId",
+            hint: "Refresh the Project run view and submit one of its pending wait tokens.",
+        });
+        return { diagnostics, httpStatus: 404, checkedAt };
+    }
+    if (input.waitToken.projectId !== input.projectSession.projectId || input.waitToken.piboSessionId !== input.projectSession.piboSessionId || input.waitToken.workflowRunId !== input.projectSession.workflowRunId) {
+        diagnostics.push({
+            code: "WorkflowRuntimeError.waitTokenSessionMismatch",
+            message: `Workflow wait token '${input.waitToken.id}' does not belong to this Project workflow session.`,
+            severity: "error",
+            path: "$.waitTokenId",
+            registryRef: input.waitToken.id,
+            hint: "Use only wait tokens shown in the selected Project run view.",
+        });
+        return { diagnostics, httpStatus: 403, checkedAt };
+    }
+    if (input.waitToken.status !== "pending") {
+        diagnostics.push({
+            code: "WorkflowRuntimeError.waitTokenNotPending",
+            message: `Workflow wait token '${input.waitToken.id}' is '${input.waitToken.status}' and cannot accept another human action.`,
+            severity: "error",
+            path: "$.waitToken.status",
+            registryRef: input.waitToken.id,
+            hint: "Human wait tokens can only be resolved once while pending.",
+        });
+        return { diagnostics, httpStatus: 409, checkedAt };
+    }
+    if (input.waitToken.expiresAt && Date.parse(input.waitToken.expiresAt) <= Date.parse(checkedAt)) {
+        diagnostics.push({
+            code: "WorkflowRuntimeError.waitTokenExpired",
+            message: `Workflow wait token '${input.waitToken.id}' expired at ${input.waitToken.expiresAt}.`,
+            severity: "error",
+            path: "$.waitToken.expiresAt",
+            registryRef: input.waitToken.id,
+            hint: "Create a new human wait or handle the timeout before submitting an action.",
+        });
+        return { diagnostics, httpStatus: 409, checkedAt, expiredAt: input.waitToken.expiresAt };
+    }
+    const actionRef = input.request.actionId
+        ? input.waitToken.actions.find((action) => action.id === input.request.actionId)
+        : input.waitToken.actions.find((action) => action.kind === input.request.kind);
+    if (!actionRef) {
+        diagnostics.push({
+            code: "WorkflowRuntimeError.humanActionUnavailable",
+            message: input.request.actionId
+                ? `Workflow wait token '${input.waitToken.id}' does not offer human action '${input.request.actionId}'.`
+                : `Workflow wait token '${input.waitToken.id}' does not offer a human action of kind '${input.request.kind ?? "<missing>"}'.`,
+            severity: "error",
+            path: input.request.actionId ? "$.actionId" : "$.kind",
+            ...(input.request.actionId ? { registryRef: input.request.actionId } : {}),
+            hint: "Use one of the wait token's available action refs.",
+        });
+        return { diagnostics, httpStatus: 422, checkedAt };
+    }
+    const registered = input.humanActionOptions.find((option) => option.id === actionRef.id);
+    if (!registered) {
+        diagnostics.push({
+            code: "WorkflowGraphError.unknownHumanActionRef",
+            message: `Workflow wait token '${input.waitToken.id}' references human action '${actionRef.id}', but it is not registered in the Workflow Registry.`,
+            severity: "error",
+            path: "$.waitToken.actions",
+            registryRef: actionRef.id,
+            hint: "Register or select a known approve/reject/resume/cancel human action before accepting it.",
+        });
+        return { diagnostics, httpStatus: 422, checkedAt, actionRef };
+    }
+    if (actionRef.kind && actionRef.kind !== registered.kind) {
+        diagnostics.push({
+            code: "WorkflowGraphError.humanActionKindMismatch",
+            message: `Workflow wait token '${input.waitToken.id}' action '${actionRef.id}' declares kind '${actionRef.kind}', but the registry defines kind '${registered.kind}'.`,
+            severity: "error",
+            path: "$.waitToken.actions",
+            registryRef: actionRef.id,
+            hint: "Keep wait-token action refs aligned with their registered action definitions.",
+        });
+    }
+    if (input.request.kind && input.request.kind !== registered.kind) {
+        diagnostics.push({
+            code: "WorkflowRuntimeError.humanActionKindMismatch",
+            message: `Requested human action kind '${input.request.kind}' does not match registered action '${registered.id}' kind '${registered.kind}'.`,
+            severity: "error",
+            path: "$.kind",
+            registryRef: registered.id,
+            hint: "Submit the kind returned by the wait token action list.",
+        });
+    }
+    if (registered.kind === "resume" && input.waitToken.schema) {
+        validateWorkflowHumanActionPayloadAgainstSchema(input.request.payload, input.waitToken.schema, "$.payload", diagnostics, {
+            registryRef: registered.id,
+            waitTokenId: input.waitToken.id,
+        });
+    }
+    return {
+        diagnostics,
+        httpStatus: diagnostics.length ? 422 : 200,
+        checkedAt,
+        actionRef,
+        actionKind: registered.kind,
+    };
+}
+export function projectWorkflowHumanActionRuntimeDiagnostic(error, waitTokenId) {
+    const message = error instanceof Error ? error.message : String(error);
+    let code = "WorkflowRuntimeError.humanActionRejected";
+    if (/not found/i.test(message))
+        code = "WorkflowRuntimeError.unknownWaitToken";
+    else if (/does not belong/i.test(message))
+        code = "WorkflowRuntimeError.waitTokenSessionMismatch";
+    else if (/expired/i.test(message))
+        code = "WorkflowRuntimeError.waitTokenExpired";
+    else if (/cannot be resolved again|not pending/i.test(message))
+        code = "WorkflowRuntimeError.waitTokenNotPending";
+    else if (/does not offer/i.test(message))
+        code = "WorkflowRuntimeError.humanActionUnavailable";
+    return {
+        code,
+        message,
+        severity: "error",
+        path: "$.waitTokenId",
+        registryRef: waitTokenId,
+        hint: "Refresh the Project run view and retry with a currently pending wait token/action ref.",
+    };
+}
+export function projectWorkflowHumanActionDiagnosticResponse(message, diagnostics, status, waitToken, humanActionOptions) {
+    return responseJson({
+        error: message,
+        diagnostics: sanitizeWorkflowDiagnostics(diagnostics),
+        ...(waitToken?.status === "pending" ? { waitToken: projectWorkflowPendingHumanActionFromToken(waitToken, humanActionOptions) } : {}),
+    }, { status });
+}
+function validateWorkflowHumanActionPayloadAgainstSchema(value, schema, path, diagnostics, context) {
+    const typeNames = readParamsSchemaTypes(schema.type);
+    if (typeNames.length && !typeNames.some((typeName) => workflowParamValueMatchesType(value, typeName))) {
+        diagnostics.push({
+            code: "WorkflowRuntimeError.invalidHumanActionPayload",
+            message: `Resume payload for wait token '${context.waitTokenId}' does not match schema type at '${path}'.`,
+            severity: "error",
+            path,
+            registryRef: context.registryRef,
+            hint: "Submit a resume payload matching the wait token schema before the action is accepted.",
+        });
+        return;
+    }
+    if (isJsonObject(value)) {
+        const required = Array.isArray(schema.required) ? schema.required.filter((entry) => typeof entry === "string") : [];
+        for (const requiredKey of required) {
+            if (Object.hasOwn(value, requiredKey))
+                continue;
+            diagnostics.push({
+                code: "WorkflowRuntimeError.invalidHumanActionPayload",
+                message: `Resume payload for wait token '${context.waitTokenId}' is missing required field '${requiredKey}'.`,
+                severity: "error",
+                path: workflowParamsChildPath(path, requiredKey),
+                registryRef: context.registryRef,
+                hint: "Add the required resume payload field before submitting the action.",
+            });
+        }
+        const properties = isJsonObject(schema.properties) ? schema.properties : {};
+        for (const [key, propertyValue] of Object.entries(value)) {
+            const propertySchema = properties[key];
+            if (isJsonObject(propertySchema)) {
+                validateWorkflowHumanActionPayloadAgainstSchema(propertyValue, propertySchema, workflowParamsChildPath(path, key), diagnostics, context);
+            }
+            else if (schema.additionalProperties === false) {
+                diagnostics.push({
+                    code: "WorkflowRuntimeError.invalidHumanActionPayload",
+                    message: `Resume payload for wait token '${context.waitTokenId}' includes field '${key}', which is not allowed by the wait token schema.`,
+                    severity: "error",
+                    path: workflowParamsChildPath(path, key),
+                    registryRef: context.registryRef,
+                    hint: "Remove fields not declared by the wait token payload schema.",
+                });
+            }
+        }
+    }
+    if (Array.isArray(value) && isJsonObject(schema.items)) {
+        value.forEach((item, index) => validateWorkflowHumanActionPayloadAgainstSchema(item, schema.items, `${path}.${index}`, diagnostics, context));
+    }
+}
+function isJsonValue(value) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean" ||
+        (typeof value === "number" && Number.isFinite(value))) {
+        return true;
+    }
+    if (Array.isArray(value))
+        return value.every(isJsonValue);
+    if (typeof value === "object")
+        return Object.values(value).every(isJsonValue);
+    return false;
+}
+function isJsonObject(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function readParamsSchemaTypes(value) {
+    if (typeof value === "string")
+        return [value];
+    if (Array.isArray(value))
+        return value.filter((entry) => typeof entry === "string");
+    return [];
+}
+function workflowParamValueMatchesType(value, typeName) {
+    if (typeName === "string")
+        return typeof value === "string";
+    if (typeName === "number")
+        return typeof value === "number" && Number.isFinite(value);
+    if (typeName === "integer")
+        return Number.isInteger(value);
+    if (typeName === "boolean")
+        return typeof value === "boolean";
+    if (typeName === "object")
+        return isJsonObject(value);
+    if (typeName === "array")
+        return Array.isArray(value);
+    if (typeName === "null")
+        return value === null;
+    return true;
+}
+function workflowParamsChildPath(path, key) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? `${path}.${key}` : `${path}[${JSON.stringify(key)}]`;
+}