@archmax-ai/harness 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Archmax AI
+
+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,219 @@
+# archmax harness
+
+**A thin, governed layer over [LangChain Deep
+Agents](https://docs.langchain.com/oss/javascript/deepagents/overview). Every session runs
+under a declarative workflow state machine you author in one YAML file.**
+
+The archmax harness is Node/TypeScript and ESM. It assembles one Deep Agent per workflow, serves that agent's
+workspace through a Deep Agents backend, and enforces `workflows/<slug>/workflow.yaml` with
+middleware and a pure decision kernel.
+
+The runtime holds no use-case logic. Everything specific to your agent lives as files in your
+workspace: persona, states, tool permissions, hooks, skill bundles, data.
+
+- **One file is the source of truth.** `workflow.yaml` is the enforced machine: states,
+  transitions, per-state tool governance, lifecycle hooks, budgets, error routing, triggers.
+  What the model reads is rendered from the spec, so prose cannot drift from enforcement.
+- **Closed by default, including the graph.** The agent sees the active state's tool surface and
+  its outgoing edges. Another state's slug, instructions, transitions and even the state count
+  stay out of the prompt. So the cached prefix does not grow with the graph, and a prompt
+  injection has no map to steer with.
+- **Enforced by the kernel.** The agent moves only by calling `archmax_advance`. The workflow's
+  and the state's `allow`/`forbid` lists cover tools, skills and mounts alike, with deny beating
+  allow. The kernel applies them to every call, including the calls a sandboxed script makes.
+  Hooks return `ok`, `correct` or `veto`, and they fail closed.
+- **Human-in-the-loop, natively.** A `type: human` state parks the session on a durable
+  checkpoint. A person picks the outgoing transition, and the session resumes where it stopped.
+- **Backend-driven and durable.** Specs, prompts, skills and sessions all flow through Deep
+  Agents backends: filesystem, store, or remote. Every session is a resumable, inspectable
+  folder in a session store you choose.
+
+## Why archmax harness
+
+Reliable automation with AI agents should follow the process, and the people who own that
+process should be able to author it. Today that is out of reach for most domain experts.
+Current automation tools fall short in three ways.
+
+- **The agent is a step, not the process.** The agent sits inside a fixed graph, so its
+  flexibility ends at the edge of one node. The process stays as rigid as the diagram someone
+  drew.
+- **The process and its implementation drift apart.** Every business process is restated as a
+  technical graph. That makes two artifacts with two owners, and keeping them in step never
+  stops costing effort.
+- **Complex data still ends up in code.** Nested payloads, loops and arithmetic land in a code
+  node. The person who owns the process cannot read it, let alone change it.
+
+The archmax harness turns this around. The agent runs the whole process, and one `workflow.yaml` both
+describes it and enforces it. Data work happens in a sandbox the same rules govern.
+
+**Full documentation: <https://archmax-ai.github.io/harness/>**
+
+## Install
+
+```bash
+npm install @archmax-ai/harness
+```
+
+Node 22 or later. The model is configured through the environment, against any OpenAI-compatible
+endpoint. The archmax harness reads those keys from a `.env` in the workspace root:
+
+```bash
+ARCHMAX_API_BASE_URL=https://api.example.com/v1
+ARCHMAX_API_KEY=...
+ARCHMAX_MODEL=...
+```
+
+`ARCHMAX_MODEL` is the default. A workflow names the id its states run on with `settings.model`,
+and a single state overrides that with its own `model:`. Either way it is an id, resolved over
+the same endpoint and credentials. So a mechanical state can run on a small model while the state
+whose output a person reads runs on a capable one.
+
+See [configuration](https://archmax-ai.github.io/harness/reference/configuration/) for
+every variable.
+
+## Quickstart
+
+### A workspace
+
+```
+my-workspace/
+├── AGENTS.md                      # persona
+├── workflows/order-lookup/
+│   ├── workflow.yaml              # the enforced state machine, and its grading rubrics
+│   ├── WORKFLOW.md                # optional prose addendum
+│   ├── hooks/check-requester.js   # lifecycle hook scripts
+│   └── tests/*.test.yaml          # cases for `archmax test`
+├── skills/<slug>/                 # skill bundles: SKILL.md, assets/, scripts/
+└── sessions/                      # default session store (gitignored)
+```
+
+```yaml
+# workflows/order-lookup/workflow.yaml (excerpt)
+title: Order lookup
+instructions: Only ever disclose the requester's own company's orders.
+tools:  { forbid_always: [archmax_reset] }  # denied in every state; deny beats allow
+skills: { allow_always: [order-data] }    # enabled in every state; a state's own
+                                          # `skills.allow` adds, `skills.forbid` subtracts
+mounts: { allow_always: [reference] }     # which STATES reach a host-governed mount;
+                                          # a grant may say `access: read` or `read_write`
+
+states:
+  identify-case:
+    triggers:
+      manual:
+    instructions: Classify the request and archmax_advance to the matching path.
+    before: { script: hooks/check-requester.js }
+    transitions:                    # a description is REQUIRED on every edge: the
+                                    # agent is shown this state's edges and nothing
+                                    # else of the graph, so it is all it routes on
+      - to: orders-question
+        description: The user is asking about orders, status, shipping, or tracking.
+  orders-question:                  # no transitions: terminal
+    instructions: Answer from skills/order-data/assets/orders.json.
+                                    # no skills block: the workflow's grant reaches
+                                    # here, and enabling a bundle is the whole grant
+    # The standard this state's exit is graded against, declared where it applies.
+    # On the authoring plane, so the agent being graded can neither read it nor
+    # call it.
+    after:
+      - rubric:
+          max_iterations: 2         # how many times a `correct` may send the agent back
+          instructions: Judge the tone of the reply. Return ok, correct or veto with a reason.
+```
+
+`examples/customer-support/` in this repository is a complete reference workspace.
+
+### The CLI
+
+```bash
+npx archmax run order-lookup "Which orders are delayed for Acme?" --root ./my-workspace
+npx archmax test order-lookup --root ./my-workspace       # run the workflow's cases
+npx archmax validate order-lookup --root ./my-workspace   # static checks, no model calls
+npx archmax sessions --root ./my-workspace                # list durable sessions
+npx archmax decide <session> --to approved                # resume a session parked at a human state
+npx archmax reply <session> "Any update?"                 # answer a parked session; it stays parked
+npx archmax deliver <session> --trigger email_reply       # resume a session parked with archmax_wait
+```
+
+Results go to stdout and the state flow to stderr. Exit 0 means done or parked, 1 a failure, 2 a
+usage error. See the [CLI reference](https://archmax-ai.github.io/harness/reference/cli/).
+
+### The library
+
+```ts
+import { createAgent } from "@archmax-ai/harness";
+
+const agent = await createAgent({
+  workflow: "order-lookup",
+  workspace: { rootDir: "./my-workspace" },
+});
+
+// A turn, a decision, a reply or a delivery: one call, one Outcome.
+const outcome = await agent.workflow!.send("session-42", {
+  message: "Which orders are delayed for Acme?",
+});
+console.log(outcome.kind, outcome.state, outcome.reply); // "parked" "refund-review" "..."
+
+if (outcome.kind === "parked" && outcome.parkedChannel === "decision") {
+  await agent.workflow!.decide("session-42", { target: "approved", comment: "Within policy." });
+}
+```
+
+Omit `workflow` for a plain Deep Agent with the same parameters, or pass `workflow: false` to
+declare an agent ungoverned. `onEvent` receives the typed event stream and
+`workspace.sessionStore` puts sessions elsewhere. `workspace.mounts` composes what the agent can
+see, and marking a mount `governed: true` hands the spec's `mounts` block the decision of which
+states reach it. Marking one `searchable: false` keeps root-wide searches away from a backend
+that must refuse them.
+
+Five subpaths keep production imports small:
+
+- `@archmax-ai/harness/sandbox`: hook authoring types
+- `@archmax-ai/harness/testing`: the case engine
+- `@archmax-ai/harness/cli`: the state-flow renderer
+- `@archmax-ai/harness/spec`: the `workflow.yaml` schema, the pure validator and the grammars
+- `@archmax-ai/harness/messages`: transcript readers
+
+The last two are browser-safe, with no runtime behind them. See the
+[public API reference](https://archmax-ai.github.io/harness/reference/public-api/).
+
+### Authoring with a coding agent
+
+The package ships an authoring skill at `dist/authoring-skill/archmax-harness/`. It teaches a coding agent
+the schema, the hook contract, governance, human states, cases and the CLI. The
+`BUNDLED_AUTHORING_SKILL_DIR` export resolves to its parent directory, and the source is
+`skills/archmax-harness/`.
+
+## Documentation
+
+- [Quickstart](https://archmax-ai.github.io/harness/getting-started/quickstart/) and
+  [installation](https://archmax-ai.github.io/harness/getting-started/installation/)
+- Guides: [the workflow machine](https://archmax-ai.github.io/harness/guides/workflow-machine/),
+  [sessions](https://archmax-ai.github.io/harness/guides/sessions/),
+  [triggers](https://archmax-ai.github.io/harness/guides/triggers/),
+  [skills](https://archmax-ai.github.io/harness/guides/skills/),
+  [sub-workflows](https://archmax-ai.github.io/harness/guides/sub-workflows/),
+  [testing](https://archmax-ai.github.io/harness/guides/testing/),
+  [token efficiency](https://archmax-ai.github.io/harness/guides/token-efficiency/)
+- Reference: [machine spec](https://archmax-ai.github.io/harness/reference/machine-spec/),
+  [CLI](https://archmax-ai.github.io/harness/reference/cli/),
+  [public API](https://archmax-ai.github.io/harness/reference/public-api/),
+  [glossary](https://archmax-ai.github.io/harness/reference/glossary/),
+  [changelog](https://archmax-ai.github.io/harness/reference/changelog/)
+
+## Development
+
+```bash
+npm run dev -- run order-lookup "..." --root examples/customer-support
+npm run typecheck && npm test
+npm run docs:dev
+```
+
+Substantive changes flow through [OpenSpec](https://github.com/Fission-AI/OpenSpec) under
+`openspec/`. Documentation, `README.md` and the authoring skill ship in the same change as the
+behaviour they describe. See [CONTRIBUTING.md](CONTRIBUTING.md) and the
+[development setup](https://archmax-ai.github.io/harness/contributing/development/).
+
+## License
+
+MIT. See [LICENSE](LICENSE).

package/dist/agent.d.ts

@@ -0,0 +1,174 @@
+import { type RunnableConfig } from "@langchain/core/runnables";
+import type { BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
+import type { Graph } from "@langchain/core/runnables/graph";
+import { type AgentInput, type AgentResult, type AgentStreamOptions, type CompiledAgentGraph } from "./core/deepagents.js";
+import type { WorkflowMachine } from "./machine/machine.js";
+import type { MachineSpec } from "./machine/types.js";
+import type { ResolvedTrigger, TriggerInput } from "./machine/triggers.js";
+import type { ResolvedRuntimeContract } from "./runtime/contract.js";
+import type { EmitRunArtifacts, SessionOperations } from "./sessions/operations.js";
+import type { ResolvedSession, ResolveSessionInput } from "./sessions/resolve.js";
+import type { DecideOutcome, DecisionResolution, DeliverOutcome, Outcome, ReplyOutcome, ResumePayload, TriggerDelivery } from "./sessions/resume.js";
+import type { TurnRunner } from "./workflow/turn-runner.js";
+/**
+ * The default config an assembled agent carries: the integration metadata
+ * tracing backends key off, and the recursion limit a turn runs under when the
+ * caller names none. One invoke is one whole turn across states — every hook,
+ * model call and tool batch is a super-step — so the limit is generous by
+ * design: the authored budgets (`budget.maxTurns`, `maxParks`) are the real
+ * bound, and this only stops a turn nothing else bounds.
+ */
+export declare const AGENT_DEFAULT_CONFIG: RunnableConfig;
+/**
+ * A turn's input to {@link WorkflowSurface.send}: what the person said, and —
+ * for a session's opening turn — how it is started and what it is seeded with.
+ * On a session parked at a human state the message is answered without moving
+ * it; on a session parked with `archmax_wait` the trigger and variables are
+ * delivered into it.
+ */
+export interface TurnInput {
+    /** What the person said. */
+    message: string;
+    /** How the session is started; defaults to `manual`. */
+    trigger?: TriggerInput;
+    /** Variables seeded for this turn, locked — the same seeds a delivery carries. */
+    variables?: Record<string, unknown>;
+    /** Where a firing's session id lives, overriding the trigger's declaration. */
+    sessionPath?: string;
+}
+/** What {@link WorkflowSurface.send} takes: a turn, or one of the three resumes. */
+export type SendInput = TurnInput | ResumePayload;
+/**
+ * The governance surface of a governed assembly, reached at `agent.workflow`.
+ *
+ * Carries only what is meaningless without a machine. Everything that describes
+ * *the session* — `sessions`, artifacts, spec snapshots, disposal — is on the
+ * agent itself, because an ungoverned assembly has those too. `undefined` on a
+ * plain assembly, so TypeScript makes the caller handle that.
+ */
+export interface WorkflowSurface {
+    /** Workflow slug this agent was assembled for. */
+    name: string;
+    /** The compiled machine backing this agent's workflow. */
+    machine: WorkflowMachine;
+    /** Map a trigger id to the start state it enters; throws `UnknownTriggerError`. */
+    resolveTrigger(trigger?: TriggerInput): ResolvedTrigger;
+    /** Resume a session parked at a human state with the person's decision. */
+    decide(sessionId: string, resolution: DecisionResolution): Promise<DecideOutcome>;
+    /** Reply to a session parked at a human state and get its answer; it stays parked. */
+    reply(sessionId: string, message: string): Promise<ReplyOutcome>;
+    /** @deprecated Older spelling of {@link reply}; kept for one release. */
+    respond(sessionId: string, message: string): Promise<ReplyOutcome>;
+    /** Resume a session parked with `archmax_wait` with a delivered firing. */
+    deliver(sessionId: string, delivery: TriggerDelivery): Promise<DeliverOutcome>;
+    /** Map a firing to the session it belongs to and the disposition it takes — without invoking. */
+    resolveSession(input: ResolveSessionInput): Promise<ResolvedSession>;
+    /**
+     * The one operation a host or the CLI needs: enter `sessionId` with a turn or
+     * a resume and get one {@link Outcome} back. A turn is resolved first — a new
+     * or finished session takes it as its next turn, a session parked at a human
+     * state has it answered as a reply, a session parked with `archmax_wait` has
+     * its trigger and variables delivered. `config` merges into the invoke config
+     * (a tool-mock declaration, a recursion limit).
+     */
+    send(sessionId: string, input: SendInput, config?: RunnableConfig): Promise<Outcome>;
+}
+/** The session-level members every assembled agent carries, governed or plain. */
+export interface AgentMembers {
+    /** Release every per-session resource held for `sessionId`. Idempotent. */
+    dispose(sessionId: string): void;
+    /** Runtime contract resolved (and enforced) for this agent. */
+    runtimeContract: ResolvedRuntimeContract;
+    /**
+     * Whether tool mocks declared for a session (`configurable.__toolMocks`, the
+     * case engine's `mocks:` channel) intercept **agent-initiated** tool calls —
+     * true when the tool-mock middleware is wired. Scripts' PTC calls are always
+     * intercepted; without this, interception would be partial, which is why the
+     * case engine refuses mock-declaring cases against an agent that lacks it.
+     */
+    toolMocks: boolean;
+    /**
+     * Persist the session's graph snapshot, the supplied trajectory and (when
+     * governed) its trail, variables and usage under `<sessionId>/artifacts/`.
+     * Best-effort: the artifacts directory, or `null` if writing failed.
+     */
+    emitRunArtifacts: EmitRunArtifacts;
+    /** Session handles over the configured session store. */
+    sessions: SessionOperations;
+    /** Resolve a machine spec persisted to the snapshot store by its `specHash`. */
+    getSpecSnapshot(hash: string): Promise<MachineSpec | null>;
+}
+/** @deprecated The members now live on {@link ArchmaxAgent} directly; use `Agent`. */
+export type AgentRunSurface = AgentMembers;
+/**
+ * An assembled agent: a wrapper over the compiled Deep Agent graph.
+ *
+ * This is the shape `createDeepAgent` returns — a thin delegating object holding
+ * the compiled graph — mirrored for two reasons. Familiarity: a consumer who
+ * knows `createDeepAgent` gets `invoke`/`stream`/`streamEvents`/`graph` where
+ * they expect them. Correctness: a compiled graph's `withConfig()` returns a
+ * **new** graph, so a governance namespace attached to a graph object would be
+ * dropped the first time anyone reconfigured it; {@link ArchmaxAgent.withConfig}
+ * rebuilds the wrapper, so `.workflow` survives.
+ *
+ * Every agent's `invoke`, `stream` and `streamEvents` go through a turn runner
+ * that binds the session zone and event context around the call, from
+ * `configurable.thread_id`. A governed agent's runner also streams the model's
+ * text as `agent-text-delta` events and settles parks; a plain agent's runner
+ * drives the graph as-is, bound.
+ */
+export declare class ArchmaxAgent implements AgentMembers {
+    #private;
+    readonly dispose: (sessionId: string) => void;
+    readonly runtimeContract: ResolvedRuntimeContract;
+    readonly toolMocks: boolean;
+    readonly emitRunArtifacts: EmitRunArtifacts;
+    readonly sessions: SessionOperations;
+    readonly getSpecSnapshot: (hash: string) => Promise<MachineSpec | null>;
+    /**
+     * Governance for this assembly, or `undefined` when no `workflow` was
+     * supplied. Carries only what is meaningless without a machine.
+     */
+    readonly workflow: WorkflowSurface | undefined;
+    constructor(opts: {
+        graph: unknown;
+        members: AgentMembers;
+        workflow?: WorkflowSurface | undefined;
+        config?: RunnableConfig;
+        /** The session-bound turn runner the assembly drives its graph through. */
+        driver?: TurnRunner;
+    });
+    /** The compiled `CompiledStateGraph` — a real Pregel, for LangGraph-native use. */
+    get graph(): CompiledAgentGraph;
+    /** The checkpointer the graph was compiled with. */
+    get checkpointer(): BaseCheckpointSaver | boolean | undefined;
+    /** The LangGraph store the graph was compiled with, when one was supplied. */
+    get store(): BaseStore | undefined;
+    /**
+     * A new agent of the same kind with `config` merged into its defaults.
+     * Returns a wrapper, never a bare graph: `.workflow` and the session-level
+     * members must survive reconfiguration.
+     */
+    withConfig(config: RunnableConfig): ArchmaxAgent;
+    /** Drive one turn to a settled result. */
+    invoke(input: AgentInput, config?: RunnableConfig): Promise<AgentResult>;
+    /** Stream one turn's execution. */
+    stream(input: AgentInput, options?: AgentStreamOptions): Promise<AsyncIterable<unknown>>;
+    /** Stream the framework's own event feed. */
+    streamEvents(input: AgentInput, config: RunnableConfig, options?: unknown): AsyncIterable<unknown>;
+    getState(config: RunnableConfig, options?: unknown): Promise<unknown>;
+    getStateHistory(config: RunnableConfig, options?: unknown): AsyncIterableIterator<unknown>;
+    updateState(config: RunnableConfig, values: unknown, asNode?: string): Promise<RunnableConfig>;
+    getSubgraphs(namespace?: string, recurse?: boolean): Generator<[string, unknown]>;
+    getSubgraphsAsync(namespace?: string, recurse?: boolean): AsyncGenerator<[string, unknown]>;
+    getGraphAsync(config?: RunnableConfig): Promise<Graph>;
+}
+/** An assembled agent. See {@link ArchmaxAgent}. */
+export type Agent = ArchmaxAgent;
+/**
+ * @deprecated Narrow on `agent.workflow` instead; kept for one release. An
+ * {@link Agent} known to be governed: `workflow` is present.
+ */
+export type GovernedAgent = Agent & {
+    workflow: WorkflowSurface;
+};

package/dist/agent.js

@@ -0,0 +1,140 @@
+import { mergeConfigs } from "@langchain/core/runnables";
+import { asCompiledAgentGraph, DEFAULT_RECURSION_LIMIT, } from "./core/deepagents.js";
+/**
+ * The default config an assembled agent carries: the integration metadata
+ * tracing backends key off, and the recursion limit a turn runs under when the
+ * caller names none. One invoke is one whole turn across states — every hook,
+ * model call and tool batch is a super-step — so the limit is generous by
+ * design: the authored budgets (`budget.maxTurns`, `maxParks`) are the real
+ * bound, and this only stops a turn nothing else bounds.
+ */
+export const AGENT_DEFAULT_CONFIG = {
+    metadata: { ls_integration: "archmax-harness" },
+    recursionLimit: DEFAULT_RECURSION_LIMIT,
+};
+/**
+ * An assembled agent: a wrapper over the compiled Deep Agent graph.
+ *
+ * This is the shape `createDeepAgent` returns — a thin delegating object holding
+ * the compiled graph — mirrored for two reasons. Familiarity: a consumer who
+ * knows `createDeepAgent` gets `invoke`/`stream`/`streamEvents`/`graph` where
+ * they expect them. Correctness: a compiled graph's `withConfig()` returns a
+ * **new** graph, so a governance namespace attached to a graph object would be
+ * dropped the first time anyone reconfigured it; {@link ArchmaxAgent.withConfig}
+ * rebuilds the wrapper, so `.workflow` survives.
+ *
+ * Every agent's `invoke`, `stream` and `streamEvents` go through a turn runner
+ * that binds the session zone and event context around the call, from
+ * `configurable.thread_id`. A governed agent's runner also streams the model's
+ * text as `agent-text-delta` events and settles parks; a plain agent's runner
+ * drives the graph as-is, bound.
+ */
+export class ArchmaxAgent {
+    #graph;
+    #config;
+    #members;
+    #driver;
+    dispose;
+    runtimeContract;
+    toolMocks;
+    emitRunArtifacts;
+    sessions;
+    getSpecSnapshot;
+    /**
+     * Governance for this assembly, or `undefined` when no `workflow` was
+     * supplied. Carries only what is meaningless without a machine.
+     */
+    workflow;
+    constructor(opts) {
+        this.#graph = asCompiledAgentGraph(opts.graph);
+        this.#members = opts.members;
+        this.#config = mergeConfigs(AGENT_DEFAULT_CONFIG, opts.config);
+        this.#driver = opts.driver;
+        this.workflow = opts.workflow;
+        this.dispose = opts.members.dispose;
+        this.runtimeContract = opts.members.runtimeContract;
+        this.toolMocks = opts.members.toolMocks;
+        this.emitRunArtifacts = opts.members.emitRunArtifacts;
+        this.sessions = opts.members.sessions;
+        this.getSpecSnapshot = opts.members.getSpecSnapshot;
+        // Bound so the agent survives destructuring — `const { invoke } = agent` is
+        // how a caller naturally reaches for one method.
+        this.invoke = this.invoke.bind(this);
+        this.stream = this.stream.bind(this);
+        this.streamEvents = this.streamEvents.bind(this);
+        this.withConfig = this.withConfig.bind(this);
+        this.getState = this.getState.bind(this);
+        this.getStateHistory = this.getStateHistory.bind(this);
+        this.updateState = this.updateState.bind(this);
+        this.getSubgraphs = this.getSubgraphs.bind(this);
+        this.getSubgraphsAsync = this.getSubgraphsAsync.bind(this);
+        this.getGraphAsync = this.getGraphAsync.bind(this);
+    }
+    /** The compiled `CompiledStateGraph` — a real Pregel, for LangGraph-native use. */
+    get graph() {
+        return this.#graph;
+    }
+    /** The checkpointer the graph was compiled with. */
+    get checkpointer() {
+        return this.#graph.checkpointer;
+    }
+    /** The LangGraph store the graph was compiled with, when one was supplied. */
+    get store() {
+        return this.#graph.store;
+    }
+    /**
+     * A new agent of the same kind with `config` merged into its defaults.
+     * Returns a wrapper, never a bare graph: `.workflow` and the session-level
+     * members must survive reconfiguration.
+     */
+    withConfig(config) {
+        return new ArchmaxAgent({
+            graph: this.#graph,
+            members: this.#members,
+            workflow: this.workflow,
+            config: mergeConfigs(this.#config, config),
+            ...(this.#driver ? { driver: this.#driver } : {}),
+        });
+    }
+    /** Drive one turn to a settled result. */
+    invoke(input, config) {
+        const merged = mergeConfigs(this.#config, config);
+        if (this.#driver)
+            return this.#driver.invoke(input, merged);
+        return this.#graph.invoke(input, merged);
+    }
+    /** Stream one turn's execution. */
+    async stream(input, options) {
+        const merged = mergeConfigs(this.#config, options);
+        if (this.#driver)
+            return this.#driver.stream(input, merged);
+        return this.#graph.stream(input, merged);
+    }
+    /** Stream the framework's own event feed. */
+    streamEvents(input, config, options) {
+        const merged = mergeConfigs(this.#config, config);
+        if (this.#driver)
+            return this.#driver.streamEvents(input, merged, options);
+        return this.#graph.streamEvents(input, merged, options);
+    }
+    // --- Checkpoint surface, delegated to the compiled graph -------------------
+    getState(config, options) {
+        return this.#graph.getState(mergeConfigs(this.#config, config), options);
+    }
+    getStateHistory(config, options) {
+        return this.#graph.getStateHistory(mergeConfigs(this.#config, config), options);
+    }
+    updateState(config, values, asNode) {
+        return this.#graph.updateState(mergeConfigs(this.#config, config), values, asNode);
+    }
+    getSubgraphs(namespace, recurse) {
+        return this.#graph.getSubgraphs(namespace, recurse);
+    }
+    getSubgraphsAsync(namespace, recurse) {
+        return this.#graph.getSubgraphsAsync(namespace, recurse);
+    }
+    getGraphAsync(config) {
+        return this.#graph.getGraphAsync(config ? mergeConfigs(this.#config, config) : this.#config);
+    }
+}
+//# sourceMappingURL=agent.js.map

package/dist/agent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.js","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"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"}