@output.ai/core 0.5.5 → 0.5.7

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/bin/healthcheck.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+/*
+Healthcheck
+
+Send a "ping" query to the catalog workflow; exit with 0 if result is "pong", 1 otherwise.
+*/
+
+import { Connection, Client } from '@temporalio/client';
+
+const address = process.env.TEMPORAL_ADDRESS;
+const namespace = process.env.TEMPORAL_NAMESPACE ?? 'default';
+const apiKey = process.env.TEMPORAL_API_KEY;
+const catalogId = process.env.OUTPUT_CATALOG_ID ?? 'main';
+
+const state = { connection: null };
+
+const code = await ( async () => {
+  try {
+    state.connection = await Connection.connect( { address, tls: Boolean( apiKey ), apiKey } );
+    const client = new Client( { connection: state.connection, namespace } );
+    const handle = client.workflow.getHandle( catalogId );
+    const response = await handle.query( 'ping' );
+    console.log( `Query response: ${response}` );
+    return response === 'pong' ? 0 : 1;
+  } catch ( error ) {
+    console.error( 'Healthcheck error', error );
+    return 1;
+  } finally {
+    if ( state.connection ) {
+      await state.connection.close().catch( () => {} );
+    }
+  }
+} )();
+
+process.exit( code );

package/bin/healthcheck.spec.js

@@ -0,0 +1,90 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const closeMock = vi.fn().mockResolvedValue( undefined );
+const connectionMock = { close: closeMock };
+
+const queryMock = vi.fn();
+const getHandleMock = vi.fn().mockReturnValue( { query: queryMock } );
+const ClientMock = vi.fn().mockImplementation( () => ( {
+  workflow: { getHandle: getHandleMock }
+} ) );
+const connectMock = vi.fn().mockResolvedValue( connectionMock );
+
+vi.mock( '@temporalio/client', () => ( {
+  Connection: { connect: connectMock },
+  Client: ClientMock
+} ) );
+
+describe( 'bin/healthcheck', () => {
+  const exitMock = vi.fn();
+  const originalExit = process.exit;
+
+  beforeEach( () => {
+    vi.clearAllMocks();
+    process.exit = exitMock;
+    process.env.TEMPORAL_ADDRESS = 'localhost:7233';
+    process.env.TEMPORAL_NAMESPACE = 'default';
+    process.env.OUTPUT_CATALOG_ID = 'test-catalog';
+    delete process.env.TEMPORAL_API_KEY;
+  } );
+
+  afterEach( () => {
+    process.exit = originalExit;
+  } );
+
+  it( 'exits 0 when catalog ping returns "pong"', async () => {
+    queryMock.mockResolvedValue( 'pong' );
+    vi.resetModules();
+    await import( './healthcheck.mjs' );
+    expect( connectMock ).toHaveBeenCalledWith( {
+      address: 'localhost:7233',
+      tls: false,
+      apiKey: undefined
+    } );
+    expect( ClientMock ).toHaveBeenCalledWith( { connection: connectionMock, namespace: 'default' } );
+    expect( getHandleMock ).toHaveBeenCalledWith( 'test-catalog' );
+    expect( queryMock ).toHaveBeenCalledWith( 'ping' );
+    expect( exitMock ).toHaveBeenCalledWith( 0 );
+    expect( closeMock ).toHaveBeenCalled();
+  } );
+
+  it( 'uses TLS and apiKey when TEMPORAL_API_KEY is set', async () => {
+    process.env.TEMPORAL_API_KEY = 'secret';
+    queryMock.mockResolvedValue( 'pong' );
+    vi.resetModules();
+    await import( './healthcheck.mjs' );
+    expect( connectMock ).toHaveBeenCalledWith( {
+      address: 'localhost:7233',
+      tls: true,
+      apiKey: 'secret'
+    } );
+    expect( exitMock ).toHaveBeenCalledWith( 0 );
+  } );
+
+  it( 'uses default namespace and catalog id when env unset', async () => {
+    delete process.env.TEMPORAL_NAMESPACE;
+    delete process.env.OUTPUT_CATALOG_ID;
+    queryMock.mockResolvedValue( 'pong' );
+    vi.resetModules();
+    await import( './healthcheck.mjs' );
+    expect( ClientMock ).toHaveBeenCalledWith( { connection: connectionMock, namespace: 'default' } );
+    expect( getHandleMock ).toHaveBeenCalledWith( 'main' );
+    expect( exitMock ).toHaveBeenCalledWith( 0 );
+  } );
+
+  it( 'exits 1 when catalog ping returns non-pong', async () => {
+    queryMock.mockResolvedValue( 'nope' );
+    vi.resetModules();
+    await import( './healthcheck.mjs' );
+    expect( exitMock ).toHaveBeenCalledWith( 1 );
+    expect( closeMock ).toHaveBeenCalled();
+  } );
+
+  it( 'exits 1 when query throws', async () => {
+    queryMock.mockRejectedValue( new Error( 'connection refused' ) );
+    vi.resetModules();
+    await import( './healthcheck.mjs' );
+    expect( exitMock ).toHaveBeenCalledWith( 1 );
+    expect( closeMock ).toHaveBeenCalled();
+  } );
+} );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/core",
-  "version": "0.5.5",
+  "version": "0.5.7",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {
@@ -23,10 +23,8 @@
   ],
   "bin": {
     "output-worker": "./bin/worker.sh",
-    "outputai": "./bin/worker.sh"
-  },
-  "scripts": {
-    "worker": "node ./src/worker/index.js"
+    "outputai": "./bin/worker.sh",
+    "output-healthcheck": "./bin/healthcheck.mjs"
   },
   "dependencies": {
     "@aws-sdk/client-s3": "3.913.0",
@@ -34,6 +32,9 @@
     "@babel/parser": "7.28.4",
     "@babel/traverse": "7.28.4",
     "@babel/types": "7.28.4",
+    "@temporalio/activity": "1.13.1",
+    "@temporalio/client": "1.13.1",
+    "@temporalio/common": "1.13.1",
     "@temporalio/worker": "1.13.1",
     "@temporalio/workflow": "1.13.1",
     "redis": "5.8.3",
@@ -55,5 +56,8 @@
     "#async_storage": "./src/async_storage.js",
     "#temporal_options": "./src/temporal_options.js",
     "#internal_activities": "./src/internal_activities/index.js"
+  },
+  "scripts": {
+    "worker": "node ./src/worker/index.js"
   }
-}
+}

package/src/interface/evaluation_result.d.ts

@@ -158,3 +158,16 @@ export class EvaluationBooleanResult extends EvaluationResult {
    */
   constructor( args: EvaluationResultArgs<boolean> );
 }
+
+/**
+ * An evaluation result where the value is a verdict (pass, partial, fail)
+ * @extends EvaluationResult
+ */
+export class EvaluationVerdictResult extends EvaluationResult {
+  /**
+   * @constructor
+   * @param args - See {@link EvaluationResultArgs} for full parameter documentation.
+   * @param args.value - The verdict: 'pass', 'partial', or 'fail'.
+   */
+  constructor( args: EvaluationResultArgs<'pass' | 'partial' | 'fail'> );
+}

package/src/interface/evaluation_result.js

@@ -200,3 +200,16 @@ export class EvaluationBooleanResult extends EvaluationResult {
 export class EvaluationNumberResult extends EvaluationResult {
   static valueSchema = z.number();
 };
+
+/**
+ * An evaluation result that uses a verdict value (pass, partial, fail)
+ * @extends EvaluationResult
+ * @property {'pass' | 'partial' | 'fail'} value - The evaluation verdict
+ * @constructor
+ * @param {object} args
+ * @param {'pass' | 'partial' | 'fail'} args.value - The verdict value
+ * @see EvaluationResult#constructor for other parameters (confidence, reasoning)
+ */
+export class EvaluationVerdictResult extends EvaluationResult {
+  static valueSchema = z.enum( [ 'pass', 'partial', 'fail' ] );
+};

package/src/interface/index.js

@@ -1,4 +1,10 @@
-import { EvaluationStringResult, EvaluationNumberResult, EvaluationBooleanResult, EvaluationFeedback } from './evaluation_result.js';
+import {
+  EvaluationStringResult,
+  EvaluationNumberResult,
+  EvaluationBooleanResult,
+  EvaluationVerdictResult,
+  EvaluationFeedback
+} from './evaluation_result.js';
 import { evaluator } from './evaluator.js';
 import { step } from './step.js';
 import { workflow } from './workflow.js';
@@ -12,6 +18,7 @@ export {
   EvaluationNumberResult,
   EvaluationStringResult,
   EvaluationBooleanResult,
+  EvaluationVerdictResult,
   EvaluationFeedback,
   executeInParallel,
   sendHttpRequest,

package/src/interface/workflow.d.ts

@@ -51,7 +51,7 @@ export type WorkflowContext<
      *
      * @returns True if a continue-as-new is suggested for the current run; otherwise false.
      */
-    isContinueAsNewSuggested: () => boolean
+    isContinueAsNewSuggested: () => boolean,
   },
 
   /**

package/src/interface/workflow.js

@@ -75,8 +75,7 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
       // validation comes after setting memo to have that info already set for interceptor even if validations fail
       validateWithSchema( inputSchema, input, `Workflow ${name} input` );
 
-      // binds the methods called in the code that Webpack loader will add, they will exposed via "this"
-      const output = await fn.call( {
+      const dispatchers = {
         invokeStep: async ( stepName, input, options ) => steps[`${name}#${stepName}`]( input, options ),
         invokeSharedStep: async ( stepName, input, options ) => steps[`${SHARED_STEP_PREFIX}#${stepName}`]( input, options ),
         invokeEvaluator: async ( evaluatorName, input, options ) => steps[`${name}#${evaluatorName}`]( input, options ),
@@ -90,7 +89,7 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
          * @param {object} extra
          * @param {boolean} extra.detached
          * @param {import('@temporalio/workflow').ActivityOptions} extra.options
-         * @returns
+         * @returns {Promise<unknown>}
          */
         startWorkflow: async ( childName, input, extra = {} ) =>
           executeChild( childName, {
@@ -100,11 +99,12 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
             memo: {
               executionContext,
               parentId: workflowId,
-              // new configuration for activities of the child workflow, this will be omitted so it will use what that workflow have defined
               ...( extra?.options?.activityOptions && { activityOptions: deepMerge( activityOptions, extra.options.activityOptions ) } )
             }
           } )
-      }, input, context );
+      };
+
+      const output = await fn.call( dispatchers, input, context );
 
       validateWithSchema( outputSchema, output, `Workflow ${name} output` );
 

package/src/interface/workflow.spec.js

@@ -447,34 +447,6 @@ describe( 'workflow()', () => {
     } );
   } );
 
-  describe( 'context.control', () => {
-    it( 'exposes info.workflowId and control/info namespaces when not in workflow context', async () => {
-      inWorkflowContextMock.mockReturnValue( false );
-      const { workflow } = await import( './workflow.js' );
-
-      const wf = workflow( {
-        name: 'control_wf',
-        description: 'Control',
-        inputSchema: z.object( {} ),
-        outputSchema: z.object( {
-          workflowId: z.string(),
-          hasControl: z.boolean(),
-          hasInfo: z.boolean()
-        } ),
-        fn: async ( _, context ) => ( {
-          workflowId: context.info?.workflowId,
-          hasControl: 'control' in context,
-          hasInfo: 'info' in context
-        } )
-      } );
-
-      const result = await wf( {} );
-      expect( result.workflowId ).toBe( 'test-workflow' );
-      expect( result.hasControl ).toBe( true );
-      expect( result.hasInfo ).toBe( true );
-    } );
-  } );
-
   describe( 'error handling (root workflow)', () => {
     it( 'rethrows error from fn and rejects with same message', async () => {
       const { workflow } = await import( './workflow.js' );

package/src/utils/index.d.ts

@@ -33,6 +33,14 @@ export function throws( error: Error ): void;
  */
 export function setMetadata( target: object, value: object ): void;
 
+/**
+ * Read metadata previously attached via setMetadata.
+ *
+ * @param target - The function or object to read metadata from.
+ * @returns The metadata object, or null if none is attached.
+ */
+export function getMetadata( target: Function ): { name: string; description?: string; type?: string } | null;
+
 /** Represents a {Response} serialized to plain object  */
 export type SerializedFetchResponse = {
   /** The response url */

package/src/utils/resolve_invocation_dir.js

@@ -8,8 +8,10 @@ const transformSeparators = path => path.replaceAll( '/', SEP );
 const defaultIgnorePaths = [
   '/@output.ai/core/',
   '/@output.ai/llm/',
+  '/@output.ai/evals/',
   '/sdk/core/',
   '/sdk/llm/',
+  '/sdk/evals/',
   'node:internal/',
   'evalmachine.',
   'webpack/bootstrap'

package/src/utils/utils.js

@@ -37,6 +37,13 @@ export const throws = e => {
 export const setMetadata = ( target, values ) =>
   Object.defineProperty( target, METADATA_ACCESS_SYMBOL, { value: values, writable: false, enumerable: false, configurable: false } );
 
+/**
+ * Read metadata previously attached via setMetadata
+ * @param {Function} target
+ * @returns {object|null}
+ */
+export const getMetadata = target => target[METADATA_ACCESS_SYMBOL] ?? null;
+
 /**
  * Returns true if string value is stringbool and true
  * @param {string} v

package/src/worker/bundler_options.js

@@ -6,6 +6,17 @@ const workerDir = __dirname; // sdk/core/src/worker
 const interfaceDir = join( __dirname, '..', 'interface' );
 
 export const webpackConfigHook = config => {
+  // Prefer the "output-workflow-bundle" export condition when resolving packages.
+  // Packages that transitively depend on Node.js built-ins (which can't exist in the
+  // Temporal workflow bundle) can provide an alternative entry point under this condition
+  // that excludes the offending code paths. Packages without this condition fall through
+  // to the standard "import" / "module" / "default" conditions as normal.
+  config.resolve = config.resolve ?? {};
+  config.resolve.conditionNames = [
+    'output-workflow-bundle',
+    ...( config.resolve.conditionNames ?? [ 'import', 'module', 'webpack', 'default' ] )
+  ];
+
   config.module = config.module ?? { };
   config.module.rules = config.module.rules ?? [];
 

package/src/worker/catalog_workflow/workflow.js

@@ -10,8 +10,12 @@ import { defineQuery, setHandler, condition, defineUpdate } from '@temporalio/wo
 export default async function catalogWorkflow( catalog ) {
   const state = { canEnd: false };
 
+  // Returns the catalog
   setHandler( defineQuery( 'get' ), () => catalog );
 
+  // Politely respond to a ping
+  setHandler( defineQuery( 'ping' ), () => 'pong' );
+
   // Listen to this update to complete the workflow
   setHandler( defineUpdate( 'complete' ), () => state.canEnd = true );
 

package/src/worker/webpack_loaders/tools.js

@@ -295,19 +295,46 @@ export const resolveNameFromOptions = ( optionsNode, consts, errorMessagePrefix
   throw new Error( `${errorMessagePrefix}: Missing required name property` ); // No name field found
 };
 
+/**
+ * Resolve a name from the first argument of a factory call.
+ * Handles two patterns:
+ * - String literal first arg: `verify('name', fn)` → returns 'name'
+ * - Identifier referencing top-level const: `verify(NAME, fn)` → resolves const
+ * - Object with name property: `evaluator({ name: '...' })` → delegates to resolveNameFromOptions
+ *
+ * @param {import('@babel/types').Expression} argNode - First argument to the factory call.
+ * @param {Map<string,string>} consts - Top-level const string bindings.
+ * @param {string} errorMessagePrefix - Prefix used when throwing validation errors.
+ * @returns {string} Resolved name.
+ * @throws {Error} When name is missing or not a supported static form.
+ */
+export const resolveNameFromArg = ( argNode, consts, errorMessagePrefix ) => {
+  if ( isStringLiteral( argNode ) ) {
+    return argNode.value;
+  }
+  if ( isIdentifier( argNode ) && consts.has( argNode.name ) ) {
+    return consts.get( argNode.name );
+  }
+  return resolveNameFromOptions( argNode, consts, errorMessagePrefix );
+};
+
 /**
  * Build a map of exported component identifiers to declared names by scanning a module.
- * Coerces only static, analyzable forms: `export const X = callee({ name: '...' })`.
+ * Matches any `export const X = identifier(...)` pattern — the callee name is intentionally
+ * unchecked because:
+ * - File path scoping (steps.js, evaluators.js) already constrains which files are parsed
+ * - External packages may define custom factory wrappers (e.g., verify() wraps evaluator())
+ * - Runtime metadata validation is the authoritative check for component type
+ * - Name extraction (resolveNameFromArg) rejects calls without a static name argument
  *
  * @param {object} params
  * @param {string} params.path - Absolute path to the module file.
  * @param {Map<string, Map<string,string>>} params.cache - Cache for memoizing results by file path.
- * @param {('step'|'evaluator')} params.calleeName - Factory function identifier to match.
  * @param {string} params.invalidMessagePrefix - Prefix used in thrown errors when name is invalid.
  * @returns {Map<string,string>} Map of `exportedIdentifier` -> `declaredName`.
  * @throws {Error} When names are missing, dynamic, or otherwise non-static.
  */
-const buildComponentNameMap = ( { path, cache, calleeName, invalidMessagePrefix } ) => {
+const buildComponentNameMap = ( { path, cache, invalidMessagePrefix } ) => {
   if ( cache.has( path ) ) {
     return cache.get( path );
   }
@@ -319,10 +346,10 @@ const buildComponentNameMap = ( { path, cache, calleeName, invalidMessagePrefix
     .filter( node => isExportNamedDeclaration( node ) && isVariableDeclaration( node.declaration ) )
     .reduce( ( map, node ) => {
       node.declaration.declarations
-        .filter( dec => isIdentifier( dec.id ) && isCallExpression( dec.init ) && isIdentifier( dec.init.callee, { name: calleeName } ) )
+        .filter( dec => isIdentifier( dec.id ) && isCallExpression( dec.init ) && isIdentifier( dec.init.callee ) )
         .map( dec => [
           dec,
-          resolveNameFromOptions( dec.init.arguments[0], consts, `${invalidMessagePrefix} ${path} for "${dec.id.name}"` )
+          resolveNameFromArg( dec.init.arguments[0], consts, `${invalidMessagePrefix} ${path} for "${dec.id.name}"` )
         ] )
         .forEach( ( [ dec, name ] ) => map.set( dec.id.name, name ) );
       return map;
@@ -335,7 +362,6 @@ const buildComponentNameMap = ( { path, cache, calleeName, invalidMessagePrefix
 export const buildStepsNameMap = ( path, cache ) => buildComponentNameMap( {
   path,
   cache,
-  calleeName: 'step',
   invalidMessagePrefix: 'Invalid step name in'
 } );
 
@@ -351,13 +377,13 @@ export const buildStepsNameMap = ( path, cache ) => buildComponentNameMap( {
 export const buildSharedStepsNameMap = ( path, cache ) => buildComponentNameMap( {
   path,
   cache,
-  calleeName: 'step',
   invalidMessagePrefix: 'Invalid shared step name in'
 } );
 
 /**
  * Build a map from exported evaluator identifier to declared evaluator name.
- * Parses `evaluators.js` for `export const X = evaluator({ name: '...' })`.
+ * Matches `export const X = evaluator({ name: '...' })` and wrapper patterns
+ * like `export const X = verify('name', fn)`.
  *
  * @param {string} path - Absolute path to the evaluators module file.
  * @param {Map<string, Map<string,string>>} cache - Cache of computed evaluator name maps.
@@ -367,7 +393,6 @@ export const buildSharedStepsNameMap = ( path, cache ) => buildComponentNameMap(
 export const buildEvaluatorsNameMap = ( path, cache ) => buildComponentNameMap( {
   path,
   cache,
-  calleeName: 'evaluator',
   invalidMessagePrefix: 'Invalid evaluator name in'
 } );
 
@@ -383,7 +408,6 @@ export const buildEvaluatorsNameMap = ( path, cache ) => buildComponentNameMap(
 export const buildSharedEvaluatorsNameMap = ( path, cache ) => buildComponentNameMap( {
   path,
   cache,
-  calleeName: 'evaluator',
   invalidMessagePrefix: 'Invalid shared evaluator name in'
 } );
 
@@ -411,8 +435,8 @@ export const buildWorkflowNameMap = ( path, cache ) => {
     if ( isExportNamedDeclaration( node ) && isVariableDeclaration( node.declaration ) ) {
 
       for ( const d of node.declaration.declarations ) {
-        if ( isIdentifier( d.id ) && isCallExpression( d.init ) && isIdentifier( d.init.callee, { name: 'workflow' } ) ) {
-          const name = resolveNameFromOptions( d.init.arguments[0], consts, `Invalid workflow name in ${path} for '${d.id.name}` );
+        if ( isIdentifier( d.id ) && isCallExpression( d.init ) && isIdentifier( d.init.callee ) ) {
+          const name = resolveNameFromArg( d.init.arguments[0], consts, `Invalid workflow name in ${path} for '${d.id.name}` );
           if ( name ) {
             result.named.set( d.id.name, name );
           }
@@ -423,9 +447,9 @@ export const buildWorkflowNameMap = ( path, cache ) => {
     } else if (
       isExportDefaultDeclaration( node ) &&
       isCallExpression( node.declaration ) &&
-      isIdentifier( node.declaration.callee, { name: 'workflow' } )
+      isIdentifier( node.declaration.callee )
     ) {
-      result.default = resolveNameFromOptions( node.declaration.arguments[0], consts, `Invalid default workflow name in ${path}` );
+      result.default = resolveNameFromArg( node.declaration.arguments[0], consts, `Invalid default workflow name in ${path}` );
     }
   }
 

package/src/worker/webpack_loaders/tools.spec.js

@@ -17,6 +17,7 @@ import {
   isSharedEvaluatorsPath,
   isWorkflowPath,
   createThisMethodCall,
+  resolveNameFromArg,
   resolveNameFromOptions,
   buildStepsNameMap,
   buildSharedStepsNameMap,
@@ -258,4 +259,72 @@ describe( 'workflow_rewriter tools', () => {
     expect( getFileKind( '/p/utils.js' ) ).toBe( null );
     expect( getFileKind( '/p/clients/api.js' ) ).toBe( null );
   } );
+
+  it( 'resolveNameFromArg: resolves string literal directly', () => {
+    expect( resolveNameFromArg( t.stringLiteral( 'my_name' ), new Map(), 'X' ) ).toBe( 'my_name' );
+  } );
+
+  it( 'resolveNameFromArg: resolves identifier from consts', () => {
+    const consts = new Map( [ [ 'MY_NAME', 'resolved_name' ] ] );
+    expect( resolveNameFromArg( t.identifier( 'MY_NAME' ), consts, 'X' ) ).toBe( 'resolved_name' );
+  } );
+
+  it( 'resolveNameFromArg: falls back to resolveNameFromOptions for objects', () => {
+    const opts = t.objectExpression( [ t.objectProperty( t.identifier( 'name' ), t.stringLiteral( 'obj_name' ) ) ] );
+    expect( resolveNameFromArg( opts, new Map(), 'X' ) ).toBe( 'obj_name' );
+  } );
+
+  it( 'buildEvaluatorsNameMap: reads names from string-arg factory pattern', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'tools-verify-evals-' ) );
+    const evalsPath = join( dir, 'evaluators.js' );
+    writeFileSync( evalsPath, 'export const EvalA = verify( \'eval_a\', async () => {} )' );
+    const cache = new Map();
+    const map = buildEvaluatorsNameMap( evalsPath, cache );
+    expect( map.get( 'EvalA' ) ).toBe( 'eval_a' );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'buildEvaluatorsNameMap: reads names from object-arg verify pattern', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'tools-verify-obj-evals-' ) );
+    const evalsPath = join( dir, 'evaluators.js' );
+    writeFileSync( evalsPath, 'export const EvalA = verify( { name: \'eval_a\' }, async () => {} )' );
+    const cache = new Map();
+    const map = buildEvaluatorsNameMap( evalsPath, cache );
+    expect( map.get( 'EvalA' ) ).toBe( 'eval_a' );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'buildEvaluatorsNameMap: reads names from mixed factory patterns', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'tools-mixed-evals-' ) );
+    const evalsPath = join( dir, 'evaluators.js' );
+    writeFileSync( evalsPath, [
+      'export const EvalA = verify( { name: \'eval_a\' }, async () => {} )',
+      'export const EvalB = evaluator( { name: \'eval_b\' } )'
+    ].join( '\n' ) );
+    const cache = new Map();
+    const map = buildEvaluatorsNameMap( evalsPath, cache );
+    expect( map.get( 'EvalA' ) ).toBe( 'eval_a' );
+    expect( map.get( 'EvalB' ) ).toBe( 'eval_b' );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'buildStepsNameMap: reads names from string-arg factory pattern', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'tools-verify-steps-' ) );
+    const stepsPath = join( dir, 'steps.js' );
+    writeFileSync( stepsPath, 'export const StepA = myStepHelper( \'step_a\', async () => {} )' );
+    const cache = new Map();
+    const map = buildStepsNameMap( stepsPath, cache );
+    expect( map.get( 'StepA' ) ).toBe( 'step_a' );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'buildWorkflowNameMap: reads names from string-arg factory pattern', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'tools-verify-workflow-' ) );
+    const wfPath = join( dir, 'workflow.js' );
+    writeFileSync( wfPath, 'export default myWorkflowHelper( { name: \'my_flow\' } )' );
+    const cache = new Map();
+    const res = buildWorkflowNameMap( wfPath, cache );
+    expect( res.default ).toBe( 'my_flow' );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
 } );

package/src/worker/webpack_loaders/workflow_rewriter/collect_target_imports.spec.js

@@ -76,66 +76,70 @@ const obj = {};`;
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'throws when ESM import from evaluators.js uses step() instead of evaluator()', () => {
+  it( 'resolves ESM import from evaluators.js regardless of callee name', () => {
     const dir = mkdtempSync( join( tmpdir(), 'collect-esm-mismatch-eval-' ) );
-    writeFileSync( join( dir, 'evaluators.js' ), 'export const BadExport = step({ name: \'bad\' });' );
+    writeFileSync( join( dir, 'evaluators.js' ), 'export const MyExport = step({ name: \'bad\' });' );
 
-    const source = 'import { BadExport } from \'./evaluators.js\';';
+    const source = 'import { MyExport } from \'./evaluators.js\';';
     const ast = makeAst( source, join( dir, 'file.js' ) );
 
-    expect( () => collectTargetImports(
+    const { evaluatorImports } = collectTargetImports(
       ast,
       dir,
       { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
-    ) ).toThrow( /Unresolved import 'BadExport' from evaluators file/ );
+    );
+    expect( evaluatorImports ).toEqual( [ { localName: 'MyExport', evaluatorName: 'bad' } ] );
 
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'throws when ESM import from steps.js uses evaluator() instead of step()', () => {
+  it( 'resolves ESM import from steps.js regardless of callee name', () => {
     const dir = mkdtempSync( join( tmpdir(), 'collect-esm-mismatch-step-' ) );
-    writeFileSync( join( dir, 'steps.js' ), 'export const BadExport = evaluator({ name: \'bad\' });' );
+    writeFileSync( join( dir, 'steps.js' ), 'export const MyExport = evaluator({ name: \'bad\' });' );
 
-    const source = 'import { BadExport } from \'./steps.js\';';
+    const source = 'import { MyExport } from \'./steps.js\';';
     const ast = makeAst( source, join( dir, 'file.js' ) );
 
-    expect( () => collectTargetImports(
+    const { stepImports } = collectTargetImports(
       ast,
       dir,
       { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
-    ) ).toThrow( /Unresolved import 'BadExport' from steps file/ );
+    );
+    expect( stepImports ).toEqual( [ { localName: 'MyExport', stepName: 'bad' } ] );
 
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'throws when CJS require from evaluators.js uses step() instead of evaluator()', () => {
+  it( 'resolves CJS require from evaluators.js regardless of callee name', () => {
     const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-mismatch-eval-' ) );
-    writeFileSync( join( dir, 'evaluators.js' ), 'export const BadExport = step({ name: \'bad\' });' );
+    writeFileSync( join( dir, 'evaluators.js' ), 'export const MyExport = step({ name: \'bad\' });' );
 
-    const source = 'const { BadExport } = require( \'./evaluators.js\' );';
+    const source = 'const { MyExport } = require( \'./evaluators.js\' );';
     const ast = makeAst( source, join( dir, 'file.js' ) );
 
-    expect( () => collectTargetImports(
+    const { evaluatorImports } = collectTargetImports(
       ast,
       dir,
       { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
-    ) ).toThrow( /Unresolved import 'BadExport' from evaluators file/ );
+    );
+    expect( evaluatorImports ).toEqual( [ { localName: 'MyExport', evaluatorName: 'bad' } ] );
 
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'throws when CJS require from steps.js uses evaluator() instead of step()', () => {
+  it( 'resolves CJS require from steps.js regardless of callee name', () => {
     const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-mismatch-step-' ) );
-    writeFileSync( join( dir, 'steps.js' ), 'export const BadExport = evaluator({ name: \'bad\' });' );
+    writeFileSync( join( dir, 'steps.js' ), 'export const MyExport = evaluator({ name: \'bad\' });' );
 
-    const source = 'const { BadExport } = require( \'./steps.js\' );';
+    const source = 'const { MyExport } = require( \'./steps.js\' );';
     const ast = makeAst( source, join( dir, 'file.js' ) );
 
-    expect( () => collectTargetImports(
+    const { stepImports } = collectTargetImports(
       ast,
       dir,
       { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() }
-    ) ).toThrow( /Unresolved import 'BadExport' from steps file/ );
+    );
+    expect( stepImports ).toEqual( [ { localName: 'MyExport', stepName: 'bad' } ] );
 
     rmSync( dir, { recursive: true, force: true } );
   } );
@@ -259,19 +263,19 @@ const obj = {};`;
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'throws when CJS shared steps require uses evaluator() instead of step()', () => {
+  it( 'resolves CJS shared steps require regardless of callee name', () => {
     const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-shared-step-mismatch-' ) );
     mkdirSync( join( dir, 'shared', 'steps' ), { recursive: true } );
     mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
     writeFileSync(
       join( dir, 'shared', 'steps', 'common.js' ),
-      'export const BadExport = evaluator({ name: \'bad\' });'
+      'export const MyExport = evaluator({ name: \'bad\' });'
     );
 
-    const source = 'const { BadExport } = require( \'../../shared/steps/common.js\' );';
+    const source = 'const { MyExport } = require( \'../../shared/steps/common.js\' );';
     const ast = makeAst( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
 
-    expect( () => collectTargetImports(
+    const { sharedStepImports } = collectTargetImports(
       ast,
       join( dir, 'workflows', 'my_workflow' ),
       {
@@ -279,49 +283,52 @@ const obj = {};`;
         evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map(),
         workflowNameCache: new Map()
       }
-    ) ).toThrow( /Unresolved import 'BadExport' from shared steps file/ );
+    );
+    expect( sharedStepImports ).toEqual( [ { localName: 'MyExport', stepName: 'bad' } ] );
 
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'throws when CJS shared evaluator require uses step() instead of evaluator()', () => {
+  it( 'resolves CJS shared evaluator require regardless of callee name', () => {
     const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-shared-eval-mismatch-' ) );
     mkdirSync( join( dir, 'shared', 'evaluators' ), { recursive: true } );
     mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
     writeFileSync(
       join( dir, 'shared', 'evaluators', 'common.js' ),
-      'export const BadExport = step({ name: \'bad\' });'
+      'export const MyExport = step({ name: \'bad\' });'
     );
 
-    const source = 'const { BadExport } = require( \'../../shared/evaluators/common.js\' );';
+    const source = 'const { MyExport } = require( \'../../shared/evaluators/common.js\' );';
     const ast = makeAst( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
 
-    expect( () => collectTargetImports(
+    const { sharedEvaluatorImports } = collectTargetImports(
       ast,
       join( dir, 'workflows', 'my_workflow' ),
       { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map(), workflowNameCache: new Map() }
-    ) ).toThrow( /Unresolved import 'BadExport' from shared evaluators file/ );
+    );
+    expect( sharedEvaluatorImports ).toEqual( [ { localName: 'MyExport', evaluatorName: 'bad' } ] );
 
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'throws when ESM shared evaluator import uses step() instead of evaluator()', () => {
+  it( 'resolves ESM shared evaluator import regardless of callee name', () => {
     const dir = mkdtempSync( join( tmpdir(), 'collect-esm-shared-eval-mismatch-' ) );
     mkdirSync( join( dir, 'shared', 'evaluators' ), { recursive: true } );
     mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
     writeFileSync(
       join( dir, 'shared', 'evaluators', 'common.js' ),
-      'export const BadExport = step({ name: \'bad\' });'
+      'export const MyExport = step({ name: \'bad\' });'
     );
 
-    const source = 'import { BadExport } from \'../../shared/evaluators/common.js\';';
+    const source = 'import { MyExport } from \'../../shared/evaluators/common.js\';';
     const ast = makeAst( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
 
-    expect( () => collectTargetImports(
+    const { sharedEvaluatorImports } = collectTargetImports(
       ast,
       join( dir, 'workflows', 'my_workflow' ),
       { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map(), workflowNameCache: new Map() }
-    ) ).toThrow( /Unresolved import 'BadExport' from shared evaluators file/ );
+    );
+    expect( sharedEvaluatorImports ).toEqual( [ { localName: 'MyExport', evaluatorName: 'bad' } ] );
 
     rmSync( dir, { recursive: true, force: true } );
   } );

package/src/worker/webpack_loaders/workflow_validator/index.spec.js

@@ -285,12 +285,12 @@ describe( 'workflow_validator loader', () => {
       rmSync( dir, { recursive: true, force: true } );
     } );
 
-    it( 'workflow.js: allows imports from ../../shared/clients/pokeapi.js', async () => {
-      const dir = mkdtempSync( join( tmpdir(), 'wf-shared-clients-' ) );
+    it( 'workflow.js: allows imports from ../../clients/pokeapi.js', async () => {
+      const dir = mkdtempSync( join( tmpdir(), 'wf-clients-' ) );
       mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
-      mkdirSync( join( dir, 'shared', 'clients' ), { recursive: true } );
-      writeFileSync( join( dir, 'shared', 'clients', 'pokeapi.js' ), 'export const getPokemon = () => {};\n' );
-      const src = 'import { getPokemon } from "../../shared/clients/pokeapi.js";';
+      mkdirSync( join( dir, 'clients' ), { recursive: true } );
+      writeFileSync( join( dir, 'clients', 'pokeapi.js' ), 'export const getPokemon = () => {};\n' );
+      const src = 'import { getPokemon } from "../../clients/pokeapi.js";';
       await expect( runLoader( join( dir, 'workflows', 'my_workflow', 'workflow.js' ), src ) ).resolves.toBeTruthy();
       rmSync( dir, { recursive: true, force: true } );
     } );
@@ -305,12 +305,12 @@ describe( 'workflow_validator loader', () => {
       rmSync( dir, { recursive: true, force: true } );
     } );
 
-    it( 'steps.ts: allows imports from ../../shared/clients/redis.js', async () => {
-      const dir = mkdtempSync( join( tmpdir(), 'steps-shared-clients-' ) );
+    it( 'steps.ts: allows imports from ../../clients/redis.js', async () => {
+      const dir = mkdtempSync( join( tmpdir(), 'steps-clients-' ) );
       mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
-      mkdirSync( join( dir, 'shared', 'clients' ), { recursive: true } );
-      writeFileSync( join( dir, 'shared', 'clients', 'redis.js' ), 'export const client = {};\n' );
-      const src = 'import { client } from "../../shared/clients/redis.js";';
+      mkdirSync( join( dir, 'clients' ), { recursive: true } );
+      writeFileSync( join( dir, 'clients', 'redis.js' ), 'export const client = {};\n' );
+      const src = 'import { client } from "../../clients/redis.js";';
       await expect( runLoader( join( dir, 'workflows', 'my_workflow', 'steps.js' ), src ) ).resolves.toBeTruthy();
       rmSync( dir, { recursive: true, force: true } );
     } );