@promptbook/core 0.112.0-12 → 0.112.0-13

package/esm/index.es.js

@@ -28,7 +28,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.112.0-12';
+const PROMPTBOOK_ENGINE_VERSION = '0.112.0-13';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -19795,9 +19795,9 @@ function createTimeoutSystemMessage(extraInstructions) {
     return spaceTrim$1((block) => `
             Timeout scheduling:
             - Use "set_timeout" to wake this same chat thread in the future.
-            - Timers are thread-scoped, not global for the whole agent.
+            - Use "list_timeouts" to review timeouts across all chats for the same user+agent scope.
+            - "cancel_timeout" accepts a timeout id from any chat in this same user+agent scope.
             - When one timeout elapses, you will receive a new user-like message that explicitly says it is a timeout wake-up and includes the \`timeoutId\`.
-            - Use "cancel_timeout" when a previously scheduled timeout is no longer relevant.
             - Do not claim a timer was set or cancelled unless the tool confirms it.
             ${block(extraInstructions)}
         `);
@@ -19858,13 +19858,6 @@ function parseToolExecutionEnvelope(rawValue) {
  * @private internal utility of USE TIMEOUT
  */
 function createDisabledTimeoutResult(action, message) {
-    if (action === 'set') {
-        return {
-            action,
-            status: 'disabled',
-            message,
-        };
-    }
     return {
         action,
         status: 'disabled',
@@ -19891,6 +19884,18 @@ function getTimeoutToolRuntimeAdapterOrDisabledResult(action, runtimeContext) {
     }
 }
 
+/**
+ * Default number of rows returned by `list_timeouts`.
+ *
+ * @private internal USE TIMEOUT constant
+ */
+const DEFAULT_LIST_TIMEOUTS_LIMIT = 20;
+/**
+ * Hard cap for `list_timeouts` page size.
+ *
+ * @private internal USE TIMEOUT constant
+ */
+const MAX_LIST_TIMEOUTS_LIMIT = 100;
 /**
  * Parses and validates `USE TIMEOUT` tool arguments.
  *
@@ -19925,6 +19930,31 @@ const parseTimeoutToolArgs = {
         }
         return { timeoutId };
     },
+    /**
+     * Parses `list_timeouts` input.
+     */
+    list(args) {
+        if (args.includeFinished !== undefined && typeof args.includeFinished !== 'boolean') {
+            throw new PipelineExecutionError(spaceTrim$1(`
+                    Timeout \`includeFinished\` must be a boolean when provided.
+                `));
+        }
+        const parsedLimit = args.limit === undefined ? DEFAULT_LIST_TIMEOUTS_LIMIT : Math.floor(Number(args.limit));
+        if (!Number.isFinite(parsedLimit) || parsedLimit <= 0) {
+            throw new PipelineExecutionError(spaceTrim$1(`
+                    Timeout \`limit\` must be a positive number.
+                `));
+        }
+        if (parsedLimit > MAX_LIST_TIMEOUTS_LIMIT) {
+            throw new PipelineExecutionError(spaceTrim$1(`
+                    Timeout \`limit\` must be at most \`${MAX_LIST_TIMEOUTS_LIMIT}\`.
+                `));
+        }
+        return {
+            includeFinished: args.includeFinished === true,
+            limit: parsedLimit,
+        };
+    },
 };
 
 /**
@@ -19935,6 +19965,7 @@ const parseTimeoutToolArgs = {
 const TimeoutToolNames = {
     set: 'set_timeout',
     cancel: 'cancel_timeout',
+    list: 'list_timeouts',
 };
 
 /**
@@ -20034,6 +20065,35 @@ function createTimeoutToolFunctions() {
                 return JSON.stringify(result);
             }
         },
+        async [TimeoutToolNames.list](args) {
+            const runtimeContext = resolveTimeoutRuntimeContext(args);
+            const { adapter, disabledResult } = getTimeoutToolRuntimeAdapterOrDisabledResult('list', runtimeContext);
+            if (!adapter || disabledResult) {
+                return JSON.stringify(disabledResult);
+            }
+            try {
+                const parsedArgs = parseTimeoutToolArgs.list(args);
+                const listedTimeouts = await adapter.listTimeouts(parsedArgs, runtimeContext);
+                const result = {
+                    action: 'list',
+                    status: 'listed',
+                    items: listedTimeouts.items,
+                    total: listedTimeouts.total,
+                };
+                return createToolExecutionEnvelope({
+                    assistantMessage: listedTimeouts.total === 1 ? 'Found 1 timeout.' : `Found ${listedTimeouts.total} timeouts.`,
+                    toolResult: result,
+                });
+            }
+            catch (error) {
+                const result = {
+                    action: 'list',
+                    status: 'error',
+                    message: error instanceof Error ? error.message : String(error),
+                };
+                return JSON.stringify(result);
+            }
+        },
     };
 }
 
@@ -20067,26 +20127,45 @@ function createTimeoutTools(existingTools = []) {
     if (!tools.some((tool) => tool.name === TimeoutToolNames.cancel)) {
         tools.push({
             name: TimeoutToolNames.cancel,
-            description: 'Cancel one previously scheduled timeout in the current chat thread.',
+            description: 'Cancel one previously scheduled timeout within the same user+agent scope, even if it was set in another chat.',
             parameters: {
                 type: 'object',
                 properties: {
                     timeoutId: {
                         type: 'string',
-                        description: 'Identifier returned earlier by `set_timeout`.',
+                        description: 'Identifier returned earlier by `set_timeout` or `list_timeouts`.',
                     },
                 },
                 required: ['timeoutId'],
             },
         });
     }
+    if (!tools.some((tool) => tool.name === TimeoutToolNames.list)) {
+        tools.push({
+            name: TimeoutToolNames.list,
+            description: 'List scheduled timeouts across all chats for this same user+agent scope so they can be reviewed or cancelled.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    includeFinished: {
+                        type: 'boolean',
+                        description: 'When true, include completed, failed, and cancelled rows in addition to active timeouts.',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Maximum number of rows to return (default 20, max 100).',
+                    },
+                },
+            },
+        });
+    }
     return tools;
 }
 
 /**
  * `USE TIMEOUT` commitment definition.
  *
- * The `USE TIMEOUT` commitment enables thread-scoped timers that wake the same chat later.
+ * The `USE TIMEOUT` commitment enables timeout wake-ups and scoped timeout management.
  *
  * @private [🪔] Maybe export the commitments through some package
  */
@@ -20101,7 +20180,7 @@ class UseTimeoutCommitmentDefinition extends BaseCommitmentDefinition {
      * Short one-line description of `USE TIMEOUT`.
      */
     get description() {
-        return 'Enable thread-scoped timers that can wake the same chat in the future.';
+        return 'Enable timeout wake-ups plus scoped timeout listing/cancellation across chats.';
     }
     /**
      * Icon for this commitment.
@@ -20116,14 +20195,15 @@ class UseTimeoutCommitmentDefinition extends BaseCommitmentDefinition {
         return spaceTrim$1(`
             # USE TIMEOUT
 
-            Enables the agent to schedule thread-scoped timeout wake-ups.
+            Enables timeout wake-ups and timeout management for the same user+agent scope.
 
             ## Key aspects
 
             - The agent uses \`set_timeout\` to schedule a future wake-up in the same chat thread.
             - The tool returns immediately while the timeout is stored and executed by the runtime later.
             - The wake-up arrives as a new user-like timeout message in the same conversation.
-            - The agent can cancel an existing timeout by \`timeoutId\` via \`cancel_timeout\`.
+            - The agent can inspect known timeouts via \`list_timeouts\`.
+            - The agent can cancel an existing timeout by \`timeoutId\` via \`cancel_timeout\`, including timeouts created in another chat.
             - Commitment content is treated as optional timeout policy instructions.
 
             ## Examples
@@ -20152,6 +20232,7 @@ class UseTimeoutCommitmentDefinition extends BaseCommitmentDefinition {
         return {
             [TimeoutToolNames.set]: 'Set timer',
             [TimeoutToolNames.cancel]: 'Cancel timer',
+            [TimeoutToolNames.list]: 'List timers',
         };
     }
     /**