@lunora/testing 1.0.0-alpha.4 → 1.0.0-alpha.41

package/dist/index.d.mts

@@ -1,5 +1,115 @@
+import { AgentMessageRow, AgentRunInput, AgentGenerateResult, AgentRunResult, AgentDefinition } from '@lunora/agent';
 import { ScheduledJob, RegisteredAction, RegisteredMutation, RegisteredQuery, ArgsValidator, InferArgs, ActionCtx, MutationCtx, QueryCtx, TableDefinition, Schema } from '@lunora/server';
 export { type InboxOptions, type WaitForMailOptions, extractLink, listCapturedMail, waitForMail } from '@lunora/mail/testing';
+/** A thread message as the in-memory runtime stores it (superset of {@link AgentMessageRow}). */
+interface HarnessMessage extends AgentMessageRow {
+  messageKey: string;
+  threadKey: string;
+}
+/** A thread record as the in-memory runtime stores it. */
+interface HarnessThread {
+  agent: string;
+  error?: string;
+  instanceId?: string;
+  key: string;
+  messageCount: number;
+  owner?: string;
+  status: string;
+  title?: string;
+  usage?: unknown;
+}
+/** One recorded function dispatch the loop made through `ctx.run`. */
+interface HarnessDispatch {
+  args: Record<string, unknown> | undefined;
+  path: string;
+}
+/** Extra function-dispatch handler layered over the built-in `agents:*` runtime double. */
+type HarnessFunction = (args?: Record<string, unknown>) => unknown;
+interface AgentHarnessOptions {
+  /**
+  * Worker `env` bindings visible to tool `execute` and a dynamic
+  * `instructions` thunk. Default `{ LUNORA_TEST: true }`.
+  */
+  env?: Record<string, unknown>;
+  /**
+  * The agent's `lunora/agents.ts` export name — used for thread attribution
+  * and to derive the child-agent `AGENT_*` bindings a sub-agent tool targets.
+  * Default `"agent"`.
+  */
+  exportName?: string;
+  /**
+  * Stub the app functions a tool's `execute` (or the agent's `memory.source`)
+  * dispatches through `ctx.run`, keyed by function path (`"weather:lookup"`).
+  * A handler layered here shadows the built-in `agents:*` runtime double for
+  * that path. An unstubbed non-`agents:*` dispatch throws, so a missing stub
+  * fails loudly rather than silently returning `undefined`.
+  */
+  functions?: Record<string, HarnessFunction>;
+  /**
+  * Scripted model decisions, one {@link AgentGenerateResult} per LLM turn —
+  * the default script for {@link AgentHarness.run}. A terminal turn has an
+  * empty `toolCalls`; a tool-calling turn lists the calls the loop then runs
+  * against the agent's own tools. Override per run via `run(..., { script })`.
+  */
+  script: AgentGenerateResult[];
+}
+/** Per-run overrides for {@link AgentHarness.run}. */
+interface AgentRunOverrides {
+  /** The workflow instance id for this run (default: an auto-incrementing `wf-N`). */
+  instanceId?: string;
+  /** The model script for THIS run, replacing the harness default. */
+  script?: AgentGenerateResult[];
+}
+interface AgentHarness {
+  /**
+  * Every function dispatch the loop has made through `ctx.run`, in order —
+  * both the `agents:*` runtime calls and the tool/memory app dispatches. Use
+  * it to assert a tool called the function you expected with the args you
+  * expected.
+  */
+  readonly dispatches: ReadonlyArray<HarnessDispatch>;
+  /** The persisted messages of a thread, ordered by `seq`. */
+  messages: (threadKey: string) => AgentMessageRow[];
+  /**
+  * Drive one durable agent run to completion against the in-memory journal +
+  * runtime double, returning the loop's {@link AgentRunResult}. Reuse the same
+  * `threadKey` across calls to continue a conversation (the persisted history
+  * carries over); each call runs under a fresh instance id, modelling a
+  * distinct workflow instance.
+  */
+  run: (params: AgentRunInput, overrides?: AgentRunOverrides) => Promise<AgentRunResult>;
+  /** The stored thread record (status, error, instanceId, usage, …), or `undefined` before its first run. */
+  thread: (threadKey: string) => HarnessThread | undefined;
+}
+/**
+* A unit-test harness for a `defineAgent` tool-loop that runs WITHOUT a real
+* model or network. It drives {@link runAgentLoop} over the agent's own
+* `AgentGenerate` seam — the model is a script of per-turn decisions, tool calls
+* run the agent's real `execute` functions inside an in-memory durable-step
+* journal, and thread/message persistence goes through an in-memory `agents:*`
+* runtime double. Mock any function a tool (or the agent's memory) dispatches
+* through the `functions` option.
+*
+* ```ts
+* const harness = agentHarness(support, {
+*     script: [toolCallTurn("c1", "lookup", { id: "o_1" }), finalTurn("It shipped.")],
+*     functions: { "orders:lookup": () => ({ status: "shipped" }) },
+* });
+* const result = await harness.run({ input: "where is my order?", threadKey: "t1" });
+* expect(result.text).toBe("It shipped.");
+* expect(harness.messages("t1").at(-1)?.content).toBe("It shipped.");
+* ```
+*
+* The harness deliberately does NOT model the concurrency guard or a
+* human-in-the-loop approval pause — it is for exercising an agent's tools and
+* turn logic, not the durable orchestration itself (that is covered inside
+* `@lunora/agent`).
+*/
+declare const agentHarness: (agent: AgentDefinition, options: AgentHarnessOptions) => AgentHarness;
+/** A terminal (final-answer) turn — no tool calls. */
+declare const finalTurn: (text: string, extra?: Partial<AgentGenerateResult>) => AgentGenerateResult;
+/** A single-tool-call turn: the loop runs the named tool with `input`. */
+declare const toolCallTurn: (id: string, name: string, input: unknown, text?: string) => AgentGenerateResult;
 /** A pending job entry in the fake scheduler queue. */
 interface FakeScheduledJob extends ScheduledJob {
   /** The args the job was scheduled with. */
@@ -141,6 +251,19 @@ type FunctionRegistry = Record<string, RegisteredAction<any, any> | RegisteredMu
 * clearly-throwing stubs for unsupported surfaces.
 */
 interface LunoraTestOptions {
+  /**
+  * Injectable `ctx.env` for every context (query / mutation / action). When
+  * provided, handlers that read `ctx.env.SOME_KEY` (the validated `defineEnv`
+  * surface) see this object. Left unset it stays `undefined` — matching the
+  * optional `ctx.env?` field, so graceful `ctx.env?.KEY` access still yields
+  * `undefined` rather than throwing. Not a throwing stub for exactly that
+  * reason: `env` is designed to be legitimately absent.
+  * @example
+  * ```ts
+  * const t = lunoraTest(schema, { env: { STRIPE_KEY: "sk_test_…" } });
+  * ```
+  */
+  env?: Record<string, unknown>;
   /**
   * Injectable `fetch` implementation for action contexts. When provided,
   * `ctx.fetch` in every `action` (and `withIdentity` views) resolves to this
@@ -171,6 +294,16 @@ interface LunoraTestOptions {
   * ```
   */
   functions?: FunctionRegistry;
+  /**
+  * Fixed value for `ctx.now` (epoch ms) in every context. Production captures
+  * `Date.now()` once per execution; in tests a fixed `now` makes time-dependent
+  * handlers deterministic. Defaults to the wall clock at harness creation.
+  * @example
+  * ```ts
+  * const t = lunoraTest(schema, { now: 1_700_000_000_000 });
+  * ```
+  */
+  now?: number;
 }
 /**
 * The in-memory test harness returned by {@link lunoraTest}. Mirrors the first
@@ -253,6 +386,8 @@ interface TestHarness {
 *
 * **v1 surfaces now supported:**
 *
+* - `ctx.env` (all contexts): inject the validated env via `options.env`; unset it
+* stays `undefined`, matching the optional `ctx.env?` field.
 * - `ctx.fetch` (actions): inject a custom `fetch` via `options.fetch`.
 * - `ctx.scheduler` (mutations + actions): fully functional fake with virtual clock;
 * control via `harness.scheduler.advance(ms)` / `runPending()` / `list()`.
@@ -262,4 +397,76 @@ interface TestHarness {
 * These are clearly documented follow-ups.
 */
 declare const lunoraTest: (schema: TestSchema, options?: LunoraTestOptions) => TestHarness;
-export { type FakeScheduledJob, type FakeSchedulerControls, type FunctionRegistry, type LunoraTestOptions, type ScheduledJobFailure, type SweepOptions, type TestHarness, type TestIdentity, type TestSubscription, lunoraTest };
+/** One sample handed to a {@link Scorer}. */
+interface ScorerSample {
+  /** The reference/gold answer, when the scorer compares against one. */
+  expected?: string;
+  /** The prompt/input that produced the output (for LLM-judge context). */
+  input?: string;
+  /** Arbitrary per-sample metadata carried through. */
+  metadata?: Record<string, unknown>;
+  /** The model/agent output under test. */
+  output: string;
+}
+/** A scorer's verdict: a `[0, 1]` score and an optional human-readable reason. */
+interface ScoreResult {
+  reason?: string;
+  score: number;
+}
+/** A named scorer — returns a `[0, 1]` score (or a {@link ScoreResult}) for a sample. */
+interface Scorer {
+  name: string;
+  score: (sample: ScorerSample) => Promise<ScoreResult | number> | ScoreResult | number;
+}
+/** One dataset case: an input and its optional gold answer/metadata. */
+interface EvalCase {
+  expected?: string;
+  input: string;
+  metadata?: Record<string, unknown>;
+}
+/** The per-case eval result: the produced output plus each scorer's verdict and the mean. */
+interface EvalItemResult {
+  average: number;
+  input: string;
+  output: string;
+  scores: Record<string, ScoreResult>;
+}
+/** The whole eval run: per-case results plus the mean of their averages. */
+interface EvalResult {
+  average: number;
+  items: EvalItemResult[];
+}
+/** Score 1 if the output contains `needle` (case-insensitive unless `caseSensitive`). */
+declare const containsScorer: (needle: string, options?: {
+  caseSensitive?: boolean;
+}) => Scorer;
+/** Score 1 when `pattern` matches the output. */
+declare const regexScorer: (pattern: RegExp, name?: string) => Scorer;
+/** Score 1 when the trimmed output exactly equals the trimmed `expected`. */
+declare const exactMatchScorer: () => Scorer;
+/** Score the fraction of `keywords` (case-insensitive) present in the output. */
+declare const keywordScorer: (keywords: ReadonlyArray<string>) => Scorer;
+/**
+* An LLM-as-judge scorer. `judge` is INJECTED — a `(prompt) => Promise&lt;string>`
+* you wire to your model (e.g. via `ctx.ai` / `generateText`), so this module
+* stays model-agnostic and the judge is mockable in tests. It returns the model's
+* numeric verdict (`[0, 1]`) plus its reason.
+*/
+declare const llmScorer: (options: {
+  criteria: string;
+  judge: (prompt: string) => Promise<string>;
+  name?: string;
+}) => Scorer;
+/** Run every scorer over one sample (concurrently) → each verdict keyed by name + their mean. */
+declare const scoreSample: (sample: ScorerSample, scorers: ReadonlyArray<Scorer>) => Promise<{
+  average: number;
+  scores: Record<string, ScoreResult>;
+}>;
+/**
+* Run a dataset through `produce` (e.g. an `agentHarness.run` wrapper returning
+* the output text) and score each output with `scorers`. Cases run concurrently;
+* give each its own thread/key inside `produce` if the producer is stateful.
+* Returns per-case results plus the mean of their averages.
+*/
+declare const evaluate: (cases: ReadonlyArray<EvalCase>, produce: (input: string) => Promise<string> | string, scorers: ReadonlyArray<Scorer>) => Promise<EvalResult>;
+export { type AgentHarness, type AgentHarnessOptions, type AgentRunOverrides, type EvalCase, type EvalItemResult, type EvalResult, type FakeScheduledJob, type FakeSchedulerControls, type FunctionRegistry, type HarnessDispatch, type HarnessMessage, type HarnessThread, type LunoraTestOptions, type ScheduledJobFailure, type ScoreResult, type Scorer, type ScorerSample, type SweepOptions, type TestHarness, type TestIdentity, type TestSubscription, agentHarness, containsScorer, evaluate, exactMatchScorer, finalTurn, keywordScorer, llmScorer, lunoraTest, regexScorer, scoreSample, toolCallTurn };

package/dist/index.d.ts

@@ -1,5 +1,115 @@
+import { AgentMessageRow, AgentRunInput, AgentGenerateResult, AgentRunResult, AgentDefinition } from '@lunora/agent';
 import { ScheduledJob, RegisteredAction, RegisteredMutation, RegisteredQuery, ArgsValidator, InferArgs, ActionCtx, MutationCtx, QueryCtx, TableDefinition, Schema } from '@lunora/server';
 export { type InboxOptions, type WaitForMailOptions, extractLink, listCapturedMail, waitForMail } from '@lunora/mail/testing';
+/** A thread message as the in-memory runtime stores it (superset of {@link AgentMessageRow}). */
+interface HarnessMessage extends AgentMessageRow {
+  messageKey: string;
+  threadKey: string;
+}
+/** A thread record as the in-memory runtime stores it. */
+interface HarnessThread {
+  agent: string;
+  error?: string;
+  instanceId?: string;
+  key: string;
+  messageCount: number;
+  owner?: string;
+  status: string;
+  title?: string;
+  usage?: unknown;
+}
+/** One recorded function dispatch the loop made through `ctx.run`. */
+interface HarnessDispatch {
+  args: Record<string, unknown> | undefined;
+  path: string;
+}
+/** Extra function-dispatch handler layered over the built-in `agents:*` runtime double. */
+type HarnessFunction = (args?: Record<string, unknown>) => unknown;
+interface AgentHarnessOptions {
+  /**
+  * Worker `env` bindings visible to tool `execute` and a dynamic
+  * `instructions` thunk. Default `{ LUNORA_TEST: true }`.
+  */
+  env?: Record<string, unknown>;
+  /**
+  * The agent's `lunora/agents.ts` export name — used for thread attribution
+  * and to derive the child-agent `AGENT_*` bindings a sub-agent tool targets.
+  * Default `"agent"`.
+  */
+  exportName?: string;
+  /**
+  * Stub the app functions a tool's `execute` (or the agent's `memory.source`)
+  * dispatches through `ctx.run`, keyed by function path (`"weather:lookup"`).
+  * A handler layered here shadows the built-in `agents:*` runtime double for
+  * that path. An unstubbed non-`agents:*` dispatch throws, so a missing stub
+  * fails loudly rather than silently returning `undefined`.
+  */
+  functions?: Record<string, HarnessFunction>;
+  /**
+  * Scripted model decisions, one {@link AgentGenerateResult} per LLM turn —
+  * the default script for {@link AgentHarness.run}. A terminal turn has an
+  * empty `toolCalls`; a tool-calling turn lists the calls the loop then runs
+  * against the agent's own tools. Override per run via `run(..., { script })`.
+  */
+  script: AgentGenerateResult[];
+}
+/** Per-run overrides for {@link AgentHarness.run}. */
+interface AgentRunOverrides {
+  /** The workflow instance id for this run (default: an auto-incrementing `wf-N`). */
+  instanceId?: string;
+  /** The model script for THIS run, replacing the harness default. */
+  script?: AgentGenerateResult[];
+}
+interface AgentHarness {
+  /**
+  * Every function dispatch the loop has made through `ctx.run`, in order —
+  * both the `agents:*` runtime calls and the tool/memory app dispatches. Use
+  * it to assert a tool called the function you expected with the args you
+  * expected.
+  */
+  readonly dispatches: ReadonlyArray<HarnessDispatch>;
+  /** The persisted messages of a thread, ordered by `seq`. */
+  messages: (threadKey: string) => AgentMessageRow[];
+  /**
+  * Drive one durable agent run to completion against the in-memory journal +
+  * runtime double, returning the loop's {@link AgentRunResult}. Reuse the same
+  * `threadKey` across calls to continue a conversation (the persisted history
+  * carries over); each call runs under a fresh instance id, modelling a
+  * distinct workflow instance.
+  */
+  run: (params: AgentRunInput, overrides?: AgentRunOverrides) => Promise<AgentRunResult>;
+  /** The stored thread record (status, error, instanceId, usage, …), or `undefined` before its first run. */
+  thread: (threadKey: string) => HarnessThread | undefined;
+}
+/**
+* A unit-test harness for a `defineAgent` tool-loop that runs WITHOUT a real
+* model or network. It drives {@link runAgentLoop} over the agent's own
+* `AgentGenerate` seam — the model is a script of per-turn decisions, tool calls
+* run the agent's real `execute` functions inside an in-memory durable-step
+* journal, and thread/message persistence goes through an in-memory `agents:*`
+* runtime double. Mock any function a tool (or the agent's memory) dispatches
+* through the `functions` option.
+*
+* ```ts
+* const harness = agentHarness(support, {
+*     script: [toolCallTurn("c1", "lookup", { id: "o_1" }), finalTurn("It shipped.")],
+*     functions: { "orders:lookup": () => ({ status: "shipped" }) },
+* });
+* const result = await harness.run({ input: "where is my order?", threadKey: "t1" });
+* expect(result.text).toBe("It shipped.");
+* expect(harness.messages("t1").at(-1)?.content).toBe("It shipped.");
+* ```
+*
+* The harness deliberately does NOT model the concurrency guard or a
+* human-in-the-loop approval pause — it is for exercising an agent's tools and
+* turn logic, not the durable orchestration itself (that is covered inside
+* `@lunora/agent`).
+*/
+declare const agentHarness: (agent: AgentDefinition, options: AgentHarnessOptions) => AgentHarness;
+/** A terminal (final-answer) turn — no tool calls. */
+declare const finalTurn: (text: string, extra?: Partial<AgentGenerateResult>) => AgentGenerateResult;
+/** A single-tool-call turn: the loop runs the named tool with `input`. */
+declare const toolCallTurn: (id: string, name: string, input: unknown, text?: string) => AgentGenerateResult;
 /** A pending job entry in the fake scheduler queue. */
 interface FakeScheduledJob extends ScheduledJob {
   /** The args the job was scheduled with. */
@@ -141,6 +251,19 @@ type FunctionRegistry = Record<string, RegisteredAction<any, any> | RegisteredMu
 * clearly-throwing stubs for unsupported surfaces.
 */
 interface LunoraTestOptions {
+  /**
+  * Injectable `ctx.env` for every context (query / mutation / action). When
+  * provided, handlers that read `ctx.env.SOME_KEY` (the validated `defineEnv`
+  * surface) see this object. Left unset it stays `undefined` — matching the
+  * optional `ctx.env?` field, so graceful `ctx.env?.KEY` access still yields
+  * `undefined` rather than throwing. Not a throwing stub for exactly that
+  * reason: `env` is designed to be legitimately absent.
+  * @example
+  * ```ts
+  * const t = lunoraTest(schema, { env: { STRIPE_KEY: "sk_test_…" } });
+  * ```
+  */
+  env?: Record<string, unknown>;
   /**
   * Injectable `fetch` implementation for action contexts. When provided,
   * `ctx.fetch` in every `action` (and `withIdentity` views) resolves to this
@@ -171,6 +294,16 @@ interface LunoraTestOptions {
   * ```
   */
   functions?: FunctionRegistry;
+  /**
+  * Fixed value for `ctx.now` (epoch ms) in every context. Production captures
+  * `Date.now()` once per execution; in tests a fixed `now` makes time-dependent
+  * handlers deterministic. Defaults to the wall clock at harness creation.
+  * @example
+  * ```ts
+  * const t = lunoraTest(schema, { now: 1_700_000_000_000 });
+  * ```
+  */
+  now?: number;
 }
 /**
 * The in-memory test harness returned by {@link lunoraTest}. Mirrors the first
@@ -253,6 +386,8 @@ interface TestHarness {
 *
 * **v1 surfaces now supported:**
 *
+* - `ctx.env` (all contexts): inject the validated env via `options.env`; unset it
+* stays `undefined`, matching the optional `ctx.env?` field.
 * - `ctx.fetch` (actions): inject a custom `fetch` via `options.fetch`.
 * - `ctx.scheduler` (mutations + actions): fully functional fake with virtual clock;
 * control via `harness.scheduler.advance(ms)` / `runPending()` / `list()`.
@@ -262,4 +397,76 @@ interface TestHarness {
 * These are clearly documented follow-ups.
 */
 declare const lunoraTest: (schema: TestSchema, options?: LunoraTestOptions) => TestHarness;
-export { type FakeScheduledJob, type FakeSchedulerControls, type FunctionRegistry, type LunoraTestOptions, type ScheduledJobFailure, type SweepOptions, type TestHarness, type TestIdentity, type TestSubscription, lunoraTest };
+/** One sample handed to a {@link Scorer}. */
+interface ScorerSample {
+  /** The reference/gold answer, when the scorer compares against one. */
+  expected?: string;
+  /** The prompt/input that produced the output (for LLM-judge context). */
+  input?: string;
+  /** Arbitrary per-sample metadata carried through. */
+  metadata?: Record<string, unknown>;
+  /** The model/agent output under test. */
+  output: string;
+}
+/** A scorer's verdict: a `[0, 1]` score and an optional human-readable reason. */
+interface ScoreResult {
+  reason?: string;
+  score: number;
+}
+/** A named scorer — returns a `[0, 1]` score (or a {@link ScoreResult}) for a sample. */
+interface Scorer {
+  name: string;
+  score: (sample: ScorerSample) => Promise<ScoreResult | number> | ScoreResult | number;
+}
+/** One dataset case: an input and its optional gold answer/metadata. */
+interface EvalCase {
+  expected?: string;
+  input: string;
+  metadata?: Record<string, unknown>;
+}
+/** The per-case eval result: the produced output plus each scorer's verdict and the mean. */
+interface EvalItemResult {
+  average: number;
+  input: string;
+  output: string;
+  scores: Record<string, ScoreResult>;
+}
+/** The whole eval run: per-case results plus the mean of their averages. */
+interface EvalResult {
+  average: number;
+  items: EvalItemResult[];
+}
+/** Score 1 if the output contains `needle` (case-insensitive unless `caseSensitive`). */
+declare const containsScorer: (needle: string, options?: {
+  caseSensitive?: boolean;
+}) => Scorer;
+/** Score 1 when `pattern` matches the output. */
+declare const regexScorer: (pattern: RegExp, name?: string) => Scorer;
+/** Score 1 when the trimmed output exactly equals the trimmed `expected`. */
+declare const exactMatchScorer: () => Scorer;
+/** Score the fraction of `keywords` (case-insensitive) present in the output. */
+declare const keywordScorer: (keywords: ReadonlyArray<string>) => Scorer;
+/**
+* An LLM-as-judge scorer. `judge` is INJECTED — a `(prompt) => Promise&lt;string>`
+* you wire to your model (e.g. via `ctx.ai` / `generateText`), so this module
+* stays model-agnostic and the judge is mockable in tests. It returns the model's
+* numeric verdict (`[0, 1]`) plus its reason.
+*/
+declare const llmScorer: (options: {
+  criteria: string;
+  judge: (prompt: string) => Promise<string>;
+  name?: string;
+}) => Scorer;
+/** Run every scorer over one sample (concurrently) → each verdict keyed by name + their mean. */
+declare const scoreSample: (sample: ScorerSample, scorers: ReadonlyArray<Scorer>) => Promise<{
+  average: number;
+  scores: Record<string, ScoreResult>;
+}>;
+/**
+* Run a dataset through `produce` (e.g. an `agentHarness.run` wrapper returning
+* the output text) and score each output with `scorers`. Cases run concurrently;
+* give each its own thread/key inside `produce` if the producer is stateful.
+* Returns per-case results plus the mean of their averages.
+*/
+declare const evaluate: (cases: ReadonlyArray<EvalCase>, produce: (input: string) => Promise<string> | string, scorers: ReadonlyArray<Scorer>) => Promise<EvalResult>;
+export { type AgentHarness, type AgentHarnessOptions, type AgentRunOverrides, type EvalCase, type EvalItemResult, type EvalResult, type FakeScheduledJob, type FakeSchedulerControls, type FunctionRegistry, type HarnessDispatch, type HarnessMessage, type HarnessThread, type LunoraTestOptions, type ScheduledJobFailure, type ScoreResult, type Scorer, type ScorerSample, type SweepOptions, type TestHarness, type TestIdentity, type TestSubscription, agentHarness, containsScorer, evaluate, exactMatchScorer, finalTurn, keywordScorer, llmScorer, lunoraTest, regexScorer, scoreSample, toolCallTurn };

package/dist/index.mjs

@@ -1,2 +1,4 @@
-export { lunoraTest } from './packem_shared/lunoraTest-BUg4Ebv8.mjs';
+export { agentHarness, finalTurn, toolCallTurn } from './packem_shared/agentHarness-GTPhWdQ8.mjs';
+export { lunoraTest } from './packem_shared/lunoraTest-DbzbUAGQ.mjs';
+export { containsScorer, evaluate, exactMatchScorer, keywordScorer, llmScorer, regexScorer, scoreSample } from './packem_shared/containsScorer-DGwtvUNp.mjs';
 export { extractLink, listCapturedMail, waitForMail } from '@lunora/mail/testing';

package/dist/packem_shared/agentHarness-GTPhWdQ8.mjs

@@ -0,0 +1,144 @@
+import { runAgentLoop, DEFAULT_AGENT_FUNCTION_PATHS } from '@lunora/agent';
+
+const scriptedGenerate = (script) => {
+  const remaining = [...script];
+  return () => {
+    const next = remaining.shift();
+    if (!next) {
+      throw new Error("agentHarness: scripted generate exhausted — the run took more turns than the script provided.");
+    }
+    return Promise.resolve(next);
+  };
+};
+class DurableStepJournal {
+  invoked = [];
+  entries = /* @__PURE__ */ new Map();
+  async do(name, callback) {
+    const existing = this.entries.get(name);
+    if (existing) {
+      return existing.output;
+    }
+    this.invoked.push(name);
+    const output = await callback();
+    this.entries.set(name, { output });
+    return output;
+  }
+  // eslint-disable-next-line class-methods-use-this -- mirrors AgentStepLike.waitForEvent's host signature so the mock stays assignable
+  async waitForEvent(_name, _options) {
+    return new Promise(() => {
+    });
+  }
+}
+const createRuntime = (extra) => {
+  const threads = /* @__PURE__ */ new Map();
+  const messages = /* @__PURE__ */ new Map();
+  const dispatches = [];
+  const ensureThread = (args) => {
+    const key = args?.["key"];
+    const instanceId = args?.["instanceId"];
+    const existing = threads.get(key);
+    if (existing) {
+      existing.status = "running";
+      delete existing.error;
+      if (instanceId !== void 0) {
+        existing.instanceId = instanceId;
+      }
+      return { created: false };
+    }
+    threads.set(key, {
+      agent: args?.["agent"],
+      instanceId,
+      key,
+      messageCount: 0,
+      owner: args?.["owner"],
+      status: "running",
+      title: args?.["title"]
+    });
+    return { created: true };
+  };
+  const appendMessage = (args) => {
+    const threadKey = args?.["threadKey"];
+    const messageKey = args?.["messageKey"];
+    const id = `${threadKey}:${messageKey}`;
+    const existing = messages.get(id);
+    if (existing) {
+      return { seq: existing.seq };
+    }
+    const thread = threads.get(threadKey);
+    if (!thread) {
+      throw new Error(`agentHarness: append to unknown thread "${threadKey}".`);
+    }
+    const seq = thread.messageCount;
+    thread.messageCount += 1;
+    messages.set(id, { ...args, seq });
+    return { seq };
+  };
+  const listMessages = (args) => {
+    const key = args?.["key"];
+    return [...messages.values()].filter((message) => message.threadKey === key).toSorted((a, b) => a.seq - b.seq);
+  };
+  const patchThread = (args) => {
+    const thread = threads.get(args?.["key"]);
+    if (thread) {
+      for (const [field, value] of Object.entries(args ?? {})) {
+        if (field !== "key" && value !== void 0) {
+          thread[field] = value;
+        }
+      }
+    }
+    return void 0;
+  };
+  const handlers = new Map([
+    [DEFAULT_AGENT_FUNCTION_PATHS.appendMessage, appendMessage],
+    [DEFAULT_AGENT_FUNCTION_PATHS.ensureThread, ensureThread],
+    [DEFAULT_AGENT_FUNCTION_PATHS.listMessages, listMessages],
+    [DEFAULT_AGENT_FUNCTION_PATHS.patchThread, patchThread],
+    ...Object.entries(extra)
+  ]);
+  const run = (reference, args) => {
+    const path = reference["__lunoraRef"];
+    dispatches.push({ args, path });
+    const handler = handlers.get(path);
+    if (!handler) {
+      throw new Error(`agentHarness: unstubbed dispatch "${path}" — pass a \`functions\` handler for it.`);
+    }
+    return Promise.resolve(handler(args));
+  };
+  return { dispatches, messages, run, threads };
+};
+const agentHarness = (agent, options) => {
+  const exportName = options.exportName ?? "agent";
+  const env = options.env ?? { LUNORA_TEST: true };
+  const runtime = createRuntime(options.functions ?? {});
+  let runCount = 0;
+  const run = (params, overrides) => {
+    runCount += 1;
+    const instanceId = overrides?.instanceId ?? `wf-${String(runCount)}`;
+    const script = overrides?.script ?? options.script;
+    return runAgentLoop({
+      agent,
+      env,
+      exportName,
+      generate: scriptedGenerate(script),
+      instanceId,
+      params,
+      paths: DEFAULT_AGENT_FUNCTION_PATHS,
+      run: runtime.run,
+      step: new DurableStepJournal()
+    });
+  };
+  return {
+    dispatches: runtime.dispatches,
+    messages: (threadKey) => [...runtime.messages.values()].filter((message) => message.threadKey === threadKey).toSorted((a, b) => a.seq - b.seq).map(({ messageKey: _messageKey, threadKey: _threadKey, ...row }) => row),
+    run,
+    thread: (threadKey) => runtime.threads.get(threadKey)
+  };
+};
+const finalTurn = (text, extra) => {
+  return { text, toolCalls: [], ...extra };
+};
+const toolCallTurn = (id, name, input, text = "") => {
+  return { text, toolCalls: [{ id, input, name }] };
+};
+
+export { agentHarness, finalTurn, toolCallTurn };