@statelyai/agent 2.0.0-alpha.11 → 2.0.0-alpha.13

package/readme.md

@@ -1,20 +1,22 @@
 # Stately Agent
 
-**The logic layer for AI agents.**
+**Make invalid agent actions impossible.**
 
-Build agents as state machines to control exactly what the agent can do. The machine owns control flow; the model only ever picks a legal event. Testing, inspection, and visualization fall out for free.
+Agent logic as state machines: deterministic, inspectable, resumable, runs anywhere. The machine owns control flow; the model only ever picks a legal event. Testing, inspection, and visualization fall out for free.
 
-Stately Agent adds model requests and decisions to XState. The state machine defines what the agent can do. Your application chooses the model, runs the requests, and stores the state.
+Stately Agent adds model requests and decisions to XState:
 
-Any agent workflow or loop can be modeled as a state machine. Model calls and tools run as effects inside it. The model proposes an event. The machine decides whether it is allowed and what happens next. See [how this compares to LangGraph and hand-rolling a loop](docs/comparison.md).
+- The machine defines what the agent can do.
+- Your application chooses the model, runs the requests, and stores the state.
+- The model proposes an event; the machine decides whether it is allowed and what happens next.
 
 Stately Agent 2 is in alpha. APIs may change before the stable release.
 
 [Documentation](https://stately.ai/docs/agents) · [Examples](examples/README.md) · [XState](https://github.com/statelyai/xstate)
 
-## Three ways to start
+## Three starting points
 
-- **Author a new agent.** Build a machine from states, decisions, and typed requests; run it locally with `runAgent`, test it with no API key, then eject to any framework or runtime with zero machine changes. See the [Quickstart](docs/quickstart.md) and [Eject to your stack](docs/eject.md).
+- **Author a new agent.** Build a machine from states, decisions, and typed requests; run it locally with `runAgent`, test it with no API key, then use it in any framework or runtime with zero machine changes. See the [Quickstart](docs/quickstart.md) and [Use in any stack](docs/any-stack.md).
 - **Retrofit an existing agent.** Turn a `while` loop into a machine: your SDK calls, tools, and retry code become the executors; the machine replaces only the control flow. See [Migrating from a loop](docs/from-a-loop.md).
 - **Copy a known pattern.** ReAct, reflection, plan-and-execute, RAG, supervisor, and more, each a single runnable file you lift in 60 seconds. See [Agent patterns](docs/patterns.md).
 
@@ -26,7 +28,11 @@ Stately Agent 2 is in alpha. APIs may change before the stable release.
 pnpm add @statelyai/agent@alpha xstate@alpha zod ai@^6 @ai-sdk/openai@^3
 ```
 
-Node 22.18 or newer is required. The package is ESM-only; the library targets XState v6 alpha and stays compatible with XState v5. Provider packages must match your `ai` major: `@ai-sdk/openai@^3` pairs with `ai@^6` (a bare `@ai-sdk/openai` resolves to `@latest`, which can mismatch the `ai` peer).
+Requirements:
+
+- Node 22.18 or newer, and XState v6 alpha.25 or newer.
+- The package is ESM-first. CommonJS builds are published too, so `require()` works.
+- Provider packages must match your `ai` major: `@ai-sdk/openai@^3` pairs with `ai@^6`. A bare `@ai-sdk/openai` resolves to `@latest`, which can mismatch the `ai` peer.
 
 ## Quick start
 
@@ -114,11 +120,34 @@ When the machine reaches `refunded`, the result is:
 
 The model chooses between the events allowed in `deciding`. The `AUTO_REFUND` transition only works when the amount is at most $100. If the model chooses it for a larger amount, the guard rejects the choice and the decision is tried again.
 
-## The state machine
+`createScriptedExecutors` plays back canned answers through the same executor contract, so the machine above runs end to end before a model is involved. **No API key needed:**
+
+```ts
+import { createScriptedExecutors } from "@statelyai/agent";
+
+const result = await runAgent(refundMachine, {
+  input: { request: "I was charged twice for the same order.", amount: 75 },
+  executors: createScriptedExecutors({ decisions: [{ type: "AUTO_REFUND" }] }),
+});
+```
+
+Swap in `createAiSdkExecutors({ models })` when you want a real model. The scripted set is what your tests keep using.
+
+## Architecture
+
+```mermaid
+flowchart LR
+  M["Agent machine<br/>states · guards · requests"] -->|request| R["runAgent"]
+  R -->|executor call| E["Host executors<br/>generateText · streamText · decide"]
+  E -->|API call| L["Model"]
+  L -->|result| E
+  E -->|result| R
+  R -->|event or output| M
+```
 
-<!-- Add the state machine illustration here. -->
+The machine never talks to a model directly, so swapping `createAiSdkExecutors` for `createScriptedExecutors` (or your own functions) changes nothing about the agent.
 
-The example has one model decision and two final outcomes. Real machines can add approval states, retries, parallel work, child agents, and long-running waits without changing how the control flow is represented.
+The example above has one model decision and two final outcomes. Real machines add approval states, retries, parallel work, child agents, and long-running waits without changing how control flow is represented.
 
 ## Core concepts
 
@@ -129,6 +158,7 @@ The example has one model decision and two final outcomes. Real machines can add
 - **Requests are typed.** Inputs, outputs, context, and events use Standard Schema. Zod works out of the box.
 - **Your code runs the model.** `runAgent` accepts executor functions. The example uses the Vercel AI SDK adapter, but the machine does not depend on a provider.
 - **Snapshots can be stored.** An agent can stop for human input, save its XState snapshot, and resume later in another process.
+- **Runs export verified replay entries.** Every `runAgent` result carries a JSON-safe `AgentLogEntry[]` with event identity, timestamp, machine version, and state/effect hashes; pass it to `replay` or `verifyReplay` without repeating model or tool calls.
 - **Machines can be checked without model calls.** Lint their structure, simulate scripted decisions, and explore paths without an API key.
 - **Agents are XState machines.** Guards, actors, parallel states, inspection, testing, and visualization work as usual.
 
@@ -151,7 +181,14 @@ See [all examples](examples/README.md).
 - [Decisions](docs/decisions.md)
 - [Human in the loop](docs/human-in-the-loop.md)
 - [Testing and verification](docs/verify.md)
-- [Running on different hosts](docs/hosts.md)
-- [Eject to your stack](docs/eject.md)
+- [Evals](docs/evals.md)
+- [Generating machines with an LLM](docs/generate-machines.md)
+- [Hosts and executors](docs/hosts.md)
+- [Models and providers](docs/models-and-providers.md)
+- [Use in any stack](docs/any-stack.md)
+- [The event log](docs/event-log.md)
+- [Observability](docs/observability.md)
+- [Usage and budgets](docs/usage-and-budgets.md)
 - [Agent patterns](docs/patterns.md)
 - [Migrating from a loop](docs/from-a-loop.md)
+- [LangGraph vs agent machines](docs/langgraph-comparison.md)

package/schemas/agent-workflow.json

@@ -45,6 +45,17 @@
       },
       "default": {}
     },
+    "actors": {
+      "description": "Placeholder actor sources declared by key. JSON wires no execution; provide the logic via machine.provide({ actors }) after setupAgent.fromConfig(...).",
+      "type": "object",
+      "propertyNames": {
+        "$ref": "#/$defs/Identifier"
+      },
+      "additionalProperties": {
+        "$ref": "#/$defs/Actor"
+      },
+      "default": {}
+    },
     "initial": {
       "description": "Initial child state key.",
       "type": "string"
@@ -233,6 +244,7 @@
           }
         },
         "toolChoice": {
+          "description": "Passed to the provider as-is; unlike other request fields it is NOT template-evaluated, so {{ }} expressions are not allowed here.",
           "anyOf": [
             {
               "type": "string",
@@ -250,10 +262,13 @@
                 }
               },
               "additionalProperties": false
-            },
-            { "$ref": "#/$defs/ExpressionString" }
+            }
           ]
         },
+        "reasoning": {
+          "description": "Opt into the structured-output envelope's `reasoning` field.",
+          "type": "boolean"
+        },
         "temperature": {
           "$ref": "#/$defs/ExpressionValue"
         },
@@ -301,7 +316,8 @@
         "$ref": "#/$defs/ExpressionValue"
       }
     },
-    "Tool": {
+    "Actor": {
+      "description": "A placeholder actor source: schemas describe it for authors/editors; the implementation is provided by the host.",
       "type": "object",
       "properties": {
         "description": {
@@ -314,6 +330,21 @@
           "$ref": "#/$defs/JsonSchema"
         }
       },
+      "additionalProperties": false
+    },
+    "Tool": {
+      "type": "object",
+      "properties": {
+        "description": {
+          "type": "string"
+        },
+        "inputSchema": {
+          "$ref": "#/$defs/JsonSchema"
+        },
+        "outputSchema": {
+          "$ref": "#/$defs/JsonSchema"
+        }
+      },
       "additionalProperties": {
         "$ref": "#/$defs/JsonValue"
       }
@@ -395,7 +426,8 @@
           "$ref": "#/$defs/ExpressionValue"
         },
         "meta": {
-          "$ref": "#/$defs/ExpressionObject"
+          "description": "Static state metadata, passed through verbatim. Not template-evaluated.",
+          "$ref": "#/$defs/JsonObject"
         }
       },
       "additionalProperties": false
@@ -420,9 +452,6 @@
         },
         "onError": {
           "$ref": "#/$defs/TransitionOrArray"
-        },
-        "meta": {
-          "$ref": "#/$defs/ExpressionObject"
         }
       },
       "additionalProperties": false
@@ -453,21 +482,10 @@
           ]
         },
         "guard": {
+          "description": "Either a whole-string {{ }} expression evaluated as truthy/falsy, or a named guard reference resolved against the `guards` passed to setupAgent.fromConfig(config, { guards }). Object guards ({ type, params }) are rejected by the lowering.",
           "anyOf": [
             { "$ref": "#/$defs/ExpressionString" },
-            {
-              "type": "object",
-              "required": ["type"],
-              "properties": {
-                "type": {
-                  "type": "string"
-                },
-                "params": {
-                  "$ref": "#/$defs/ExpressionValue"
-                }
-              },
-              "additionalProperties": false
-            }
+            { "$ref": "#/$defs/Identifier" }
           ]
         },
         "assign": {
@@ -484,7 +502,8 @@
           "type": "boolean"
         },
         "meta": {
-          "$ref": "#/$defs/ExpressionObject"
+          "description": "Static transition metadata, passed through verbatim. Not template-evaluated.",
+          "$ref": "#/$defs/JsonObject"
         }
       },
       "additionalProperties": false

package/skills/generate-machine/SKILL.md

@@ -0,0 +1,267 @@
+---
+name: generate-machine
+description: Author a @statelyai/agent workflow as JSON and check it before it runs. Use when asked to generate or author an agent machine, create a workflow config, write an AgentWorkflowConfig, or produce an LLM-authored state machine for an agent — and when a generated config fails Ajv validation or agent lint and needs repair.
+---
+
+# Generate an agent machine
+
+An agent machine is data. You author a JSON `AgentWorkflowConfig`, then run it through gates that all work with no API key: Ajv → `fromConfig` → lint → simulate. Do not hand back a config that has not passed all four.
+
+```
+author → validate (Ajv 2020) → lower (fromConfig) → lint (assertAgentMachine) → simulate → hand back
+```
+
+## 1. Read the schema
+
+The config shape is fixed by a shipped JSON Schema. Read it first; it is the contract.
+
+- Consuming the package: `node_modules/@statelyai/agent/agent-workflow.json` (importable as `@statelyai/agent/agent-workflow.json`)
+- In the `statelyai/agent` repo: `schemas/agent-workflow.json`
+
+## 2. Author the config
+
+Rules the runtime enforces. Each one maps to a build error or a lint diagnostic:
+
+- Every value is a JSON literal or a whole-string `"{{ }}"` expression reading a dot path on `input`, `context`, or `event`. No JavaScript.
+- Guard expressions are truthy-only: no comparisons, operators, or negation.
+- A model call is either a named `requests` entry invoked with `src: "<requestName>"`, or an inline invoke with `src: "agent.decide"` plus an `allowedEvents` list.
+- A state invoking `agent.decide` MUST handle every allowed event in its `on`.
+- An `agent.decide` invoke has no `onDone` (a decision produces no output). Use `onError` for the retries-exhausted path.
+- A request invoke reads its result via `onDone.assign` from `"{{ event.output.<field> }}"`.
+- Every path must reach a `"type": "final"` state, and each final state needs an `output` when `schemas.output` is declared.
+- Do not invent guard or action names. Only `"{{ }}"` guards, `assign`, and `emit` exist unless the host tells you which named guards/actions it implements.
+- Model refs are strings (`"openai/gpt-5.4-mini"`); the host resolves them.
+
+Reference config — decision, text request, idle human step, one final state:
+
+```json
+{
+  "id": "support-ticket",
+  "schemas": {
+    "input": {
+      "type": "object",
+      "properties": { "ticket": { "type": "string" } },
+      "required": ["ticket"]
+    },
+    "context": {
+      "type": "object",
+      "properties": {
+        "ticket": { "type": "string" },
+        "reply": { "type": "string" },
+        "resolution": { "type": "string" }
+      },
+      "required": ["ticket"]
+    },
+    "events": {
+      "ESCALATE": {
+        "type": "object",
+        "properties": { "reason": { "type": "string" } },
+        "required": ["reason"]
+      },
+      "REPLY": { "type": "object", "properties": {} },
+      "APPROVE": { "type": "object", "properties": {} },
+      "REJECT": { "type": "object", "properties": {} }
+    },
+    "output": {
+      "type": "object",
+      "properties": { "resolution": { "type": "string" }, "reply": { "type": "string" } },
+      "required": ["resolution"]
+    }
+  },
+  "context": { "ticket": "{{ input.ticket }}" },
+  "requests": {
+    "draftReply": {
+      "model": "openai/gpt-5.4-mini",
+      "system": "Draft a short, courteous support reply.",
+      "prompt": "{{ context.ticket }}",
+      "input": {
+        "type": "object",
+        "properties": { "ticket": { "type": "string" } },
+        "required": ["ticket"]
+      },
+      "output": {
+        "type": "object",
+        "properties": { "reply": { "type": "string" } },
+        "required": ["reply"]
+      }
+    }
+  },
+  "initial": "triaging",
+  "states": {
+    "triaging": {
+      "invoke": {
+        "id": "triageDecision",
+        "src": "agent.decide",
+        "input": {
+          "model": "openai/gpt-5.4-mini",
+          "system": "Decide whether this ticket needs escalation or a drafted reply.",
+          "prompt": "{{ context.ticket }}",
+          "allowedEvents": ["ESCALATE", "REPLY"],
+          "maxRetries": 2
+        },
+        "onError": { "target": "resolved", "assign": { "resolution": "escalated" } }
+      },
+      "on": {
+        "ESCALATE": { "target": "resolved", "assign": { "resolution": "escalated" } },
+        "REPLY": { "target": "drafting" }
+      }
+    },
+    "drafting": {
+      "invoke": {
+        "id": "draft",
+        "src": "draftReply",
+        "input": { "ticket": "{{ context.ticket }}" },
+        "onDone": {
+          "target": "awaitingApproval",
+          "assign": { "reply": "{{ event.output.reply }}" }
+        }
+      }
+    },
+    "awaitingApproval": {
+      "description": "Idle: nothing to do until a human approves or rejects the draft.",
+      "on": {
+        "APPROVE": { "target": "resolved", "assign": { "resolution": "replied" } },
+        "REJECT": { "target": "resolved", "assign": { "resolution": "escalated" } }
+      }
+    },
+    "resolved": {
+      "type": "final",
+      "output": { "resolution": "{{ context.resolution }}", "reply": "{{ context.reply }}" }
+    }
+  }
+}
+```
+
+## 3. Validate with Ajv 2020
+
+The workflow schema is draft 2020-12, so it needs Ajv's 2020 build. Run this before anything else touches the config.
+
+```ts
+import Ajv2020 from "ajv/dist/2020.js";
+import workflowSchema from "@statelyai/agent/agent-workflow.json";
+import type { AgentWorkflowConfig } from "@statelyai/agent";
+
+const validateWorkflow = new Ajv2020({ strict: false }).compile(workflowSchema);
+
+function validateGeneratedConfig(candidate: unknown): AgentWorkflowConfig {
+  if (validateWorkflow(candidate)) return candidate as AgentWorkflowConfig;
+  throw new Error(
+    (validateWorkflow.errors ?? [])
+      .map((error) => `${error.instancePath || "(root)"} ${error.message}`)
+      .join("\n"),
+  );
+}
+```
+
+Ajv errors carry `instancePath`, so a repair prompt can name the exact bad field.
+
+## 4. Lower with `fromConfig`
+
+`fromConfig` needs a `compileSchema` that turns the JSON Schemas _inside_ the config into Standard Schema validators. Two engines, two jobs: the 2020 build above checks the config document; this one compiles the per-field schemas. The library bundles no JSON Schema engine, by design.
+
+```ts
+import Ajv from "ajv";
+import { setupAgent, type SchemaCompiler, type StandardSchemaV1 } from "@statelyai/agent";
+
+const ajv = new Ajv({ strict: false });
+
+export const ajvCompileSchema: SchemaCompiler = (jsonSchema, name): StandardSchemaV1 => {
+  const validate = ajv.compile(jsonSchema);
+  return {
+    "~standard": {
+      version: 1,
+      vendor: "ajv",
+      validate: (value) =>
+        validate(value)
+          ? { value }
+          : {
+              issues: (validate.errors ?? []).map((e) => ({
+                message: `${name}${e.instancePath} ${e.message}`,
+              })),
+            },
+      // Expose the source JSON Schema so lint's serializability checks can read the shape.
+      jsonSchema: { input: () => jsonSchema },
+    },
+  };
+};
+
+const { machine, schemas } = setupAgent.fromConfig(config, { compileSchema: ajvCompileSchema });
+```
+
+Lowering is itself a gate: it throws on an unresolved named guard/action and on an `onDone` attached to an `agent.decide` invoke.
+
+## 5. Lint
+
+```ts
+import { assertAgentMachine, lintAgentMachine } from "@statelyai/agent";
+
+const diagnostics = lintAgentMachine(machine);
+assertAgentMachine(machine); // throws AgentLintError on error-severity findings
+```
+
+Every check applies to config-built machines, reachability included — the lowering keeps the config's transition targets, so `unreachable-state` and `missing-final` read the real graph. Do not disable checks.
+
+The one that bites most often is `decide-without-events`: an `allowedEvents` list with no matching `on` transitions produces a decision the machine can never deliver.
+
+## 6. Simulate a dry run
+
+Lint is structural. A dry run proves a path actually settles. No API key needed.
+
+```ts
+import { simulateAgent } from "@statelyai/agent";
+
+const dryRun = await simulateAgent(machine, {
+  input: { ticket: "" },
+  script: {
+    decisions: { "agent.decide": [{ type: "REPLY" }] },
+    text: { draftReply: [{ reply: "" }] },
+  },
+});
+// dryRun.status: 'done' | 'idle' | 'exhausted'
+```
+
+Derive the script from the config rather than guessing: take the first entry of each decision's `allowedEvents`, and stub each request's output from its declared `output` schema (`""` for string, `0` for number, `[]` for array, recurse on `properties`).
+
+- `'exhausted'` → the machine loops. Reject it.
+- `'idle'` → it stopped at a human step. Expected when the config has one.
+- To cover every branch instead of one path, use `explorePaths` / `canReach`.
+
+## 7. Repair loop
+
+Every gate throws with a message naming the offending field, state, or path. Feed that message back verbatim and regenerate:
+
+```ts
+for (let attempt = 0; attempt < 3; attempt++) {
+  try {
+    return buildAndVet(await author({ system, prompt }));
+  } catch (error) {
+    prompt = `${originalTask}\n\nYour previous config was rejected:\n${(error as Error).message}\nReturn a corrected config.`;
+  }
+}
+```
+
+Keep the cap at ~3. A config that fails three schema-shaped repairs is usually asking for something the data form cannot express — author it in TypeScript with `setupAgent` instead.
+
+## 8. Hand back
+
+Deliver the config JSON plus how to run it:
+
+```ts
+import { runAgent } from "@statelyai/agent";
+import { createAiSdkExecutors } from "@statelyai/agent/ai-sdk";
+
+const result = await runAgent(machine, {
+  input: { ticket: "Export downloads a 0-byte CSV on Safari." },
+  executors: createAiSdkExecutors({ resolveModel }),
+});
+```
+
+Say which gates passed, list any warning-severity lint diagnostics, and report the dry-run status. Model refs are strings, so the host supplies `resolveModel`.
+
+## Known limits
+
+- **Named guards and actions are host-resolved.** A config carries no functions. `guard: "isReady"` only works if the host passes an `isReady` implementation to `fromConfig`; an unresolved name is a build-time throw. Either list the host's names in the prompt or forbid named guards/actions entirely.
+- **Expressions are dot-path templates only.** `"{{ context.a.b }}"` — no comparisons, no arithmetic, no method calls, no partial interpolation inside a larger string.
+- **Ajv validity is not semantic validity.** A config can validate and still invoke a request that does not exist or route to a state that solves nothing. That is what lint and simulate are for.
+- **A dry run covers one path.** Use `explorePaths` when the branch structure matters.
+- **Model refs and tool names are unchecked strings.** They resolve at run time, in the host.

package/dist/adapter.cjs

@@ -1,15 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_events = require("./events-CRQj3VtP.cjs");
-exports.bindRequestExecutor = require_events.bindRequestExecutor;
-exports.buildEnvelopeSchema = require_events.buildEnvelopeSchema;
-exports.getAgentOutputMode = require_events.getAgentOutputMode;
-exports.getJsonSchema = require_events.getJsonSchema;
-exports.getJsonSchemaSync = require_events.getJsonSchemaSync;
-exports.getMachineStructuralHash = require_events.getMachineStructuralHash;
-exports.isStandardSchema = require_events.isStandardSchema;
-exports.isStructuredOutputSchema = require_events.isStructuredOutputSchema;
-exports.matchesEventPattern = require_events.matchesEventPattern;
-exports.parseModelRef = require_events.parseModelRef;
-exports.parseOutput = require_events.parseOutput;
-exports.parseStructuredEnvelope = require_events.parseStructuredEnvelope;
-exports.validateSchemaSync = require_events.validateSchemaSync;

package/dist/adapter.d.cts

@@ -1,4 +0,0 @@
-import { C as StandardSchemaV1 } from "./types-C9QiMjre.cjs";
-import { D as parseOutput, E as parseModelRef, J as matchesEventPattern, O as parseStructuredEnvelope, S as buildEnvelopeSchema, T as isStructuredOutputSchema, a as AgentRequestExecutorInfo, h as TextLogic, i as AgentRequestExecutor, l as AgentTextRequest, m as StructuredOutputEnvelope, o as AgentRequestExecutorResult, r as AgentOutputMode, w as getAgentOutputMode, x as bindRequestExecutor } from "./text-logic-Ckhr2kKC.cjs";
-import { a as getMachineStructuralHash, f as validateSchemaSync, i as getJsonSchemaSync, r as getJsonSchema, s as isStandardSchema } from "./utils-BYqT_Dyv.cjs";
-export { type AgentOutputMode, type AgentRequestExecutor, type AgentRequestExecutorInfo, type AgentRequestExecutorResult, type AgentTextRequest, type StandardSchemaV1, type StructuredOutputEnvelope, type TextLogic, bindRequestExecutor, buildEnvelopeSchema, getAgentOutputMode, getJsonSchema, getJsonSchemaSync, getMachineStructuralHash, isStandardSchema, isStructuredOutputSchema, matchesEventPattern, parseModelRef, parseOutput, parseStructuredEnvelope, validateSchemaSync };

package/dist/adapter.d.mts

@@ -1,4 +0,0 @@
-import { C as StandardSchemaV1 } from "./types-qm00QF91.mjs";
-import { D as parseOutput, E as parseModelRef, J as matchesEventPattern, O as parseStructuredEnvelope, S as buildEnvelopeSchema, T as isStructuredOutputSchema, a as AgentRequestExecutorInfo, h as TextLogic, i as AgentRequestExecutor, l as AgentTextRequest, m as StructuredOutputEnvelope, o as AgentRequestExecutorResult, r as AgentOutputMode, w as getAgentOutputMode, x as bindRequestExecutor } from "./text-logic-CaKqgX4Y.mjs";
-import { a as getMachineStructuralHash, f as validateSchemaSync, i as getJsonSchemaSync, r as getJsonSchema, s as isStandardSchema } from "./utils-Do5wIJrh.mjs";
-export { type AgentOutputMode, type AgentRequestExecutor, type AgentRequestExecutorInfo, type AgentRequestExecutorResult, type AgentTextRequest, type StandardSchemaV1, type StructuredOutputEnvelope, type TextLogic, bindRequestExecutor, buildEnvelopeSchema, getAgentOutputMode, getJsonSchema, getJsonSchemaSync, getMachineStructuralHash, isStandardSchema, isStructuredOutputSchema, matchesEventPattern, parseModelRef, parseOutput, parseStructuredEnvelope, validateSchemaSync };

package/dist/adapter.mjs

@@ -1,2 +0,0 @@
-import { F as getMachineStructuralHash, H as validateSchemaSync, L as isStandardSchema, N as getJsonSchema, P as getJsonSchemaSync, b as parseOutput, d as buildEnvelopeSchema, g as isStructuredOutputSchema, h as getAgentOutputMode, r as matchesEventPattern, u as bindRequestExecutor, x as parseStructuredEnvelope, y as parseModelRef } from "./events-JiVPYrct.mjs";
-export { bindRequestExecutor, buildEnvelopeSchema, getAgentOutputMode, getJsonSchema, getJsonSchemaSync, getMachineStructuralHash, isStandardSchema, isStructuredOutputSchema, matchesEventPattern, parseModelRef, parseOutput, parseStructuredEnvelope, validateSchemaSync };