@zhanla/sdk-ts 0.3.3 → 0.3.4

package/bin/cli.js

@@ -41,6 +41,11 @@ if (subcommand === "discover") {
   }
   const { runDiscover } = await import("./discover.js");
   await runDiscover(filePath);
+} else if (subcommand === "version") {
+  const { createRequire } = await import("module");
+  const require = createRequire(import.meta.url);
+  const { version } = require("../package.json");
+  process.stdout.write(version + "\n");
 } else if (subcommand === "run") {
   const [target, ...rest] = args;
   if (!target) {

package/dist/executor.d.ts

@@ -3,11 +3,13 @@
  * Mirrors the Python CLI executor's component-type dispatch semantics.
  */
 import { ZhanlaComponent } from "./types.js";
+import { LLMCall } from "./trace_store.js";
 export interface RowResult {
     status: "ok" | "error";
     output?: Record<string, unknown>;
     error?: string;
     pathTaken?: Record<string, unknown>;
+    componentLlmCalls?: LLMCall[];
 }
 export declare function executeComponent(comp: ZhanlaComponent, kwargs: Record<string, unknown>): Promise<Record<string, unknown>>;
 export declare function executeRow(component: ZhanlaComponent, evalComponent: ZhanlaComponent | null, row: Record<string, unknown>): Promise<RowResult>;

package/dist/executor.js

@@ -2,7 +2,9 @@
  * Local execution engine for TypeScript SDK components.
  * Mirrors the Python CLI executor's component-type dispatch semantics.
  */
+import { randomUUID } from "crypto";
 import { parseJsonResponse } from "./json.js";
+import { TraceContext, traceStorage } from "./trace_store.js";
 const COMPONENT_ERROR_KEY = "_component_error";
 const OUTPUT_SCHEMA_MISMATCH_REASON = "Model response doesn't match the requested output schema.";
 const JSON_OUTPUT_ERROR_MARKERS = [
@@ -69,6 +71,12 @@ function stringifyValue(value) {
         return String(value);
     }
 }
+function deriveModelInput(row) {
+    if ("input" in row) {
+        return stringifyValue(row["input"]);
+    }
+    return stringifyValue(row);
+}
 function deriveExpectedOutput(row) {
     if ("expected_output" in row) {
         return stringifyValue(row["expected_output"]);
@@ -76,9 +84,12 @@ function deriveExpectedOutput(row) {
     if ("output" in row) {
         return stringifyValue(row["output"]);
     }
-    return "";
+    return stringifyValue(row);
 }
 function deriveModelResponse(output) {
+    if (output == null) {
+        return stringifyValue(output);
+    }
     const keys = Object.keys(output);
     if (keys.length === 1 && keys[0] === "result") {
         return stringifyValue(output["result"]);
@@ -88,6 +99,13 @@ function deriveModelResponse(output) {
     }
     return stringifyValue(output);
 }
+function buildCodeEvalKwargs(output, row) {
+    return {
+        model_input: deriveModelInput(row),
+        model_response: deriveModelResponse(output),
+        expected_output: deriveExpectedOutput(row),
+    };
+}
 // ---------------------------------------------------------------------------
 // Component execution dispatch
 // ---------------------------------------------------------------------------
@@ -156,13 +174,11 @@ async function runTool(comp, kwargs) {
     return { result };
 }
 async function runCodeEval(comp, kwargs) {
-    const modelResponse = kwargs["model_response"];
-    const expectedResponse = kwargs["expected_response"] ?? null;
     const { value: result, logs } = await captureConsoleLogs(async () => {
         if (comp.isAsync) {
-            return await comp.fn(modelResponse, expectedResponse);
+            return await comp.fn(kwargs);
         }
-        return comp.fn(modelResponse, expectedResponse);
+        return comp.fn(kwargs);
     });
     if (result !== null && typeof result === "object" && !Array.isArray(result)) {
         return logs.length > 0
@@ -528,14 +544,19 @@ export async function executeRow(component, evalComponent, row) {
     let error;
     let demotedError;
     let orchestrationSteps;
+    let componentLlmCalls;
+    let componentFailedWithoutEval = false;
+    const traceContext = new TraceContext(randomUUID());
     try {
-        if (component.componentType === "orchestration") {
-            orchestrationSteps = [];
-            output = await runOrchestration(component, row, orchestrationSteps);
-        }
-        else {
-            output = await executeComponent(component, row);
-        }
+        await traceStorage.run(traceContext, async () => {
+            if (component.componentType === "orchestration") {
+                orchestrationSteps = [];
+                output = await runOrchestration(component, row, orchestrationSteps);
+            }
+            else {
+                output = await executeComponent(component, row);
+            }
+        });
     }
     catch (err) {
         error = err instanceof Error ? err.message : String(err);
@@ -545,9 +566,20 @@ export async function executeRow(component, evalComponent, row) {
             error = undefined;
         }
         else {
-            return { status: "error", error, pathTaken: buildPathTaken(component, row, undefined, error, orchestrationSteps) };
+            componentFailedWithoutEval = true;
         }
     }
+    finally {
+        componentLlmCalls = traceContext.flush();
+    }
+    if (componentFailedWithoutEval) {
+        return {
+            status: "error",
+            error,
+            pathTaken: buildPathTaken(component, row, undefined, error, orchestrationSteps),
+            componentLlmCalls,
+        };
+    }
     if (evalComponent != null) {
         if (output != null
             && typeof output[COMPONENT_ERROR_KEY] === "string"
@@ -556,18 +588,17 @@ export async function executeRow(component, evalComponent, row) {
                 status: "ok",
                 output: { ...output, _eval: buildSchemaMismatchEvalOutput(String(output[COMPONENT_ERROR_KEY])) },
                 pathTaken: buildPathTaken(component, row, output, demotedError, orchestrationSteps),
+                componentLlmCalls,
             };
         }
-        const evalKwargs = {
-            model_response: deriveModelResponse(output),
-            expected_response: deriveExpectedOutput(row) || null,
-        };
+        const evalKwargs = buildCodeEvalKwargs(output, row);
         try {
             const evalOutput = await executeComponent(evalComponent, evalKwargs);
             return {
                 status: "ok",
                 output: { ...output, _eval: evalOutput },
                 pathTaken: buildPathTaken(component, row, output, demotedError, orchestrationSteps),
+                componentLlmCalls,
             };
         }
         catch (err) {
@@ -577,6 +608,7 @@ export async function executeRow(component, evalComponent, row) {
                 output,
                 error: evalError,
                 pathTaken: buildPathTaken(component, row, output, demotedError, orchestrationSteps),
+                componentLlmCalls,
             };
         }
     }
@@ -584,6 +616,7 @@ export async function executeRow(component, evalComponent, row) {
         status: "ok",
         output,
         pathTaken: buildPathTaken(component, row, output, demotedError, orchestrationSteps),
+        componentLlmCalls,
     };
 }
 function buildPathTaken(component, inputData, output, error, orchestrationSteps) {

package/dist/index.d.ts

@@ -3,7 +3,7 @@
  * Import component classes to define zhanla components in TypeScript.
  */
 export { Tool, CodeEval, Skill, Agent, LLMProcessor, LLMEval, Runner, Conditional, Step, Orchestration, Leaf, Edge, Branch, Checklist, EvalTree, ZhanlaComponent, RUNNABLE_TYPES, EVAL_TYPES, } from "./types.js";
-export type { ComponentValue, ToolOptions, CodeEvalOptions, SkillOptions, AgentOptions, LLMProcessorOptions, LLMEvalOptions, OrchestrationOptions, ChecklistOptions, EvalTreeOptions, StepOptions, ComponentType, JsonSchema, JsonSchemaObject, JsonSchemaArray, JsonSchemaScalar, ToolCall, LLMResponse, RunnerOptions, RunnerCallOptions, RunnerMessage, } from "./types.js";
+export type { ComponentValue, ToolOptions, CodeEvalKwargs, CodeEvalOptions, SkillOptions, AgentOptions, LLMProcessorOptions, LLMEvalOptions, OrchestrationOptions, ChecklistOptions, EvalTreeOptions, StepOptions, ComponentType, JsonSchema, JsonSchemaObject, JsonSchemaArray, JsonSchemaScalar, ToolCall, LLMResponse, RunnerOptions, RunnerCallOptions, RunnerMessage, } from "./types.js";
 export { toManifest, collectExportedComponents } from "./manifest.js";
 export type { ComponentManifest, StepManifest, BranchManifest, EdgeManifest, LeafManifest } from "./manifest.js";
 export { executeComponent, executeRow } from "./executor.js";

package/dist/types.d.ts

@@ -103,10 +103,15 @@ export declare class Tool extends ZhanlaComponent {
     readonly key: string;
     constructor(opts: ToolOptions);
 }
+export interface CodeEvalKwargs extends Record<string, unknown> {
+    model_input?: string;
+    model_response: string;
+    expected_output?: string;
+}
 export interface CodeEvalOptions {
     name: string;
     description: string;
-    fn: (modelResponse: ComponentValue, expectedResponse: ComponentValue | null) => unknown;
+    fn: (kwargs: CodeEvalKwargs) => unknown;
     modelResponseFormat?: "JSON" | "TEXT" | "YAML";
     key: string;
 }
@@ -114,7 +119,7 @@ export declare class CodeEval extends ZhanlaComponent {
     readonly componentType: "code_eval";
     readonly name: string;
     readonly description: string;
-    readonly fn: (modelResponse: ComponentValue, expectedResponse: ComponentValue | null) => unknown;
+    readonly fn: (kwargs: CodeEvalKwargs) => unknown;
     readonly isAsync: boolean;
     readonly modelResponseFormat: "JSON" | "TEXT" | "YAML";
     readonly key: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhanla/sdk-ts",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "TypeScript SDK for the zhanla CLI — define and run AI components locally",
   "homepage": "https://benchmark-black.vercel.app/",
   "repository": {