@pasko70/pibo 2.5.2 → 3.0.1

package/dist/subagents/tool.js

@@ -8,6 +8,7 @@ export const PIBO_AGENT_TOOL_NAMES = [
     "pibo_agents_observe",
     "pibo_agents_kill",
 ];
+export const PIBO_AGENT_SESSION_NAME_MAX_LENGTH = 40;
 function availableAgentDescription(subagent) {
     return subagent.description?.trim() || `Targets profile ${subagent.targetProfile}.`;
 }
@@ -30,6 +31,58 @@ export function formatAvailableAgentsForPrompt(subagents) {
 function resultText(prefix, value) {
     return `${prefix}\n${JSON.stringify(value, null, 2)}`;
 }
+export function normalizePiboAgentSessionName(value) {
+    if (typeof value !== "string")
+        throw new Error("Agent session name is required.");
+    if ([...value].length > PIBO_AGENT_SESSION_NAME_MAX_LENGTH) {
+        throw new Error(`Agent session name must be at most ${PIBO_AGENT_SESSION_NAME_MAX_LENGTH} characters.`);
+    }
+    const normalized = value.trim();
+    if (!normalized)
+        throw new Error("Agent session name must not be empty.");
+    return normalized;
+}
+function preparePiboAgentSessionNameInput(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        throw new Error("Agent session name is required.");
+    }
+    return {
+        ...input,
+        sessionName: normalizePiboAgentSessionName(input.sessionName),
+    };
+}
+function preparePiboAgentToolInput(input) {
+    return preparePiboAgentSessionNameInput(input);
+}
+function preparePiboDeprecatedSubagentToolInput(input) {
+    return preparePiboAgentSessionNameInput(input);
+}
+export function formatAgentObservationsForModel(result) {
+    const includeTools = result.filters.includeTools === true;
+    const toolDetail = result.filters.toolDetail ?? "summary";
+    const lines = [
+        `Agent observations (${result.observations.length}; tools=${includeTools ? toolDetail : "hidden"}; order=${result.filters.order ?? "desc"}; limit=${result.filters.limit ?? 20})`,
+        `nextAfterSequence=${result.nextAfterSequence}; truncated=${result.truncated}`,
+    ];
+    if (result.observations.length === 0) {
+        lines.push("", "No delegated-agent observations matched the filters.");
+        return lines.join("\n");
+    }
+    for (const observation of result.observations) {
+        const scope = [
+            observation.name,
+            observation.threadKey ? `thread=${observation.threadKey}` : undefined,
+            observation.requestId ? `request=${observation.requestId}` : undefined,
+        ].filter(Boolean).join("; ");
+        const event = observation.kind === "tool"
+            ? `${observation.eventType}${observation.toolName ? ` ${observation.toolName}` : ""}`
+            : observation.eventType;
+        lines.push("", `#${observation.sequence} ${scope} — ${event}${observation.isError ? " [error]" : ""}`);
+        if (observation.text)
+            lines.push(observation.text);
+    }
+    return lines.join("\n");
+}
 function normalizeAgentSendMessageResult(result, fallbackRequestId) {
     return {
         ...result,
@@ -55,20 +108,27 @@ export function createAgentToolDefinitions(subagents, controller) {
             name: "pibo_agents_send_message",
             title: "Pibo Agents Send Message",
             description: [
-                "Yielded-only delegated send. Start this tool through pibo_run_start; bounded waits do not limit the child lifetime.",
+                "Yielded-only delegated send with a required sessionName. It must be a nonblank string of at most 40 Unicode code points and is trimmed before use. name selects the configured agent, sessionName is the human-readable child-session title, and threadKey controls conversation reuse. Invalid arguments fail before a run or child session is created. Start this tool through pibo_run_start; bounded waits do not limit the child lifetime.",
                 "Available agents:",
                 catalog,
             ].join("\n"),
-            promptSnippet: "Start pibo_agents_send_message through pibo_run_start. Reuse threadKey to continue its child session, and use run wait/status/read/cancel plus agent observe for lifecycle control.",
+            promptSnippet: "Start pibo_agents_send_message through pibo_run_start. Provide a nonblank sessionName of at most 40 Unicode code points on every call; Pibo trims it and rejects invalid input before creating a run. Follow-up calls update the reused child title without changing identity. Reuse threadKey to continue its child session, and use run wait/status/read/cancel plus agent observe for lifecycle control.",
             executionMode: "parallel",
             inputSchema: Type.Object({
-                name: piboStringEnum(names, { description: "Available delegated agent name" }),
+                name: piboStringEnum(names, { description: "Configured delegated-agent selector; not the child title or reuse key" }),
+                sessionName: Type.String({
+                    description: "Required nonblank human-readable child Pibo Session title, trimmed before use and limited to 40 Unicode code points. Follow-up calls update the title without changing thread identity.",
+                    minLength: 1,
+                    maxLength: PIBO_AGENT_SESSION_NAME_MAX_LENGTH,
+                    pattern: "\\S",
+                }),
                 message: Type.String({ description: "Message to send to the delegated agent" }),
                 threadKey: Type.Optional(Type.String({
-                    description: "Stable key for continuing one delegated-agent conversation. Omit it to create a new child session.",
+                    description: "Stable reuse key for one delegated-agent conversation; independent of sessionName. Omit it to create a new child session.",
                     maxLength: 256,
                 })),
             }),
+            prepareInput: preparePiboAgentToolInput,
             async execute(toolCallId, params, signal, _onUpdate, context) {
                 const subagent = byName.get(params.name);
                 if (!subagent)
@@ -76,10 +136,12 @@ export function createAgentToolDefinitions(subagents, controller) {
                 if (!context.yieldedRunId) {
                     throw new Error("pibo_agents_send_message is yielded-only. Start it through pibo_run_start.");
                 }
+                const preparedParams = preparePiboAgentToolInput(params);
                 const result = normalizeAgentSendMessageResult(await controller.sendMessage({
                     subagent,
-                    message: params.message,
-                    threadKey: params.threadKey,
+                    sessionName: preparedParams.sessionName,
+                    message: preparedParams.message,
+                    threadKey: preparedParams.threadKey,
                     toolCallId,
                     requestId: context.yieldedRunId,
                     parentProvenance: context.getActiveMessage?.()?.provenance,
@@ -105,8 +167,8 @@ export function createAgentToolDefinitions(subagents, controller) {
         definePiboTool({
             name: "pibo_agents_list_agents",
             title: "Pibo Agents List Agents",
-            description: "List available delegated-agent profiles and child agent instances owned by this session.",
-            promptSnippet: "List available delegated agents and existing child instances with their agentId, thread, profile, and running, idle, or killed status.",
+            description: "List available delegated-agent profiles and child agent instances owned by this session, including each current sessionName when available.",
+            promptSnippet: "List available delegated agents and existing child instances with their agentId, current sessionName, threadKey, profile, and running, idle, or killed status.",
             executionMode: "parallel",
             annotations: { readOnly: true },
             inputSchema: Type.Object({}),
@@ -121,8 +183,12 @@ export function createAgentToolDefinitions(subagents, controller) {
         definePiboTool({
             name: "pibo_agents_observe",
             title: "Pibo Agents Observe",
-            description: "Read bounded delegated-agent observations with exact agent, thread, event, kind, time, text, cursor, order, and limit filters.",
-            promptSnippet: "Observe child-agent activity. Array filters use OR within a field and different fields combine with AND. For cursor polling, pass afterSequence from the previous result; pages consume the oldest unseen observations even when order is desc.",
+            description: [
+                "Read completed delegated-agent messages with bounded cursor, identity, event, time, text, order, and limit filters.",
+                "Default: the newest 20 completed assistant messages, with streaming deltas and tools hidden.",
+                "Set includeTools=true to add compact tool calls and terminal results; set toolDetail=full only for bounded diagnostic inspection.",
+            ].join("\n"),
+            promptSnippet: "Observe child-agent progress through completed assistant messages. Defaults: newest 20 messages, no streaming deltas, no duplicate tool progress events, no tools. Set includeTools=true for compact tool call/result summaries, toolDetail=full for bounded raw tool text, or eventTypes/kinds for explicit progress diagnostics. Pass afterSequence from the previous result for cursor polling; cursor pages consume the oldest unseen matches even when order is desc.",
             executionMode: "parallel",
             annotations: { readOnly: true },
             inputSchema: Type.Object({
@@ -130,21 +196,23 @@ export function createAgentToolDefinitions(subagents, controller) {
                 agentIds: Type.Optional(Type.Array(Type.String({ description: "Owned child agentId" }), { maxItems: 50 })),
                 names: Type.Optional(Type.Array(piboStringEnum(names), { maxItems: 50 })),
                 threadKeys: Type.Optional(Type.Array(Type.String(), { maxItems: 50 })),
-                eventTypes: Type.Optional(Type.Array(Type.String({ description: "Exact Pibo output event type" }), { maxItems: 50 })),
-                kinds: Type.Optional(Type.Array(piboStringEnum(["message", "thinking", "tool", "error", "lifecycle", "event"]), { maxItems: 6 })),
+                eventTypes: Type.Optional(Type.Array(Type.String({ description: "Exact Pibo output event type. Explicit filters can retrieve progress events hidden by the default view." }), { maxItems: 50 })),
+                kinds: Type.Optional(Type.Array(piboStringEnum(["message", "thinking", "tool", "error", "lifecycle", "event"], { description: "Optional broad event kinds, including progress events. Omit eventTypes and kinds for the compact default view." }), { maxItems: 6 })),
                 roles: Type.Optional(Type.Array(Type.String({ description: "Exact normalized role, for example assistant" }), { maxItems: 20 })),
                 since: Type.Optional(Type.String({ description: "Inclusive ISO-8601 lower timestamp bound" })),
                 until: Type.Optional(Type.String({ description: "Inclusive ISO-8601 upper timestamp bound" })),
                 textContains: Type.Optional(Type.String({ description: "Case-insensitive substring match against normalized observation text" })),
-                afterSequence: Type.Optional(Type.Integer({ description: "Exclusive live observation cursor. Cursor pages consume the oldest unseen observations; desc reverses only the returned page.", minimum: 0 })),
-                order: Type.Optional(piboStringEnum(["asc", "desc"], { default: "asc" })),
-                limit: Type.Optional(Type.Integer({ description: "Maximum observations to return", minimum: 1, maximum: 200, default: 50 })),
-                includeDetails: Type.Optional(Type.Boolean({ description: "Include the normalized source event in each observation" })),
+                afterSequence: Type.Optional(Type.Integer({ description: "Exclusive live observation cursor. Cursor pages consume the oldest unseen matches; desc reverses only the returned page.", minimum: 0 })),
+                order: Type.Optional(piboStringEnum(["asc", "desc"], { default: "desc", description: "Newest first by default when no cursor is supplied" })),
+                limit: Type.Optional(Type.Integer({ description: "Maximum completed messages or activity records to return. Use 50 explicitly when needed.", minimum: 1, maximum: 200, default: 20 })),
+                includeTools: Type.Optional(Type.Boolean({ description: "Include tools. Default false. With the default message view, true adds tool_call and tool_execution_finished records.", default: false })),
+                toolDetail: Type.Optional(piboStringEnum(["summary", "full"], { default: "summary", description: "Tool text detail when tools are included. summary is compact; full remains bounded to the observation text limit." })),
+                includeDetails: Type.Optional(Type.Boolean({ description: "Include the normalized source event in structured details. Default false; use only for diagnostics.", default: false })),
             }),
             async execute(_toolCallId, params) {
                 const result = controller.observe(params);
                 return {
-                    content: [{ type: "text", text: resultText("Agent observations:", result) }],
+                    content: [{ type: "text", text: formatAgentObservationsForModel(result) }],
                     details: result,
                 };
             },
@@ -198,18 +266,33 @@ export function createSubagentToolDefinitions(subagents, runner) {
         definitions.push(definePiboTool({
             name: toolName,
             title: `Pibo Subagent ${subagent.name}`,
-            description: subagent.description ?? `Send a message to the ${subagent.name} subagent. Use threadKey to continue the same subagent session.`,
-            promptSnippet: subagent.description ?? `Send a message to the ${subagent.name} subagent. Pass the same threadKey when you want to continue the same subagent session.`,
+            description: `${subagent.description ?? `Send a message to the ${subagent.name} subagent.`} sessionName is required, trimmed, nonblank, and limited to 40 Unicode code points.`,
+            promptSnippet: `Provide a nonblank sessionName of at most 40 Unicode code points. ${subagent.description ?? `Send a message to the ${subagent.name} subagent.`} Pass the same threadKey when you want to continue the same subagent session.`,
             executionMode: "parallel",
             inputSchema: Type.Object({
+                sessionName: Type.String({
+                    description: "Required human-readable delegated-session title, trimmed before use and limited to 40 Unicode code points.",
+                    minLength: 1,
+                    maxLength: PIBO_AGENT_SESSION_NAME_MAX_LENGTH,
+                    pattern: "\\S",
+                }),
                 message: Type.String({ description: "Message to send to the subagent" }),
                 threadKey: Type.Optional(Type.String({
                     description: "Stable key for continuing a previous subagent conversation. Omit it to create a new subagent session.",
                     maxLength: 256,
                 })),
             }),
+            prepareInput: preparePiboDeprecatedSubagentToolInput,
             async execute(toolCallId, params, signal) {
-                const result = await runner.runSubagent({ subagent, message: params.message, threadKey: params.threadKey, toolCallId, signal });
+                const preparedParams = preparePiboDeprecatedSubagentToolInput(params);
+                const result = await runner.runSubagent({
+                    subagent,
+                    sessionName: preparedParams.sessionName,
+                    message: preparedParams.message,
+                    threadKey: preparedParams.threadKey,
+                    toolCallId,
+                    signal,
+                });
                 return { content: [{ type: "text", text: result.reply.text }], details: result };
             },
         }));

package/dist/tools/codex-image-artifacts.js

@@ -0,0 +1,24 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { getPiboHome } from "../core/pibo-home.js";
+export function codexImageArtifactRoot() {
+    return join(getPiboHome(), "generated_images");
+}
+export function codexImageArtifactPath(sessionId, toolCallId) {
+    const safeSessionId = sanitizePathPart(sessionId?.trim() || "local");
+    const safeToolCallId = sanitizePathPart(toolCallId || `image_${Date.now()}`);
+    const artifactId = `${safeSessionId}/${safeToolCallId}.png`;
+    return {
+        artifactId,
+        savedPath: join(codexImageArtifactRoot(), safeSessionId, `${safeToolCallId}.png`),
+    };
+}
+export async function saveCodexGeneratedImage(sessionId, toolCallId, b64Json) {
+    const target = codexImageArtifactPath(sessionId, toolCallId);
+    await mkdir(dirname(target.savedPath), { recursive: true });
+    await writeFile(target.savedPath, Buffer.from(b64Json.trim(), "base64"));
+    return target;
+}
+function sanitizePathPart(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 120) || "unknown";
+}

package/dist/tools/codex-image-generation.js

@@ -1,10 +1,10 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { platform, release, arch } from "node:os";
-import { dirname, extname, isAbsolute, join, resolve } from "node:path";
+import { extname, isAbsolute, resolve } from "node:path";
 import { Type } from "typebox";
 import { readPiCredential, resolvePiProviderAuth, } from "../agent-runtimes/pi/credentials.js";
 import { definePiboTool } from "./contract.js";
-import { getPiboHome } from "../core/pibo-home.js";
+import { saveCodexGeneratedImage } from "./codex-image-artifacts.js";
 const OPENAI_CODEX_PROVIDER = "openai-codex";
 const DEFAULT_CODEX_BACKEND_BASE_URL = "https://chatgpt.com/backend-api";
 const CODEX_IMAGE_MODEL = "gpt-image-2";
@@ -141,24 +141,6 @@ function validateImageArgs(params) {
         }
     }
 }
-function sanitizePathPart(value) {
-    return value.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 120) || "unknown";
-}
-function artifactPath(sessionId, toolCallId) {
-    const safeSessionId = sanitizePathPart(sessionId?.trim() || "local");
-    const safeToolCallId = sanitizePathPart(toolCallId || `image_${Date.now()}`);
-    const artifactId = `${safeSessionId}/${safeToolCallId}.png`;
-    return {
-        artifactId,
-        savedPath: join(getPiboHome(), "generated_images", safeSessionId, `${safeToolCallId}.png`),
-    };
-}
-async function saveGeneratedImage(sessionId, toolCallId, b64Json) {
-    const target = artifactPath(sessionId, toolCallId);
-    await mkdir(dirname(target.savedPath), { recursive: true });
-    await writeFile(target.savedPath, Buffer.from(b64Json.trim(), "base64"));
-    return target;
-}
 function truncateErrorBody(text) {
     const compact = text.replace(/\s+/g, " ").trim();
     return compact.length > 1000 ? `${compact.slice(0, 1000)}…` : compact;
@@ -240,7 +222,7 @@ export function createCodexImageGenerationToolDefinition(context = {}, options =
             const auth = await getCodexImageAuth();
             const response = await postCodexImageRequest(endpoint, createRequest(params.prompt, images), auth, signal, options.baseUrl);
             const result = firstImageB64(response);
-            const saved = await saveGeneratedImage(context.piboSessionId, toolCallId, result);
+            const saved = await saveCodexGeneratedImage(context.piboSessionId, toolCallId, result);
             const details = {
                 provider: OPENAI_CODEX_PROVIDER,
                 api: "codex-chatgpt-images",

package/dist/web/channel.js

@@ -40,6 +40,43 @@ function firstHeaderValue(value) {
     const raw = Array.isArray(value) ? value[0] : value;
     return raw?.split(",")[0]?.trim() || undefined;
 }
+function strictAuthorityHostname(rawAuthority) {
+    if (!rawAuthority)
+        return undefined;
+    const authority = rawAuthority.trim();
+    if (!authority || authority.includes(",") || /[\\/@?#\s]/.test(authority))
+        return undefined;
+    try {
+        return new URL(`http://${authority}`).hostname.toLowerCase();
+    }
+    catch {
+        return undefined;
+    }
+}
+function rawRequestHostname(request) {
+    const rawAuthority = request.headers.host;
+    if (Array.isArray(rawAuthority))
+        return undefined;
+    const directHostname = strictAuthorityHostname(rawAuthority);
+    if (!directHostname)
+        return undefined;
+    const forwardedHost = request.headers["x-forwarded-host"];
+    if (Array.isArray(forwardedHost) || forwardedHost?.includes(","))
+        return undefined;
+    const forwardedProto = request.headers["x-forwarded-proto"];
+    if (Array.isArray(forwardedProto) || forwardedProto?.includes(","))
+        return undefined;
+    if (Boolean(forwardedHost) !== Boolean(forwardedProto))
+        return undefined;
+    if (forwardedProto && forwardedProto !== "http" && forwardedProto !== "https")
+        return undefined;
+    if (isLoopbackAddress(request.socket.remoteAddress) &&
+        forwardedHost &&
+        forwardedProto) {
+        return strictAuthorityHostname(forwardedHost);
+    }
+    return directHostname;
+}
 function isLoopbackAddress(address) {
     return address === "::1" || address === "127.0.0.1" || address?.startsWith("127.") === true || address?.startsWith("::ffff:127.") === true;
 }
@@ -240,9 +277,28 @@ export function createWebHostChannel(options = {}) {
         }
     };
     const handleRequest = async (nodeRequest, nodeResponse) => {
+        const requestController = new AbortController();
+        const abortRequest = () => requestController.abort(new Error("HTTP client disconnected"));
+        const abortPrematureResponse = () => {
+            if (!nodeResponse.writableFinished)
+                abortRequest();
+        };
+        nodeRequest.once("aborted", abortRequest);
+        nodeResponse.once("close", abortPrematureResponse);
         try {
             const baseURL = createRequestBaseURL(nodeRequest, host, port, options.canonicalBaseURL);
-            const baseRequest = await nodeRequestToWebRequest(nodeRequest, baseURL);
+            const requestURL = new URL(nodeRequest.url ?? "/", baseURL);
+            const requestHostname = rawRequestHostname(nodeRequest);
+            const ctx = requireContext();
+            const apps = ctx.getWebApps();
+            const hostApp = requestHostname === requestURL.hostname.toLowerCase()
+                ? apps.find((candidate) => candidate.matchesHost?.(requestHostname))
+                : undefined;
+            if (hostApp?.handleNodeRequest) {
+                await hostApp.handleNodeRequest(nodeRequest, nodeResponse, createAppContext(ctx), requestURL);
+                return;
+            }
+            const baseRequest = await nodeRequestToWebRequest(nodeRequest, baseURL, requestController.signal);
             // Inject the TCP socket peer into every request so the local auth
             // plugin can apply the same loopback predicate from `getSession`
             // regardless of whether the call came from a browser cookie, the
@@ -271,13 +327,11 @@ export function createWebHostChannel(options = {}) {
                 await sendResponse(nodeResponse, authResponse);
                 return;
             }
-            const ctx = requireContext();
             const simpleApiResponse = await handleSimpleAgentApiRequest(request, ctx);
             if (simpleApiResponse) {
                 await sendResponse(nodeResponse, simpleApiResponse);
                 return;
             }
-            const apps = ctx.getWebApps();
             const app = apps.find((candidate) => matchPrefix(url.pathname, candidate.mountPath) || matchPrefix(url.pathname, candidate.apiPrefix));
             if (app) {
                 const response = await app.handleRequest(request, createAppContext(ctx));
@@ -302,7 +356,34 @@ export function createWebHostChannel(options = {}) {
         }
         catch (error) {
             const status = error instanceof PiboAuthError || error instanceof PiboWebHttpError ? error.statusCode : 500;
-            await sendResponse(nodeResponse, responseJson({ error: error instanceof Error ? error.message : String(error) }, { status }));
+            if (!nodeResponse.destroyed) {
+                await sendResponse(nodeResponse, responseJson({ error: error instanceof Error ? error.message : String(error) }, { status }));
+            }
+        }
+        finally {
+            nodeRequest.removeListener("aborted", abortRequest);
+            nodeResponse.removeListener("close", abortPrematureResponse);
+        }
+    };
+    const handleUpgrade = async (nodeRequest, socket, head) => {
+        try {
+            const ctx = requireContext();
+            const requestURL = new URL(nodeRequest.url ?? "/", createRequestBaseURL(nodeRequest, host, port, options.canonicalBaseURL));
+            const requestHostname = rawRequestHostname(nodeRequest);
+            const app = requestHostname === requestURL.hostname.toLowerCase()
+                ? ctx.getWebApps().find((candidate) => candidate.matchesHost?.(requestHostname))
+                : undefined;
+            if (!app?.handleUpgrade) {
+                socket.end("HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n");
+                return;
+            }
+            await app.handleUpgrade(nodeRequest, socket, head, createAppContext(ctx), requestURL);
+        }
+        catch (error) {
+            if (!socket.destroyed) {
+                const unauthorized = error instanceof PiboAuthError || error instanceof PiboWebHttpError;
+                socket.end(`HTTP/1.1 ${unauthorized ? 401 : 502} ${unauthorized ? "Unauthorized" : "Bad Gateway"}\r\nConnection: close\r\n\r\n`);
+            }
         }
     };
     return {
@@ -320,6 +401,9 @@ export function createWebHostChannel(options = {}) {
             server = createServer((request, response) => {
                 void handleRequest(request, response);
             });
+            server.on("upgrade", (request, socket, head) => {
+                void handleUpgrade(request, socket, head);
+            });
             server.on("connection", (socket) => {
                 sockets.add(socket);
                 socket.once("close", () => sockets.delete(socket));

package/dist/web/http.js

@@ -44,7 +44,7 @@ export async function readJsonBody(request) {
         throw new PiboWebHttpError("Invalid JSON body", 400);
     }
 }
-export async function nodeRequestToWebRequest(request, baseURL) {
+export async function nodeRequestToWebRequest(request, baseURL, signal) {
     const url = new URL(request.url ?? "/", baseURL);
     const headers = new Headers();
     for (const [key, value] of Object.entries(request.headers)) {
@@ -74,6 +74,7 @@ export async function nodeRequestToWebRequest(request, baseURL) {
         method: request.method,
         headers,
         body,
+        signal,
     });
 }
 export async function sendWebResponse(response, webResponse, options = {}) {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@pasko70/pibo",
-  "version": "2.5.2",
+  "version": "3.0.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@pasko70/pibo",
-      "version": "2.5.2",
+      "version": "3.0.1",
       "workspaces": [
         "packages/workflows"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pasko70/pibo",
-  "version": "2.5.2",
+  "version": "3.0.1",
   "type": "module",
   "workspaces": [
     "packages/workflows"