@pasko70/pibo 1.9.7 → 1.9.9

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

@@ -1,347 +0,0 @@
-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)}]`;
-}

package/dist/apps/chat/project-workflow-sessions.js

@@ -1,260 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { isPiboThinkingLevel } from "../../core/thinking.js";
-import { PiboWebHttpError } from "../../web/http.js";
-import { hashWorkflowDefinitionJson, sanitizeWorkflowDiagnostics, } from "./workflow-persistence.js";
-import { workflowVersionPickerOptionFromCatalogRecord, } from "./workflow-catalog.js";
-const PROJECT_WORKFLOW_SESSION_CREATE_FIELDS = new Set([
-    "profile",
-    "workflowId",
-    "workflowVersion",
-    "title",
-    "inputValues",
-    "promptOverrides",
-    "model",
-    "thinkingLevel",
-    "fastMode",
-]);
-const PROJECT_WORKFLOW_SESSION_DISALLOWED_FIELDS = new Map([
-    ["agentProfileOverrides", "Agent profile overrides are not supported for V2 workflow sessions"],
-    ["profileOverrides", "Agent profile overrides are not supported for V2 workflow sessions"],
-    ["profileOverride", "Agent profile overrides are not supported for V2 workflow sessions"],
-    ["nodeProfileOverrides", "Agent profile overrides are not supported for V2 workflow sessions"],
-    ["retryLimit", "Retry limit overrides are not supported for V2 workflow sessions"],
-    ["retryLimits", "Retry limit overrides are not supported for V2 workflow sessions"],
-    ["maxRetries", "Retry limit overrides are not supported for V2 workflow sessions"],
-    ["retryCount", "Retry limit overrides are not supported for V2 workflow sessions"],
-    ["handlerOverrides", "Handler overrides are not supported for V2 workflow sessions"],
-    ["handlerOverride", "Handler overrides are not supported for V2 workflow sessions"],
-    ["adapterOverrides", "Adapter overrides are not supported for V2 workflow sessions"],
-    ["adapterOverride", "Adapter overrides are not supported for V2 workflow sessions"],
-    ["guardOverrides", "Guard overrides are not supported for V2 workflow sessions"],
-    ["guardOverride", "Guard overrides are not supported for V2 workflow sessions"],
-    ["nodeOverrides", "Arbitrary node overrides are not supported for V2 workflow sessions"],
-    ["overrides", "Arbitrary overrides are not supported for V2 workflow sessions"],
-    ["options", "Arbitrary options are not supported for V2 workflow sessions"],
-    ["arbitraryOptions", "Arbitrary options are not supported for V2 workflow sessions"],
-]);
-export function normalizeProjectWorkflowSessionConfiguration(body, definition) {
-    assertProjectWorkflowSessionCreateFields(body);
-    const inputValues = normalizeProjectWorkflowInputValues(body.inputValues);
-    const promptOverrideEligibleNodeIds = workflowPromptOverrideEligibleNodeIds(definition);
-    const promptOverrides = normalizeProjectWorkflowPromptOverrides(body.promptOverrides, promptOverrideEligibleNodeIds);
-    const model = normalizeWorkflowSessionModel(body.model);
-    const thinkingLevel = normalizeThinkingLevel(body.thinkingLevel, "thinkingLevel");
-    const fastMode = normalizeOptionalBoolean(body.fastMode, "fastMode");
-    return {
-        inputValues,
-        promptOverrides,
-        promptOverrideEligibleNodeIds,
-        overrideScopes: {
-            promptOverrides: "eligible_agent_node",
-            model: "workflow",
-            thinkingLevel: "workflow",
-            fastMode: "workflow",
-        },
-        ...(model ? { model } : {}),
-        ...(thinkingLevel ? { thinkingLevel } : {}),
-        ...(fastMode !== undefined ? { fastMode } : {}),
-    };
-}
-export function createProjectWorkflowSessionSnapshot(input) {
-    const baseDefinition = cloneJsonObject(input.baseDefinition);
-    const effectiveDefinition = applyProjectWorkflowPromptOverrides(baseDefinition, input.configuration.promptOverrides);
-    const baseDefinitionHash = hashWorkflowDefinitionJson(baseDefinition);
-    const effectiveDefinitionHash = hashWorkflowDefinitionJson(effectiveDefinition);
-    const now = new Date().toISOString();
-    return {
-        id: `wfs_${randomUUID()}`,
-        schemaVersion: 1,
-        createdAt: now,
-        createdBy: input.webSession.authSession.identity.userId,
-        projectId: input.project.id,
-        piboSessionId: input.session.id,
-        workflow: {
-            id: input.workflow.id,
-            version: input.workflow.version,
-            source: input.workflow.source,
-            title: input.workflow.title,
-            ...(input.workflow.description ? { description: input.workflow.description } : {}),
-            tags: [...input.workflow.tags],
-            baseDefinitionHash,
-            effectiveDefinitionHash,
-        },
-        baseDefinition,
-        effectiveDefinition,
-        inputValues: cloneJsonObject(input.configuration.inputValues),
-        promptOverrides: { ...input.configuration.promptOverrides },
-        overridePolicy: {
-            promptEligibility: "metadata.sessionOverrides.prompt===true-and-direct-promptTemplate",
-            eligiblePromptNodeIds: [...input.configuration.promptOverrideEligibleNodeIds],
-            modelScope: input.configuration.overrideScopes.model,
-            thinkingLevelScope: input.configuration.overrideScopes.thinkingLevel,
-            fastModeScope: input.configuration.overrideScopes.fastMode,
-        },
-        ...(input.configuration.model ? { model: input.configuration.model } : {}),
-        ...(input.configuration.thinkingLevel ? { thinkingLevel: input.configuration.thinkingLevel } : {}),
-        ...(input.configuration.fastMode !== undefined ? { fastMode: input.configuration.fastMode } : {}),
-        promptAssetPins: [],
-        validation: workflowValidationSnapshot(input.validation),
-        deletedDefinitionFallback: {
-            title: input.workflow.title,
-            workflowId: input.workflow.id,
-            workflowVersion: input.workflow.version,
-            effectiveDefinitionHash,
-        },
-    };
-}
-export function workflowVersionFromSnapshot(snapshot) {
-    return workflowVersionPickerOptionFromCatalogRecord({
-        id: snapshot.workflow.id,
-        version: snapshot.workflow.version,
-        title: snapshot.workflow.title ?? snapshot.workflow.id,
-        ...(snapshot.workflow.description ? { description: snapshot.workflow.description } : {}),
-        source: snapshot.workflow.source,
-        status: "published",
-        tags: [...snapshot.workflow.tags],
-    });
-}
-export function createProjectWorkflowRunCurrent(definition) {
-    const initialNodeIds = workflowInitialNodeIds(definition);
-    return {
-        status: "running",
-        initialNodeIds,
-        ...(initialNodeIds.length === 1 ? { nodeId: initialNodeIds[0] } : {}),
-    };
-}
-function assertProjectWorkflowSessionCreateFields(body) {
-    if (!body || typeof body !== "object" || Array.isArray(body))
-        throw new PiboWebHttpError("Invalid JSON body", 400);
-    for (const key of Object.keys(body)) {
-        const disallowedMessage = PROJECT_WORKFLOW_SESSION_DISALLOWED_FIELDS.get(key);
-        if (disallowedMessage)
-            throw new PiboWebHttpError(disallowedMessage, 400);
-        if (!PROJECT_WORKFLOW_SESSION_CREATE_FIELDS.has(key)) {
-            throw new PiboWebHttpError(`Unsupported workflow session creation field: ${key}`, 400);
-        }
-    }
-}
-function normalizeProjectWorkflowInputValues(value) {
-    if (value === undefined || value === null)
-        return {};
-    if (!isJsonObject(value))
-        throw new PiboWebHttpError("inputValues must be a JSON object", 400);
-    return value;
-}
-function normalizeProjectWorkflowPromptOverrides(value, eligibleNodeIds) {
-    if (value === undefined || value === null)
-        return {};
-    if (!isJsonObject(value))
-        throw new PiboWebHttpError("promptOverrides must be a JSON object keyed by eligible node id", 400);
-    const eligible = new Set(eligibleNodeIds);
-    const promptOverrides = {};
-    for (const [nodeId, prompt] of Object.entries(value)) {
-        if (!nodeId.trim())
-            throw new PiboWebHttpError("promptOverrides cannot contain an empty node id", 400);
-        if (!eligible.has(nodeId)) {
-            throw new PiboWebHttpError(`Node '${nodeId}' is not eligible for prompt overrides in this workflow version`, 400);
-        }
-        if (typeof prompt !== "string") {
-            throw new PiboWebHttpError(`Prompt override for node '${nodeId}' must be a string`, 400);
-        }
-        promptOverrides[nodeId] = prompt;
-    }
-    return promptOverrides;
-}
-function normalizeWorkflowSessionModel(value) {
-    if (value === undefined || value === null)
-        return undefined;
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        throw new PiboWebHttpError("model must be an object", 400);
-    const keys = Object.keys(value);
-    const unsupportedKey = keys.find((key) => key !== "provider" && key !== "id");
-    if (unsupportedKey)
-        throw new PiboWebHttpError(`model contains unsupported field: ${unsupportedKey}`, 400);
-    return normalizeModelProfile(value, "model");
-}
-function normalizeOptionalBoolean(value, fieldName) {
-    if (value === undefined || value === null)
-        return undefined;
-    if (typeof value !== "boolean")
-        throw new PiboWebHttpError(`${fieldName} must be a boolean`, 400);
-    return value;
-}
-function normalizeThinkingLevel(value, fieldName) {
-    if (value === undefined || value === null)
-        return undefined;
-    if (typeof value !== "string" || !isPiboThinkingLevel(value)) {
-        throw new PiboWebHttpError(`${fieldName} must be one of off, minimal, low, medium, high, xhigh, max`, 400);
-    }
-    return value;
-}
-function normalizeModelProfile(value, fieldName) {
-    if (value === undefined || value === null)
-        return undefined;
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        throw new PiboWebHttpError(`${fieldName} must be an object`, 400);
-    }
-    const raw = value;
-    if (typeof raw.provider !== "string" || typeof raw.id !== "string") {
-        throw new PiboWebHttpError(`${fieldName} must include provider and id`, 400);
-    }
-    const provider = raw.provider.trim();
-    const id = raw.id.trim();
-    if (!provider || !id) {
-        throw new PiboWebHttpError(`${fieldName} must include provider and id`, 400);
-    }
-    return { provider, id };
-}
-function workflowPromptOverrideEligibleNodeIds(definition) {
-    const nodes = definition.nodes;
-    if (!isJsonObject(nodes))
-        return [];
-    return Object.entries(nodes)
-        .filter(([, node]) => isWorkflowPromptOverrideEligibleNode(node))
-        .map(([nodeId]) => nodeId)
-        .sort();
-}
-function isWorkflowPromptOverrideEligibleNode(value) {
-    if (!isJsonObject(value))
-        return false;
-    const metadata = isJsonObject(value.metadata) ? value.metadata : undefined;
-    const sessionOverrides = metadata && isJsonObject(metadata.sessionOverrides) ? metadata.sessionOverrides : undefined;
-    return value.kind === "agent"
-        && value.runtime === "pibo"
-        && typeof value.promptTemplate === "string"
-        && sessionOverrides?.prompt === true;
-}
-function applyProjectWorkflowPromptOverrides(definition, promptOverrides) {
-    const effectiveDefinition = cloneJsonObject(definition);
-    const nodes = isJsonObject(effectiveDefinition.nodes) ? effectiveDefinition.nodes : undefined;
-    if (!nodes)
-        return effectiveDefinition;
-    for (const [nodeId, promptTemplate] of Object.entries(promptOverrides)) {
-        const node = nodes[nodeId];
-        if (isJsonObject(node)) {
-            nodes[nodeId] = { ...node, promptTemplate };
-        }
-    }
-    return effectiveDefinition;
-}
-function workflowValidationSnapshot(validation) {
-    return {
-        ...validation.validation,
-        validatedAt: validation.validation.checkedAt,
-        diagnostics: sanitizeWorkflowDiagnostics(validation.diagnostics),
-    };
-}
-function workflowInitialNodeIds(definition) {
-    if (typeof definition.initial === "string" && definition.initial.trim())
-        return [definition.initial.trim()];
-    if (Array.isArray(definition.initial)) {
-        return definition.initial.filter((nodeId) => typeof nodeId === "string" && Boolean(nodeId.trim())).map((nodeId) => nodeId.trim());
-    }
-    return [];
-}
-function cloneJsonObject(value) {
-    return JSON.parse(JSON.stringify(value));
-}
-function isJsonObject(value) {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}

package/dist/apps/chat/provider-auth-actions.js

@@ -1,43 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { completeLogin, getLoginStatus, removeLogin, setApiKey, startLogin } from "../../auth/login-actions.js";
-import { PiboWebHttpError, responseJson } from "../../web/http.js";
-function isJsonObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-export function isProviderAuthAction(action) {
-    return action === "login.status" || action === "login.start" || action === "login.complete" || action === "login.apikey" || action === "logout";
-}
-export async function executeProviderAuthAction(action, params) {
-    const input = isJsonObject(params) ? params : {};
-    const provider = typeof input.provider === "string" ? input.provider : undefined;
-    if (action === "login.status")
-        return { providers: getLoginStatus(provider) };
-    if (!provider)
-        throw new PiboWebHttpError(`${action} requires params.provider`, 400);
-    if (action === "login.start")
-        return await startLogin(provider);
-    if (action === "login.complete") {
-        if (input.code !== undefined && typeof input.code !== "string")
-            throw new PiboWebHttpError("login.complete params.code must be a string when provided", 400);
-        if (typeof input.state !== "string" || input.state.length === 0)
-            throw new PiboWebHttpError("login.complete requires params.state", 400);
-        return await completeLogin(provider, input.code, input.state);
-    }
-    if (action === "login.apikey") {
-        if (typeof input.apiKey !== "string" || input.apiKey.length === 0)
-            throw new PiboWebHttpError("login.apikey requires params.apiKey", 400);
-        return setApiKey(provider, input.apiKey);
-    }
-    if (action === "logout")
-        return removeLogin(provider);
-    throw new PiboWebHttpError(`Unsupported provider auth action ${action}`, 400);
-}
-export function providerAuthActionResponse(input) {
-    return responseJson({
-        type: "execution_result",
-        piboSessionId: input.piboSessionId ?? "",
-        eventId: randomUUID(),
-        action: input.action,
-        result: input.result,
-    });
-}