@kirrosh/zond 0.12.7 → 0.14.0

package/CHANGELOG.md

@@ -48,8 +48,25 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+### Removed
+
+- **AI subsystem** — removed `ai-generate` CLI, `chat` CLI, AI agent loop, LLM client, TUI chat UI, and all AI SDK dependencies (`ai`, `@ai-sdk/openai`, `@ai-sdk/anthropic`)
+- **CLI commands** — removed `add-api`, `init`, `collections`, `runs`, `compare`, `doctor`, `update` (available via MCP tools or unnecessary)
+- **Directories** — removed `generated/`, `examples/`, `self-tests/`, `apis/`, `docs/archive/`
+- **Files** — removed `seed-demo.ts`, `BACKLOG.md`, `docs/agent.md`
+
 ### Added
 
+- **Extended YAML test format** — 12 new assertion operators, flow control, and data transforms:
+  - **Assertion operators**: `not_equals`, `not_contains`, `gte`, `lte`, `length`, `length_gt/gte/lt/lte`
+  - **Array assertions**: `each` (every element matches), `contains_item` (at least one matches), `set_equals` (order-independent comparison)
+  - **Flow control**: `skip_if` (conditional skip with expression evaluator), `retry_until` (retry with condition/max_attempts/delay_ms), `for_each` (iterate over array)
+  - **Data transforms**: `set` steps with directives — `concat`, `append`, `length`, `get`, `first`, `map_field`
+  - **Generator**: `{{$isoTimestamp}}` — ISO 8601 timestamp string
+  - **Expression evaluator**: supports `==`, `!=`, `>`, `<`, `>=`, `<=` for skip_if/retry_until conditions
+  - Guide-builder YAML cheatsheet updated with all new features
+  - Full backward compatibility — all existing tests continue to work unchanged
+
 - **MCP feedback improvements**
   - `diagnose_failure` now includes `response_headers` in failure output (e.g. `X-Ably-ErrorMessage`)
   - `generate_tests_guide`: annotates `any`-typed request bodies with a warning comment

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kirrosh/zond",
-  "version": "0.12.7",
+  "version": "0.14.0",
   "description": "API testing platform — define tests in YAML, run from CLI or WebUI, generate from OpenAPI specs",
   "license": "MIT",
   "module": "index.ts",
@@ -26,9 +26,8 @@
   "scripts": {
     "zond": "bun run src/cli/index.ts",
     "test": "bun run test:unit && bun run test:mocked",
-    "test:unit": "bun test tests/db/ tests/parser/ tests/runner/ tests/generator/ tests/core/ tests/cli/args.test.ts tests/cli/chat.test.ts tests/cli/ci-init.test.ts tests/cli/commands.test.ts tests/cli/doctor.test.ts tests/cli/init.test.ts tests/cli/runs.test.ts tests/cli/safe-run.test.ts tests/cli/update.test.ts tests/integration/ tests/web/ tests/mcp/tools.test.ts tests/mcp/save-test-suite.test.ts tests/agent/agent-loop.test.ts tests/agent/context-manager.test.ts tests/agent/system-prompt.test.ts tests/reporter/ tests/version-sync.test.ts",
+    "test:unit": "bun test tests/db/ tests/parser/ tests/runner/ tests/generator/ tests/core/ tests/cli/args.test.ts tests/cli/ci-init.test.ts tests/cli/commands.test.ts tests/cli/safe-run.test.ts tests/integration/ tests/web/ tests/mcp/tools.test.ts tests/mcp/save-test-suite.test.ts tests/reporter/ tests/version-sync.test.ts",
     "test:mocked": "bun run scripts/run-mocked-tests.ts",
-    "test:ai": "bun test tests/ai/",
     "check": "tsc --noEmit --project tsconfig.json",
     "build": "bun build --compile src/cli/index.ts --outfile zond",
     "version:sync": "bun run scripts/sync-version.ts",
@@ -42,12 +41,9 @@
   },
   "dependencies": {
     "@humanwhocodes/momoa": "^2.0.3",
-    "@ai-sdk/anthropic": "^2",
-    "@ai-sdk/openai": "^2",
     "@hono/zod-openapi": "^1.2.2",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "@readme/openapi-parser": "^5.5.0",
-    "ai": "^6",
     "hono": "^4.12.2",
     "openapi-types": "^12.1.3",
     "zod": "^4.3.6"

package/src/cli/index.ts

@@ -3,18 +3,9 @@
 import { runCommand } from "./commands/run.ts";
 import { validateCommand } from "./commands/validate.ts";
 import { serveCommand } from "./commands/serve.ts";
-import { collectionsCommand } from "./commands/collections.ts";
-import { aiGenerateCommand } from "./commands/ai-generate.ts";
 import { mcpCommand } from "./commands/mcp.ts";
-import { initCommand } from "./commands/init.ts";
-import { updateCommand } from "./commands/update.ts";
-import { chatCommand } from "./commands/chat.ts";
-import { runsCommand } from "./commands/runs.ts";
 import { coverageCommand } from "./commands/coverage.ts";
-import { doctorCommand } from "./commands/doctor.ts";
-import { addApiCommand } from "./commands/add-api.ts";
 import { ciInitCommand } from "./commands/ci-init.ts";
-import { compareCommand } from "./commands/compare.ts";
 import { printError } from "./output.ts";
 import { getRuntimeInfo } from "./runtime.ts";
 import { getDb } from "../db/schema.ts";
@@ -75,51 +66,13 @@ function printUsage(): void {
   console.log(`zond - API Testing Platform
 
 Usage:
-  zond add-api <name>   Register a new API (collection)
   zond run <path>       Run API tests
   zond validate <path>  Validate test files without running
-  zond ai-generate --from <spec> --prompt "..."  Generate tests with AI
-  zond runs [id]        View test run history
-  zond coverage --spec <path> --tests <dir>  Analyze API test coverage
-  zond collections      List test collections
+  zond coverage         Analyze API test coverage
   zond serve            Start web dashboard
-  zond init             Initialize a new zond project
-  zond ci init          Generate CI/CD workflow (GitHub Actions, GitLab CI)
   zond mcp              Start MCP server (stdio transport for AI agents)
                            --dir <path>  Set working directory (relative paths resolve here)
-  zond chat             Start interactive AI chat for API testing
-  zond compare <runA> <runB>  Compare two test runs (regressions/fixes)
-  zond doctor           Run diagnostic checks
-  zond update           Update to latest version
-
-Options for 'add-api':
-  --spec <path-or-url>   OpenAPI spec (extracts base_url from servers[0])
-  --dir <directory>      Base directory (default: ./apis/<name>/)
-  --env key=value        Set environment variables (repeatable)
-  --insecure             Skip TLS verification (self-signed certs)
-
-Options for 'chat':
-  --provider <name>    LLM provider: ollama, openai, anthropic, custom (default: ollama)
-  --model <name>       Model name (default: provider-specific)
-  --api-key <key>      API key (or set ZOND_AI_KEY env var)
-  --base-url <url>     Provider base URL override
-  --safe               Only allow running GET tests (read-only mode)
-
-Options for 'runs':
-  runs                 List recent test runs
-  runs <id>            Show run details with step results
-  --limit <n>          Number of runs to show (default: 20)
-
-Options for 'compare':
-  compare <runA> <runB>   Compare two run IDs
-  Exit code 1 if regressions found, 0 otherwise
-
-Options for 'coverage':
-  --api <name>         Use API collection (auto-resolves spec and tests dir)
-  --spec <path>        Path to OpenAPI spec (required unless --api used)
-  --tests <dir>        Path to test files directory (required unless --api used)
-  --fail-on-coverage N Exit 1 when coverage percentage is below N (0–100)
-  --run-id <number>    Cross-reference with a test run for pass/fail/5xx breakdown
+  zond ci init          Generate CI/CD workflow (GitHub Actions, GitLab CI)
 
 Options for 'run':
   --dry-run            Show requests without sending them (exit code always 0)
@@ -135,15 +88,12 @@ Options for 'run':
   --safe               Run only GET tests (read-only, safe mode)
   --tag <tag>          Filter suites by tag (repeatable, comma-separated, OR logic)
 
-Options for 'ai-generate':
-  --api <name>         Use API collection (auto-resolves spec and output dir)
-  --from <spec>        Path to OpenAPI spec (required unless --api used)
-  --prompt <text>      Test scenario description (required)
-  --provider <name>    LLM provider: ollama, openai, anthropic, custom (default: ollama)
-  --model <name>       Model name (default: provider-specific)
-  --api-key <key>      API key (or set ZOND_AI_KEY env var)
-  --base-url <url>     Provider base URL override
-  --output <dir>       Output directory (default: ./generated/ai/)
+Options for 'coverage':
+  --api <name>         Use API collection (auto-resolves spec and tests dir)
+  --spec <path>        Path to OpenAPI spec (required unless --api used)
+  --tests <dir>        Path to test files directory (required unless --api used)
+  --fail-on-coverage N Exit 1 when coverage percentage is below N (0–100)
+  --run-id <number>    Cross-reference with a test run for pass/fail/5xx breakdown
 
 Options for 'serve':
   --port <port>        Server port (default: 8080)
@@ -186,35 +136,6 @@ async function main(): Promise<number> {
   }
 
   switch (command) {
-    case "add-api": {
-      const name = positional[0];
-      if (!name) {
-        printError("Missing name argument. Usage: zond add-api <name> [--spec <path>] [--dir <dir>]");
-        return 2;
-      }
-
-      // Collect all --env flags (parseArgs only stores last one, so re-parse)
-      const envValues: string[] = [];
-      const rawArgs = process.argv.slice(2);
-      for (let i = 0; i < rawArgs.length; i++) {
-        if (rawArgs[i] === "--env" && rawArgs[i + 1] && rawArgs[i + 1]!.includes("=")) {
-          envValues.push(rawArgs[i + 1]!);
-          i++;
-        } else if (rawArgs[i]?.startsWith("--env=") && rawArgs[i]!.slice(6).includes("=")) {
-          envValues.push(rawArgs[i]!.slice(6));
-        }
-      }
-
-      return addApiCommand({
-        name,
-        spec: typeof flags["spec"] === "string" ? flags["spec"] : undefined,
-        dir: typeof flags["dir"] === "string" ? flags["dir"] : undefined,
-        envPairs: envValues.length > 0 ? envValues : undefined,
-        dbPath: typeof flags["db"] === "string" ? flags["db"] : undefined,
-        insecure: flags["insecure"] === true,
-      });
-    }
-
     case "run": {
       let path = positional[0];
       const apiFlag = typeof flags["api"] === "string" ? flags["api"] : undefined;
@@ -297,51 +218,6 @@ async function main(): Promise<number> {
       return validateCommand({ path });
     }
 
-    case "ai-generate": {
-      let from = flags["from"] as string | undefined;
-      let output = typeof flags["output"] === "string" ? flags["output"] : undefined;
-      const aiGenApiFlag = typeof flags["api"] === "string" ? flags["api"] : undefined;
-
-      // Resolve --api to spec and output dir from collection
-      if (aiGenApiFlag) {
-        try {
-          getDb(typeof flags["db"] === "string" ? flags["db"] : undefined);
-          const col = findCollectionByNameOrId(aiGenApiFlag);
-          if (!col) { printError(`API '${aiGenApiFlag}' not found`); return 1; }
-          if (!from && col.openapi_spec) from = col.openapi_spec;
-          if (!output && col.test_path) output = col.test_path;
-        } catch (err) {
-          printError(`Failed to resolve --api: ${(err as Error).message}`);
-          return 2;
-        }
-      }
-
-      if (typeof from !== "string") {
-        printError("Missing --from <spec>. Usage: zond ai-generate --from <spec> --prompt \"...\"");
-        return 2;
-      }
-      const prompt = flags["prompt"];
-      if (typeof prompt !== "string") {
-        printError("Missing --prompt <text>. Usage: zond ai-generate --from <spec> --prompt \"...\"");
-        return 2;
-      }
-      return aiGenerateCommand({
-        from,
-        prompt,
-        provider: typeof flags["provider"] === "string" ? flags["provider"] : "ollama",
-        model: typeof flags["model"] === "string" ? flags["model"] : undefined,
-        apiKey: typeof flags["api-key"] === "string" ? flags["api-key"] : undefined,
-        baseUrl: typeof flags["base-url"] === "string" ? flags["base-url"] : undefined,
-        output,
-      });
-    }
-
-    case "collections": {
-      return collectionsCommand(
-        typeof flags["db"] === "string" ? flags["db"] : undefined,
-      );
-    }
-
     case "serve": {
       const portRaw = flags["port"];
       let port: number | undefined;
@@ -361,12 +237,6 @@ async function main(): Promise<number> {
       });
     }
 
-    case "init": {
-      return initCommand({
-        force: flags["force"] === true,
-      });
-    }
-
     case "mcp": {
       return mcpCommand({
         dbPath: typeof flags["db"] === "string" ? flags["db"] : undefined,
@@ -374,49 +244,6 @@ async function main(): Promise<number> {
       });
     }
 
-    case "chat": {
-      return chatCommand({
-        provider: typeof flags["provider"] === "string" ? flags["provider"] : undefined,
-        model: typeof flags["model"] === "string" ? flags["model"] : undefined,
-        apiKey: typeof flags["api-key"] === "string" ? flags["api-key"] : undefined,
-        baseUrl: typeof flags["base-url"] === "string" ? flags["base-url"] : undefined,
-        safe: flags["safe"] === true,
-        dbPath: typeof flags["db"] === "string" ? flags["db"] : undefined,
-      });
-    }
-
-    case "update": {
-      return updateCommand({ force: flags["force"] === true });
-    }
-
-    case "runs": {
-      const idRaw = positional[0];
-      let runId: number | undefined;
-      if (idRaw) {
-        runId = parseInt(idRaw, 10);
-        if (isNaN(runId)) {
-          printError(`Invalid run ID: ${idRaw}`);
-          return 2;
-        }
-      }
-
-      const limitRaw = flags["limit"];
-      let limit: number | undefined;
-      if (typeof limitRaw === "string") {
-        limit = parseInt(limitRaw, 10);
-        if (isNaN(limit) || limit <= 0) {
-          printError(`Invalid limit value: ${limitRaw}`);
-          return 2;
-        }
-      }
-
-      return runsCommand({
-        runId,
-        limit,
-        dbPath: typeof flags["db"] === "string" ? flags["db"] : undefined,
-      });
-    }
-
     case "ci": {
       const ciSub = positional[0];
       if (ciSub !== "init") {
@@ -433,32 +260,6 @@ async function main(): Promise<number> {
       });
     }
 
-    case "compare": {
-      const rawA = positional[0];
-      const rawB = positional[1];
-      if (!rawA || !rawB) {
-        printError("Usage: zond compare <runA> <runB>");
-        return 2;
-      }
-      const runA = parseInt(rawA, 10);
-      const runB = parseInt(rawB, 10);
-      if (isNaN(runA) || isNaN(runB)) {
-        printError("Run IDs must be integers");
-        return 2;
-      }
-      return compareCommand({
-        runA,
-        runB,
-        dbPath: typeof flags["db"] === "string" ? flags["db"] : undefined,
-      });
-    }
-
-    case "doctor": {
-      return doctorCommand({
-        dbPath: typeof flags["db"] === "string" ? flags["db"] : undefined,
-      });
-    }
-
     case "coverage": {
       let spec = flags["spec"] as string | undefined;
       let tests = flags["tests"] as string | undefined;

package/src/core/generator/guide-builder.ts

@@ -120,7 +120,7 @@ Use \`json:\` for JSON request bodies. Do NOT use \`body:\` — it is not a vali
 For form-encoded: use \`form:\` instead of \`json:\`.
 
 ### Built-in generators
-\`{{$uuid}}\`, \`{{$randomInt}}\`, \`{{$timestamp}}\`, \`{{$randomName}}\`, \`{{$randomEmail}}\`, \`{{$randomString}}\`
+\`{{$uuid}}\`, \`{{$randomInt}}\`, \`{{$timestamp}}\`, \`{{$isoTimestamp}}\`, \`{{$randomName}}\`, \`{{$randomEmail}}\`, \`{{$randomString}}\`
 
 ### Variable capture & interpolation
 \`\`\`yaml
@@ -139,6 +139,58 @@ For form-encoded: use \`form:\` instead of \`json:\`.
       id: { equals: "{{created_id}}" }
 \`\`\`
 
+### Array assertions
+\`\`\`yaml
+items:
+  each:                          # every element must match
+    status: { not_equals: "deleted" }
+    id: { type: integer }
+
+items:
+  contains_item:                 # at least one element matches
+    name: { contains: "test" }
+
+ids:
+  set_equals: [1, 2, 3]         # same elements, order-independent
+\`\`\`
+
+### Flow control
+\`\`\`yaml
+  # skip_if — skip step when condition is true (after variable substitution)
+  - name: Delete only if exists
+    DELETE: /items/{{item_id}}
+    skip_if: "{{item_id}} == 0"
+    expect:
+      status: 204
+
+  # retry_until — repeat request until condition met
+  - name: Wait for processing
+    GET: /jobs/{{job_id}}
+    retry_until:
+      condition: "{{status}} == completed"
+      max_attempts: 5
+      delay_ms: 1000
+    expect:
+      status: 200
+
+  # for_each — repeat step for each item in array
+  - name: Delete item
+    DELETE: /items/{{id}}
+    for_each:
+      var: id
+      in: "{{item_ids}}"
+    expect:
+      status: [200, 204]
+
+  # set — transform variables without HTTP request
+  - name: Extract IDs
+    set:
+      all_ids: { map_field: ["{{items}}", "id"] }
+      count: { length: "{{items}}" }
+      first_item: { first: "{{items}}" }
+      merged: { concat: ["{{list_a}}", "{{list_b}}"] }
+\`\`\`
+
 ### Coverage matching
 Use spec paths with \`{param}\` placeholders in the path for coverage to match:
 - Spec says \`GET /products/{id}\` → write \`GET: /products/1\` (hardcode the value)

package/src/core/generator/index.ts

@@ -2,9 +2,6 @@ export { readOpenApiSpec, extractEndpoints, extractSecuritySchemes } from "./ope
 export { serializeSuite, isRelativeUrl, sanitizeEnvName, resolveSpecPath } from "./serializer.ts";
 export type { RawSuite, RawStep } from "./serializer.ts";
 export { generateFromSchema } from "./data-factory.ts";
-export { generateWithAI } from "./ai/ai-generator.ts";
-export { resolveProviderConfig, PROVIDER_DEFAULTS } from "./ai/types.ts";
-export type { AIProviderConfig, AIGenerateOptions, AIGenerateResult } from "./ai/types.ts";
 export { scanCoveredEndpoints, filterUncoveredEndpoints, normalizePath, specPathToRegex } from "./coverage-scanner.ts";
 export type { CoveredEndpoint } from "./coverage-scanner.ts";
 export { analyzeEndpoints } from "./endpoint-warnings.ts";

package/src/core/generator/serializer.ts

@@ -93,17 +93,53 @@ export function serializeSuite(suite: RawSuite): string {
       serializeValue(test.query, 3, lines);
     }
 
-    // expect
-    lines.push("    expect:");
-    if (test.expect.status !== undefined) {
-      lines.push(`      status: ${test.expect.status}`);
+    // skip_if
+    if (test.skip_if) {
+      lines.push(`    skip_if: ${yamlScalar(String(test.skip_if))}`);
+    }
+
+    // retry_until
+    if (test.retry_until && typeof test.retry_until === "object") {
+      const rt = test.retry_until as Record<string, unknown>;
+      lines.push("    retry_until:");
+      if (rt.condition !== undefined) lines.push(`      condition: ${yamlScalar(String(rt.condition))}`);
+      if (rt.max_attempts !== undefined) lines.push(`      max_attempts: ${rt.max_attempts}`);
+      if (rt.delay_ms !== undefined) lines.push(`      delay_ms: ${rt.delay_ms}`);
     }
-    if (test.expect.body) {
-      lines.push("      body:");
-      for (const [key, rule] of Object.entries(test.expect.body)) {
-        lines.push(`        ${key}:`);
-        for (const [rk, rv] of Object.entries(rule)) {
-          lines.push(`          ${rk}: ${yamlScalar(String(rv))}`);
+
+    // for_each
+    if (test.for_each && typeof test.for_each === "object") {
+      const fe = test.for_each as Record<string, unknown>;
+      lines.push("    for_each:");
+      if (fe.var !== undefined) lines.push(`      var: ${yamlScalar(String(fe.var))}`);
+      if (fe.in !== undefined) lines.push(`      in: ${yamlScalar(String(fe.in))}`);
+    }
+
+    // set
+    if (test.set && typeof test.set === "object") {
+      lines.push("    set:");
+      serializeValue(test.set, 3, lines);
+    }
+
+    // expect
+    const hasExpect = test.expect && (test.expect.status !== undefined || test.expect.body);
+    if (hasExpect) {
+      lines.push("    expect:");
+      if (test.expect.status !== undefined) {
+        lines.push(`      status: ${test.expect.status}`);
+      }
+      if (test.expect.body) {
+        lines.push("      body:");
+        for (const [key, rule] of Object.entries(test.expect.body)) {
+          lines.push(`        ${key}:`);
+          for (const [rk, rv] of Object.entries(rule)) {
+            if (typeof rv === "object" && rv !== null) {
+              lines.push(`          ${rk}:`);
+              serializeValue(rv, 6, lines);
+            } else {
+              lines.push(`          ${rk}: ${yamlScalar(String(rv))}`);
+            }
+          }
         }
       }
     }

package/src/core/parser/schema.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import type { TestSuite, TestStep, AssertionRule, TestStepExpect, SuiteConfig } from "./types.ts";
+import type { TestSuite, TestStep, AssertionRule, TestStepExpect, SuiteConfig, RetryUntil, ForEach } from "./types.ts";
 
 const HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"] as const;
 
@@ -26,11 +26,19 @@ function extractMethodAndPath(raw: unknown): unknown {
     return { ...rest, method: foundMethod, path };
   }
 
+  // set-only step: no HTTP method required
+  if (obj.set && !obj.method) {
+    return { ...obj, method: "GET", path: "" };
+  }
+
   return raw;
 }
 
 const ASSERTION_KEYS = new Set([
-  "capture", "type", "equals", "contains", "matches", "gt", "lt", "exists",
+  "capture", "type", "equals", "not_equals", "contains", "not_contains",
+  "matches", "gt", "lt", "gte", "lte", "exists",
+  "length", "length_gt", "length_gte", "length_lt", "length_lte",
+  "each", "contains_item", "set_equals",
 ]);
 
 /**
@@ -68,7 +76,7 @@ export function flattenBodyAssertions(body: Record<string, unknown>): Record<str
   return result;
 }
 
-const AssertionRuleSchema: z.ZodType<AssertionRule> = z.preprocess(
+const AssertionRuleSchemaInner: z.ZodType<AssertionRule> = z.preprocess(
   (val) => {
     if (typeof val === "string") return { type: val };
     if (val === null || val === undefined) return { exists: true };
@@ -86,14 +94,28 @@ const AssertionRuleSchema: z.ZodType<AssertionRule> = z.preprocess(
     capture: z.string().optional(),
     type: z.enum(["string", "integer", "number", "boolean", "array", "object"]).optional(),
     equals: z.unknown().optional(),
+    not_equals: z.unknown().optional(),
     contains: z.string().optional(),
+    not_contains: z.string().optional(),
     matches: z.string().optional(),
     gt: z.number().optional(),
     lt: z.number().optional(),
+    gte: z.number().optional(),
+    lte: z.number().optional(),
     exists: z.boolean().optional(),
+    length: z.number().int().optional(),
+    length_gt: z.number().int().optional(),
+    length_gte: z.number().int().optional(),
+    length_lt: z.number().int().optional(),
+    length_lte: z.number().int().optional(),
+    each: z.record(z.string(), z.lazy(() => AssertionRuleSchemaInner)).optional(),
+    contains_item: z.record(z.string(), z.lazy(() => AssertionRuleSchemaInner)).optional(),
+    set_equals: z.unknown().optional(),
   }),
 ) as z.ZodType<AssertionRule>;
 
+const AssertionRuleSchema = AssertionRuleSchemaInner;
+
 const TestStepExpectSchema: z.ZodType<TestStepExpect> = z.preprocess(
   (val) => {
     if (typeof val !== "object" || val === null) return val;
@@ -117,8 +139,29 @@ const TestStepExpectSchema: z.ZodType<TestStepExpect> = z.preprocess(
   }),
 ) as z.ZodType<TestStepExpect>;
 
+const RetryUntilSchema: z.ZodType<RetryUntil> = z.object({
+  condition: z.string(),
+  max_attempts: z.number().int().positive(),
+  delay_ms: z.number().int().nonnegative(),
+});
+
+const ForEachSchema: z.ZodType<ForEach> = z.object({
+  var: z.string(),
+  in: z.unknown(),
+});
+
 const TestStepSchema: z.ZodType<TestStep> = z.preprocess(
-  extractMethodAndPath,
+  (raw) => {
+    const obj = extractMethodAndPath(raw);
+    // Make expect optional for set-only steps
+    if (typeof obj === "object" && obj !== null) {
+      const o = obj as Record<string, unknown>;
+      if (o.set && !o.expect) {
+        o.expect = {};
+      }
+    }
+    return obj;
+  },
   z.object({
     name: z.string(),
     method: z.enum(HTTP_METHODS),
@@ -128,6 +171,10 @@ const TestStepSchema: z.ZodType<TestStep> = z.preprocess(
     form: z.record(z.string(), z.string()).optional(),
     query: z.record(z.string(), z.string()).optional(),
     expect: TestStepExpectSchema,
+    skip_if: z.string().optional(),
+    retry_until: RetryUntilSchema.optional(),
+    for_each: ForEachSchema.optional(),
+    set: z.record(z.string(), z.unknown()).optional(),
   }),
 ) as z.ZodType<TestStep>;
 

package/src/core/parser/types.ts

@@ -4,11 +4,23 @@ export interface AssertionRule {
   capture?: string;
   type?: "string" | "integer" | "number" | "boolean" | "array" | "object";
   equals?: unknown;
+  not_equals?: unknown;
   contains?: string;
+  not_contains?: string;
   matches?: string;
   gt?: number;
   lt?: number;
+  gte?: number;
+  lte?: number;
   exists?: boolean;
+  length?: number;
+  length_gt?: number;
+  length_gte?: number;
+  length_lt?: number;
+  length_lte?: number;
+  each?: Record<string, AssertionRule>;
+  contains_item?: Record<string, AssertionRule>;
+  set_equals?: unknown;
 }
 
 export interface TestStepExpect {
@@ -18,6 +30,17 @@ export interface TestStepExpect {
   duration?: number;
 }
 
+export interface RetryUntil {
+  condition: string;
+  max_attempts: number;
+  delay_ms: number;
+}
+
+export interface ForEach {
+  var: string;
+  in: unknown;
+}
+
 export interface TestStep {
   name: string;
   method: HttpMethod;
@@ -27,6 +50,10 @@ export interface TestStep {
   form?: Record<string, string>;
   query?: Record<string, string>;
   expect: TestStepExpect;
+  skip_if?: string;
+  retry_until?: RetryUntil;
+  for_each?: ForEach;
+  set?: Record<string, unknown>;
 }
 
 export interface SuiteConfig {

package/src/core/parser/variables.ts

@@ -19,6 +19,7 @@ function randomChars(len: number): string {
 export const GENERATORS: Record<string, () => string | number> = {
   "$uuid": () => crypto.randomUUID(),
   "$timestamp": () => Math.floor(Date.now() / 1000),
+  "$isoTimestamp": () => new Date().toISOString(),
   "$randomName": () => randomFrom(NAMES),
   "$randomEmail": () => `${randomChars(8).toLowerCase()}@test.com`,
   "$randomInt": () => Math.floor(Math.random() * 10000),