@sapiom/agent 0.5.0

package/CHANGELOG.md

@@ -0,0 +1,205 @@
+# @sapiom/orchestration
+
+## 0.5.0
+
+### Minor Changes
+
+- cc1261e: Rename the composition SDK to **agents** and the coding/LLM capability to **models**.
+
+  **Breaking — the package names changed. Install the new names; the old ones are deprecated.**
+
+  - Packages: `@sapiom/orchestration` → `@sapiom/agent`, `@sapiom/orchestration-core` → `@sapiom/agent-core`, `@sapiom/orchestration-runtime` → `@sapiom/agent-runtime`. (`@sapiom/create-orchestration` is retired — scaffold with the CLI or the developer MCP.)
+  - API: `defineOrchestration` → `defineAgent`; `Orchestration*` types/errors → `Agent*`.
+  - `@sapiom/tools`: the `agent` capability namespace is now `models` (e.g. `sapiom.models.coding`); the `orchestrations` namespace is now `agents`.
+  - CLI: `sapiom orchestrations …` → `sapiom agents …`.
+  - Developer MCP tools: `sapiom_dev_orchestrations_*` → `sapiom_dev_agents_*`.
+
+### Patch Changes
+
+- Updated dependencies [cc1261e]
+  - @sapiom/tools@0.16.0
+
+## 0.4.9
+
+### Patch Changes
+
+- Updated dependencies [8fd3f71]
+  - @sapiom/tools@0.15.0
+
+## 0.4.8
+
+### Patch Changes
+
+- Updated dependencies [aaf633c]
+  - @sapiom/tools@0.14.0
+
+## 0.4.7
+
+### Patch Changes
+
+- Updated dependencies [cc2bde2]
+  - @sapiom/tools@0.13.0
+
+## 0.4.6
+
+### Patch Changes
+
+- Updated dependencies [019ef30]
+  - @sapiom/tools@0.12.0
+
+## 0.4.5
+
+### Patch Changes
+
+- Updated dependencies [84e44e2]
+  - @sapiom/tools@0.11.0
+
+## 0.4.4
+
+### Patch Changes
+
+- Updated dependencies [6ebf569]
+  - @sapiom/tools@0.10.0
+
+## 0.4.3
+
+### Patch Changes
+
+- Updated dependencies [30bac1c]
+- Updated dependencies [30bac1c]
+- Updated dependencies [0361fa7]
+  - @sapiom/tools@0.9.0
+
+## 0.4.2
+
+### Patch Changes
+
+- Updated dependencies [2b94dff]
+- Updated dependencies [ac71754]
+- Updated dependencies [f078ed5]
+  - @sapiom/tools@0.8.0
+
+## 0.4.1
+
+### Patch Changes
+
+- Updated dependencies [a3cc368]
+  - @sapiom/tools@0.7.0
+
+## 0.4.0
+
+### Minor Changes
+
+- 56fd77d: Broaden `zod` peer support to `^3.25.76 || ^4.0.0` (was `^4.0.0`).
+
+  The package now uses zod's v4 API via the `zod/v4` subpath internally (types, `z.toJSONSchema`) instead of importing from `zod` directly. That subpath ships in **both** zod 3.25.x and zod 4.x, so the package can be consumed on either — restoring support for zod-3.25 projects (which `^4.0.0` had excluded) while keeping zod 4 working. Author step schemas with `import { z } from "zod/v4"` (equivalent to `import { z } from "zod"` on zod 4).
+
+  Non-breaking for existing zod-4 consumers: `zod/v4` and `zod` resolve to the same v4 implementation there.
+
+## 0.3.0
+
+### Minor Changes
+
+- f41ab95: Declare `zod` as a `peerDependency` (`^4.0.0`) instead of a direct dependency, and remove the `z` / `ZodType` compatibility re-exports from the package entry.
+
+  Step `inputSchema`s are zod schemas authored in the consumer's project and passed into this package, so there must be a single shared `zod` instance — bundling our own copy could otherwise cause type and `instanceof` mismatches against the consumer's `zod`. zod 4 is required; npm 7+ and pnpm install the peer automatically (consumers on older package managers should add `zod` alongside this package).
+
+  The previous `export { z } from "zod"` shim only worked because the package bundled its own `zod`; with `zod` as a peer it would just re-export the consumer's own instance, so it has been removed. Import `z` from `zod` directly.
+
+## 0.2.0
+
+### Minor Changes
+
+- b2c5612: Move the orchestration authoring SDK onto zod 4 via the bare `zod` import (no
+  more `zod/v4` subpath), so installing is just:
+
+  ```sh
+  npm install @sapiom/orchestration
+  ```
+
+  `zod` is now a regular dependency rather than a peer. Author your step schemas
+  with your own `import { z } from "zod"` as usual; a compatibility re-export
+  (`import { z } from "@sapiom/orchestration"`) is available for projects pinned
+  to an incompatible zod. Scaffolded projects now pin zod 4.
+
+### Patch Changes
+
+- Updated dependencies [b2c5612]
+  - @sapiom/tools@0.6.0
+
+## 0.1.9
+
+### Patch Changes
+
+- Updated dependencies [5c974b1]
+  - @sapiom/tools@0.5.0
+
+## 0.1.8
+
+### Patch Changes
+
+- Updated dependencies [e17b2d1]
+  - @sapiom/tools@0.4.0
+
+## 0.1.7
+
+### Patch Changes
+
+- Updated dependencies [704c9ac]
+  - @sapiom/tools@0.3.0
+
+## 0.1.6
+
+### Patch Changes
+
+- Updated dependencies [7f6859e]
+  - @sapiom/tools@0.2.0
+
+## 0.1.5
+
+### Patch Changes
+
+- 363270f: Generated step-input JSON Schemas no longer reject fields the schema doesn't declare.
+
+  `z.toJSONSchema()` (Zod v4) marks every object as closed (`additionalProperties: false`), but a `z.object()` ignores keys it doesn't name when it parses, rather than rejecting them. `buildManifest` now strips the closed-object marker from the schemas it emits so the two behaviors match — a step keeps validating successfully when an input it receives carries extra fields the step's `inputSchema` doesn't name. Typed catchalls (`z.object().catchall(...)`) are preserved.
+
+  Additive and non-breaking. If you previously added fields to a step's `inputSchema` only to admit extra incoming payload fields, that workaround is no longer required (though it remains harmless).
+
+## 0.1.4
+
+### Patch Changes
+
+- 2f957ca: Depend on `@sapiom/tools` with a caret range (`^0.1`) instead of an exact
+  version. The dependency was declared `workspace:*`, which publishes as the exact
+  resolved version — so `@sapiom/orchestration@0.1.2` carried a hard `0.1.2` pin and
+  forced a second copy of `@sapiom/tools` whenever a project used a newer patch
+  (e.g. tools `0.1.3`), producing duplicate nominal types and `tsc` errors. A caret
+  range lets the consumer's own `@sapiom/tools` (any `0.1.x`) satisfy and dedupe to
+  a single copy, while still pulling tools in transitively so authoring types
+  resolve out of the box.
+
+## 0.1.3
+
+### Patch Changes
+
+- Updated dependencies [2126d96]
+  - @sapiom/tools@0.1.3
+
+## 0.1.2
+
+### Patch Changes
+
+- be3886e: Add the dispatch→pause→resume authoring surface for long-running capabilities.
+
+  `@sapiom/tools`: new `DispatchHandle` contract + `CODING_RESULT_SIGNAL`; coding-run
+  handles now carry a `dispatch` member, and `launch` forwards the engine-injected
+  `SAPIOM_CAPABILITY_RESUME_TOKEN` as the `x-sapiom-workflow-token` header.
+
+  `@sapiom/orchestration`: `pauseUntilSignal` accepts a `DispatchHandle |
+Promise<DispatchHandle>` so a step can pause on a launched capability with
+  `pauseUntilSignal(ctx.sapiom.agent.coding.launch(...), { resumeStep })`.
+
+  Additive and non-breaking — standalone `agent.coding.launch` is unchanged.
+
+- Updated dependencies [be3886e]
+  - @sapiom/tools@0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Sapiom
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,130 @@
+# @sapiom/agent
+
+The versioned public contract for authoring Sapiom orchestrations.
+
+A lean, dependency-light package (types + a small protocol runtime) shared by
+three consumers:
+
+- **Customer orchestration definitions** — authored against this package's types and
+  compiled by the build.
+- **The sandbox step-runner** — reads a step's input, builds `ctx`, runs one step.
+- **The engine** — uses the directive guards + manifest schema; it never runs
+  customer code, only validates the pure-data completion payload.
+
+## Install
+
+```sh
+npm install @sapiom/agent
+```
+
+## Authoring surface
+
+```ts
+import {
+  defineAgent,
+  defineStep,
+  goto,
+  terminate,
+} from "@sapiom/agent";
+
+const start = defineStep({
+  name: "start",
+  next: ["finish"],
+  async run(input, ctx) {
+    return goto("finish", { greeting: `hello ${input.name}` });
+  },
+});
+
+const finish = defineStep({
+  name: "finish",
+  next: [],
+  terminal: true,
+  async run() {
+    return terminate({ done: true });
+  },
+});
+
+export const hello = defineAgent({
+  name: "hello",
+  entry: "start",
+  steps: { start, finish },
+});
+```
+
+A step declares the transitions it may take (`next` / `terminal` / `canFail` /
+`pause`); the `run` return type is derived from those declarations, so an
+undeclared transition is a compile error. The build reads those same declarations
+to render the orchestration graph without executing anything.
+
+## Pausing on a long-running capability
+
+Some `ctx.sapiom` capabilities are **dispatched**: you launch them, they run far
+past one step's budget, and they report back when they finish (a coding agent
+today; more below). A step can't inline-`await` one — it pauses, and a later step
+resumes with the result. `pauseUntilSignal` accepts the launch handle (or the
+launch promise itself) and reads everything it needs off it:
+
+```ts
+import { defineStep, pauseUntilSignal, terminate } from "@sapiom/agent";
+import { CODING_RESULT_SIGNAL } from "@sapiom/tools";
+
+const code = defineStep({
+  name: "code",
+  next: ["review"],
+  // capability's exported signal constant so the decl can't drift from the handle.
+  pause: { signal: CODING_RESULT_SIGNAL, resumeStep: "review" },
+  async run(input, ctx) {
+    // launch returns immediately; hand it straight to pauseUntilSignal. The run
+    // parks at status='paused' and the dispatch loop exits.
+    return pauseUntilSignal(
+      ctx.sapiom.models.coding.launch({ task: input.task }),
+      {
+        resumeStep: "review",
+      },
+    );
+  },
+});
+
+const review = defineStep({
+  name: "review",
+  next: [],
+  terminal: true,
+  // Give this step an `inputSchema` (a zod schema for the capability's result
+  // shape) to type + validate what it receives.
+  async run(result, ctx) {
+    // Fires on success OR failure — branch on the terminal result.
+    return terminate({ ok: result.status === "completed" });
+  },
+});
+```
+
+Things to know:
+
+- **The pause is a real suspend across processes**, so the launch and the resume
+  are two steps — you can't fold them into one inline `await`.
+- **The resumed step receives the capability's result as its input.** Declare its
+  `inputSchema` to type + validate it (each capability documents its result shape).
+- **Pass the launch promise directly** for the one-liner above, or `await` it first
+  when you need the handle — to stash the run id in `ctx.shared`, or to `try/catch`
+  a launch failure and route somewhere other than a retry. Awaiting doesn't lose
+  the pause; the resolved handle still flows into `pauseUntilSignal`:
+
+  ```ts
+  async run(input, ctx) {
+    const run = await ctx.sapiom.models.coding.launch({ task: input.task });
+    ctx.shared.set("codingRunId", run.runId); // readable from the resumed step
+    return pauseUntilSignal(run, { resumeStep: "review" });
+  }
+  ```
+- **Outside a workflow nothing changes** — `await launch().wait()` the capability as
+  usual; the pause wiring only engages when a step pauses on the handle.
+
+### Compatible capabilities
+
+Any capability whose `launch` returns a `DispatchHandle` (a `dispatch` member) is
+pausable; each ships a stable result-signal constant for the `pause` decl. This
+list grows as capabilities land:
+
+| Capability   | Launch                              | Pause signal                             |
+| ------------ | ----------------------------------- | ---------------------------------------- |
+| Coding agent | `ctx.sapiom.models.coding.launch(…)` | `CODING_RESULT_SIGNAL` (`@sapiom/tools`) |

package/dist/cjs/agent.d.ts

@@ -0,0 +1,10 @@
+import type { StepDefinition } from './step.js';
+export declare const AGENT_DEFINITION_BRAND: unique symbol;
+export interface AgentDefinition<TInput = unknown, TShared extends Record<string, unknown> = Record<string, unknown>> {
+    readonly name: string;
+    readonly entry: string;
+    readonly steps: Readonly<Record<string, StepDefinition<TShared>>>;
+    readonly __inputType?: TInput;
+}
+export declare function isAgentDefinition(val: unknown): val is AgentDefinition;
+export declare function defineAgent<TInput = unknown, TShared extends Record<string, unknown> = Record<string, unknown>>(def: AgentDefinition<TInput, TShared>): AgentDefinition<TInput, TShared>;

package/dist/cjs/agent.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_DEFINITION_BRAND = void 0;
+exports.isAgentDefinition = isAgentDefinition;
+exports.defineAgent = defineAgent;
+const errors_js_1 = require("./errors.js");
+exports.AGENT_DEFINITION_BRAND = Symbol.for('sapiom.models.definition');
+function isAgentDefinition(val) {
+    if (val === null || typeof val !== 'object')
+        return false;
+    return val[exports.AGENT_DEFINITION_BRAND] === 1;
+}
+function defineAgent(def) {
+    if (!def.name) {
+        throw new Error('Agent definition must have a non-empty name');
+    }
+    if (!def.entry) {
+        throw new Error(`Agent '${def.name}' must declare an entry step`);
+    }
+    if (!def.steps[def.entry]) {
+        throw new errors_js_1.UnknownStepError(def.entry);
+    }
+    for (const [key, step] of Object.entries(def.steps)) {
+        if (!step) {
+            throw new Error(`Agent '${def.name}' has null/undefined step at key '${key}'`);
+        }
+        if (step.name !== key) {
+            throw new Error(`Agent '${def.name}' step name mismatch at key '${key}': step.name='${step.name}'`);
+        }
+    }
+    Object.defineProperty(def, exports.AGENT_DEFINITION_BRAND, {
+        value: 1,
+        enumerable: false,
+        writable: false,
+        configurable: false,
+    });
+    return def;
+}

package/dist/cjs/build-manifest.d.ts

@@ -0,0 +1,15 @@
+import { type AgentManifest } from "./manifest.js";
+import type { AgentDefinition } from "./agent.js";
+export declare function buildManifest(def: AgentDefinition, opts: {
+    sdkVersion: string;
+    artifact: {
+        sha256: string;
+        entryFile: string;
+    };
+}): AgentManifest;
+export interface GraphValidation {
+    readonly errors: string[];
+    readonly warnings: string[];
+}
+export declare function validateGraph(manifest: AgentManifest): GraphValidation;
+export declare function assertValidGraph(manifest: AgentManifest): string[];

package/dist/cjs/build-manifest.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildManifest = buildManifest;
+exports.validateGraph = validateGraph;
+exports.assertValidGraph = assertValidGraph;
+const introspection_js_1 = require("./introspection.js");
+const manifest_js_1 = require("./manifest.js");
+function buildManifest(def, opts) {
+    const steps = {};
+    for (const [stepName, step] of Object.entries(def.steps)) {
+        let inputSchema = null;
+        if (step.inputSchema) {
+            const raw = (0, introspection_js_1.zodToJsonSchema)(step.inputSchema);
+            inputSchema = relaxAdditionalProperties(dropDefaultedFromRequired(raw));
+        }
+        steps[stepName] = {
+            timeoutMs: step.timeoutMs ?? null,
+            inputSchema,
+            transitions: transitionsFor(step),
+        };
+    }
+    return {
+        protocol: manifest_js_1.MANIFEST_PROTOCOL,
+        name: def.name,
+        entry: def.entry,
+        sdkVersion: opts.sdkVersion,
+        artifact: opts.artifact,
+        steps,
+    };
+}
+function transitionsFor(step) {
+    const transitions = [];
+    for (const target of step.next ?? []) {
+        transitions.push({ kind: "continue", target });
+    }
+    if (step.pause) {
+        transitions.push({
+            kind: "pause",
+            signal: step.pause.signal,
+            resumeStep: step.pause.resumeStep,
+        });
+    }
+    if (step.terminal)
+        transitions.push({ kind: "terminate" });
+    if (step.canFail)
+        transitions.push({ kind: "fail" });
+    return transitions;
+}
+function validateGraph(manifest) {
+    const errors = [];
+    const names = new Set(Object.keys(manifest.steps));
+    if (!names.has(manifest.entry)) {
+        errors.push(`entry step '${manifest.entry}' is not in the steps map`);
+    }
+    const forward = buildForwardEdges(manifest, names, errors);
+    const warnings = [];
+    if (names.has(manifest.entry)) {
+        const reachable = bfs([manifest.entry], forward);
+        for (const name of names) {
+            if (!reachable.has(name))
+                warnings.push(`step '${name}' is unreachable from entry '${manifest.entry}'`);
+        }
+    }
+    warnings.push(...terminalReachabilityWarnings(manifest, names, forward));
+    return { errors, warnings };
+}
+function assertValidGraph(manifest) {
+    const { errors, warnings } = validateGraph(manifest);
+    if (errors.length > 0) {
+        throw new Error(`Invalid workflow graph for '${manifest.name}':\n  - ${errors.join("\n  - ")}`);
+    }
+    return warnings;
+}
+function buildForwardEdges(manifest, names, errors) {
+    const forward = new Map();
+    for (const [name, step] of Object.entries(manifest.steps)) {
+        const targets = new Set();
+        for (const t of step.transitions) {
+            if (t.kind === "continue") {
+                if (names.has(t.target))
+                    targets.add(t.target);
+                else
+                    errors.push(`step '${name}' has a continue target '${t.target}' that is not in the steps map`);
+            }
+            else if (t.kind === "pause" && names.has(t.resumeStep)) {
+                targets.add(t.resumeStep);
+            }
+        }
+        if (step.transitions.length === 0) {
+            errors.push(`step '${name}' is a dead-end: it declares no transitions (next/terminal/canFail/pause)`);
+        }
+        forward.set(name, targets);
+    }
+    return forward;
+}
+function terminalReachabilityWarnings(manifest, names, forward) {
+    const sinks = Object.entries(manifest.steps)
+        .filter(([, s]) => s.transitions.some((t) => t.kind === "terminate" || t.kind === "fail"))
+        .map(([name]) => name);
+    if (sinks.length === 0) {
+        return [
+            "no step can terminate or fail — the workflow has no terminal state",
+        ];
+    }
+    const reverse = new Map();
+    for (const name of names)
+        reverse.set(name, new Set());
+    for (const [name, targets] of forward) {
+        for (const t of targets)
+            reverse.get(t)?.add(name);
+    }
+    const canReach = bfs(sinks, reverse);
+    const warnings = [];
+    for (const name of names) {
+        if (!canReach.has(name)) {
+            warnings.push(`step '${name}' cannot reach any terminate/fail (possible unbounded loop or missing terminal)`);
+        }
+    }
+    return warnings;
+}
+function bfs(starts, edges) {
+    const seen = new Set();
+    const queue = [...starts];
+    while (queue.length > 0) {
+        const cur = queue.shift();
+        if (seen.has(cur))
+            continue;
+        seen.add(cur);
+        for (const next of edges.get(cur) ?? [])
+            if (!seen.has(next))
+                queue.push(next);
+    }
+    return seen;
+}
+function relaxAdditionalProperties(value) {
+    if (Array.isArray(value)) {
+        return value.map(relaxAdditionalProperties);
+    }
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [key, v] of Object.entries(value)) {
+            if (key === "additionalProperties" && v === false) {
+                continue;
+            }
+            out[key] = relaxAdditionalProperties(v);
+        }
+        return out;
+    }
+    return value;
+}
+function dropDefaultedFromRequired(schema) {
+    const required = schema.required;
+    const properties = schema.properties;
+    if (!Array.isArray(required) ||
+        !properties ||
+        typeof properties !== "object") {
+        return schema;
+    }
+    const props = properties;
+    const filtered = required.filter((key) => {
+        if (typeof key !== "string")
+            return true;
+        const prop = props[key];
+        return !(prop && typeof prop === "object" && "default" in prop);
+    });
+    if (filtered.length === required.length) {
+        return schema;
+    }
+    return { ...schema, required: filtered };
+}

package/dist/cjs/context.d.ts

@@ -0,0 +1,47 @@
+import type { Sapiom } from '@sapiom/tools';
+import type { NextStepDirective } from './directives.js';
+export interface StepLogger {
+    info(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+    error(message: string, meta?: Record<string, unknown>): void;
+    debug(message: string, meta?: Record<string, unknown>): void;
+}
+export type FinishedStepStatus = 'dispatched' | 'succeeded' | 'failed';
+export interface AgentExecutionContext<TShared extends Record<string, unknown> = Record<string, unknown>> {
+    readonly executionId: string;
+    readonly workflowName: string;
+    readonly organizationId: string | null;
+    readonly tenantId: string | null;
+    readonly input: unknown;
+    readonly shared: TypedContextStore<TShared>;
+    readonly history: readonly StepExecutionRecord[];
+    readonly attempts: number;
+    readonly logger: StepLogger;
+    readonly sapiom: Sapiom;
+}
+export interface TypedContextStore<TShared extends Record<string, unknown>> {
+    get<K extends keyof TShared>(key: K): TShared[K] | undefined;
+    set<K extends keyof TShared>(key: K, value: TShared[K]): void;
+    has<K extends keyof TShared>(key: K): boolean;
+    snapshot(): Partial<TShared>;
+}
+export interface StepExecutionRecord {
+    readonly stepName: string;
+    readonly attempt: number;
+    readonly status: FinishedStepStatus;
+    readonly input: unknown;
+    readonly output: unknown;
+    readonly error: unknown;
+    readonly nextDirective: NextStepDirective | null;
+    readonly sharedStateAfter: Record<string, unknown> | null;
+    readonly startedAt: Date;
+    readonly finishedAt: Date;
+}
+export declare class InMemoryContextStore<TShared extends Record<string, unknown>> implements TypedContextStore<TShared> {
+    private state;
+    constructor(initial?: Partial<TShared>);
+    get<K extends keyof TShared>(key: K): TShared[K] | undefined;
+    set<K extends keyof TShared>(key: K, value: TShared[K]): void;
+    has<K extends keyof TShared>(key: K): boolean;
+    snapshot(): Partial<TShared>;
+}

package/dist/cjs/context.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryContextStore = void 0;
+class InMemoryContextStore {
+    constructor(initial = {}) {
+        this.state = { ...initial };
+    }
+    get(key) {
+        return this.state[key];
+    }
+    set(key, value) {
+        this.state[key] = value;
+    }
+    has(key) {
+        return key in this.state;
+    }
+    snapshot() {
+        return { ...this.state };
+    }
+}
+exports.InMemoryContextStore = InMemoryContextStore;