@loopstack/accessing-tool-results-example-workflow 0.21.0 → 0.21.2

package/README.md

@@ -10,10 +10,10 @@ The Tool Results Example Workflow shows how to retrieve and use data returned by
 
 By using this workflow as a reference, you'll learn how to:
 
-- Access tool results using call IDs via `runtime.tools`
-- Access tool results using call indices
-- Retrieve data from previous transitions
-- Create custom helper functions that access `runtime` for data extraction
+- Call tools using `@InjectTool()` and access their return values directly
+- Store tool results as workflow instance properties for use across transitions
+- Access stored data in later transitions via instance properties
+- Create private helper methods to encapsulate data access logic
 
 This example is useful for developers learning to build data-driven workflows that need to pass information between steps.
 
@@ -25,104 +25,133 @@ See [SETUP.md](./SETUP.md) for installation and setup instructions.
 
 ### Workflow Class
 
-The workflow declares tools, typed runtime, and a helper function:
+The workflow extends `BaseWorkflow` and declares tools via `@InjectTool()`. Tool results are stored as instance properties and accessed across transitions:
 
 ```typescript
 @Workflow({
   uiConfig: __dirname + '/workflow-tool-results.ui.yaml',
 })
-export class WorkflowToolResultsWorkflow {
+export class WorkflowToolResultsWorkflow extends BaseWorkflow {
   @InjectTool() private createValue: CreateValue;
   @InjectTool() private createChatMessage: CreateChatMessage;
 
-  @Runtime()
-  runtime: {
-    tools: {
-      create_some_data: {
-        say_hello: {
-          data: string;
-        };
-      };
-    };
-  };
-
-  @DefineHelper()
-  theMessage(): string {
-    return this.runtime.tools.create_some_data.say_hello.data;
-  }
+  storedMessage?: string;
 }
 ```
 
-### Accessing Tool Results
-
-#### 1. Using Call IDs
+### Key Concepts
 
-Assign a unique `id` to a tool call, then reference it via `runtime.tools.<transition_id>.<call_id>.data`:
+#### 1. Calling Tools and Storing Results
 
-```yaml
-- id: say_hello
-  tool: createValue
-  args:
-    input: 'Hello World.'
+In a transition method, call a tool with `this.tool.call(args)` and store the result as an instance property:
 
-- tool: createChatMessage
-  args:
-    role: 'assistant'
-    content: 'Data from specific call id: {{ runtime.tools.create_some_data.say_hello.data }}'
+```typescript
+@Initial({ to: 'data_created' })
+async createSomeData() {
+  const result = await this.createValue.call({ input: 'Hello World.' });
+  this.storedMessage = result.data as string;
+
+  await this.createChatMessage.call({
+    role: 'assistant',
+    content: `Data from specific call id: ${this.storedMessage}`,
+  });
+
+  await this.createChatMessage.call({
+    role: 'assistant',
+    content: `Data from first tool call: ${this.storedMessage}`,
+  });
+}
 ```
 
-#### 2. Using Call Indices
+The `createValue` tool returns a `ToolResult` object with a `data` property containing the output. This value is stored in `this.storedMessage` for later use.
 
-Access tool results by their position (zero-indexed) within the transition:
+#### 2. Accessing Data Across Transitions
 
-```yaml
-- tool: createChatMessage
-  args:
-    role: 'assistant'
-    content: 'Data from first tool call: {{ runtime.tools.create_some_data.0.data }}'
+Instance properties persist across transitions. In a subsequent `@Final` method, the stored data is still available:
+
+```typescript
+@Final({ from: 'data_created' })
+async accessData() {
+  await this.createChatMessage.call({
+    role: 'assistant',
+    content: `Data from previous transition: ${this.storedMessage}`,
+  });
+
+  await this.createChatMessage.call({
+    role: 'assistant',
+    content: `Data access using custom helper: ${this.theMessage()}`,
+  });
+}
 ```
 
-#### 3. Across Transitions
+#### 3. Private Helper Methods
 
-Tool results persist and can be accessed from subsequent transitions using the same `runtime.tools` patterns:
+Define private methods on the workflow class to encapsulate data access logic:
 
-```yaml
-# In a later transition
-- id: access_data
-  from: data_created
-  to: end
-  call:
-    - tool: createChatMessage
-      args:
-        role: 'assistant'
-        content: 'Data from previous transition: {{ runtime.tools.create_some_data.say_hello.data }}'
+```typescript
+private theMessage(): string {
+  return this.storedMessage!;
+}
 ```
 
-#### 4. Using Helper Functions
+These are standard TypeScript methods -- no decorator needed. Call them from any transition method using `this.theMessage()`.
 
-Define custom helper functions in your workflow class that access `this.runtime` directly:
+### Complete Workflow
 
 ```typescript
-@DefineHelper()
-theMessage(): string {
-  return this.runtime.tools.create_some_data.say_hello.data;
-}
-```
+import { BaseWorkflow, Final, Initial, InjectTool, Workflow } from '@loopstack/common';
+import { CreateChatMessage } from '@loopstack/create-chat-message-tool';
+import { CreateValue } from '@loopstack/create-value-tool';
 
-Then use them in your YAML configuration (no arguments needed):
+@Workflow({
+  uiConfig: __dirname + '/workflow-tool-results.ui.yaml',
+})
+export class WorkflowToolResultsWorkflow extends BaseWorkflow {
+  @InjectTool() private createValue: CreateValue;
+  @InjectTool() private createChatMessage: CreateChatMessage;
+
+  storedMessage?: string;
+
+  @Initial({ to: 'data_created' })
+  async createSomeData() {
+    const result = await this.createValue.call({ input: 'Hello World.' });
+    this.storedMessage = result.data as string;
+
+    await this.createChatMessage.call({
+      role: 'assistant',
+      content: `Data from specific call id: ${this.storedMessage}`,
+    });
 
-```yaml
-- tool: createChatMessage
-  args:
-    role: 'assistant'
-    content: 'Data access using custom helper: {{ theMessage }}'
+    await this.createChatMessage.call({
+      role: 'assistant',
+      content: `Data from first tool call: ${this.storedMessage}`,
+    });
+  }
+
+  @Final({ from: 'data_created' })
+  async accessData() {
+    await this.createChatMessage.call({
+      role: 'assistant',
+      content: `Data from previous transition: ${this.storedMessage}`,
+    });
+
+    await this.createChatMessage.call({
+      role: 'assistant',
+      content: `Data access using custom helper: ${this.theMessage()}`,
+    });
+  }
+
+  private theMessage(): string {
+    return this.storedMessage!;
+  }
+}
 ```
 
 ## Dependencies
 
 This workflow uses the following Loopstack modules:
 
-- `@loopstack/core` - Core framework functionality
+- `@loopstack/common` - Base classes, decorators, and tool injection
 - `@loopstack/create-chat-message-tool` - Provides `CreateChatMessage` tool
 - `@loopstack/create-value-tool` - Provides `CreateValue` tool
 

package/package.json

@@ -10,7 +10,7 @@
     "tool",
     "workflow"
   ],
-  "version": "0.21.0",
+  "version": "0.21.2",
   "license": "Apache-2.0",
   "author": {
     "name": "Jakob Klippel",
@@ -31,11 +31,11 @@
     "watch": "nest build --watch"
   },
   "dependencies": {
-    "@loopstack/common": "^0.25.0",
-    "@loopstack/core": "^0.25.0",
-    "@loopstack/create-chat-message-tool": "^0.21.0",
-    "@loopstack/create-value-tool": "^0.21.0",
-    "@nestjs/common": "^11.1.14",
+    "@loopstack/common": "^0.25.1",
+    "@loopstack/core": "^0.25.1",
+    "@loopstack/create-chat-message-tool": "^0.21.2",
+    "@loopstack/create-value-tool": "^0.21.2",
+    "@nestjs/common": "^11.1.19",
     "zod": "^4.3.6"
   },
   "files": [
@@ -51,7 +51,12 @@
     "rootDir": "src",
     "testRegex": ".*\\.spec\\.ts$",
     "transform": {
-      "^.+\\.ts$": "ts-jest"
+      "^.+\\.ts$": [
+        "ts-jest",
+        {
+          "tsconfig": "tsconfig.spec.json"
+        }
+      ]
     },
     "collectCoverageFrom": [
       "**/*.(t|j)s"