dialai 1.5.0 → 1.5.1

package/.claude/specs/poll-gate.md

@@ -0,0 +1,269 @@
+# Poll Gate Spec
+
+A poll is a gate that fans a question out to N diverse LLM models, collects their answers, and uses an arbiter to summarize consensus. The gate is the reusable infrastructure — which models, what judge, what threshold. Each question is just another invocation of that gate.
+
+```typescript
+// Create the gate once — this is the HOW
+await createGate({
+  gateId: "10-model-poll",
+  prompt: "Answer the following question accurately and concisely.",
+  transitions: { resolved: "Consensus answer found" },
+  specialists: [
+    { specialistId: "claude-sonnet",  role: "proposer", modelId: "anthropic/claude-sonnet-4-20250514" },
+    { specialistId: "gpt-4o",        role: "proposer", modelId: "openai/gpt-4o" },
+    { specialistId: "gemini-flash",  role: "proposer", modelId: "google/gemini-2.0-flash-001" },
+    { specialistId: "llama-70b",     role: "proposer", modelId: "meta-llama/llama-3.1-70b-instruct" },
+    { specialistId: "mistral-large", role: "proposer", modelId: "mistralai/mistral-large-2411" },
+    { specialistId: "deepseek-v3",   role: "proposer", modelId: "deepseek/deepseek-chat-v3-0324" },
+    { specialistId: "qwen-72b",      role: "proposer", modelId: "qwen/qwen-2.5-72b-instruct" },
+    { specialistId: "cohere-r-plus", role: "proposer", modelId: "cohere/command-r-plus-08-2024" },
+    { specialistId: "claude-haiku",  role: "proposer", modelId: "anthropic/claude-haiku-4-5-20251001" },
+    { specialistId: "gpt-4o-mini",   role: "proposer", modelId: "openai/gpt-4o-mini" },
+    { specialistId: "judge",         role: "arbiter" }
+  ],
+  consensusThreshold: 0.5,
+});
+
+// Ask questions — each is an invocation of the same gate
+const r1 = await invokeGate("10-model-poll", { promptSuffix: "Who won the 2025 World Series?" });
+const r2 = await invokeGate("10-model-poll", { promptSuffix: "What is the capital of Australia?" });
+// r1.reasoning → "7/10 said Dodgers because X, 3/10 said Yankees because Y"
+```
+
+## How It Maps to DIAL 1.5
+
+Built entirely from existing primitives. No engine, strategy, or store changes.
+
+| Poll concept | DIAL 1.5 primitive |
+|---|---|
+| Gate definition | `MachineDefinition` (synthetic 2-state machine) |
+| Gate identity (`gateId`) | `machineName` — scopes alignment + exemplars |
+| Invoking a gate | `createSession` + `submitProposal` × N + `submitArbitration` |
+| A question | `promptSuffix` appended to gate prompt |
+| An evaluation | A session with one round |
+| Each model's answer | `submitProposal({ sessionId, specialistId })` |
+| The judge | `submitArbitration({ sessionId })` via custom `strategyFn` |
+| Human correction | `submitArbitration({ sessionId, specialistId: human, transitionName })` |
+| Learning | Alignment + exemplars accumulate under `gateId` across all questions |
+
+The synthetic machine has two states:
+
+```
+evaluate  ──resolved──▶  done
+```
+
+Every proposer picks `resolved` (there's only one transition). Their answer goes in `reasoning`. The arbiter reads all proposals' reasoning and determines consensus.
+
+## What Gets Built
+
+### New file: `src/dialai/gate.ts`
+
+Two functions. Everything else is reused.
+
+#### `createGate(definition: GateDefinition): GateDefinition`
+
+Stores the gate definition in an in-memory registry (Map). Returns the definition. Phase 2 moves this to the store.
+
+#### `invokeGate(gateId, context, runtimeSpecialists?): GateResult`
+
+1. Look up gate definition from registry.
+2. Build synthetic `MachineDefinition`:
+   - `machineName` = `gateId` (so alignment/exemplars scope to gate)
+   - `initialState` = `"evaluate"`, `goalState` = `"done"`
+   - `evaluate` state: prompt = `gate.prompt + context.promptSuffix`, transitions all target `"done"`, specialists from gate definition, threshold from gate
+   - `done` state: empty (terminal)
+3. `createSession(machine, context.metaJson)` — session persisted in store.
+4. Register specialists:
+   - From `runtimeSpecialists` if provided (for function refs that can't serialize).
+   - From `gate.specialists` (strategyFnName-based auto-registration, same as `runSession` does).
+   - Defaults (`firstAvailable` proposer + `firstProposal` arbiter) if none.
+5. `Promise.all` → all proposers invoked concurrently via `submitProposal`.
+6. `submitArbitration({ sessionId })` — arbiter evaluates all proposals.
+7. Return `GateResult`.
+
+### New types in `types.ts`
+
+```typescript
+interface GateDefinition {
+  gateId: string;
+  prompt?: string;
+  transitions: Record<string, string | TransitionDefinition>;
+  specialists?: SpecialistDefinition[];
+  consensusThreshold?: number;
+}
+
+interface GateContext {
+  metaJson?: Record<string, unknown>;
+  history?: TransitionRecord[];
+  promptSuffix?: string;
+}
+
+interface GateResult {
+  evaluationId: string;
+  gateId: string;
+  transitionName: string | null;
+  reasoning: string;
+  needsHuman: boolean;
+  proposals: Proposal[];
+  metaJson?: Record<string, unknown>;
+  costUSD?: number;
+  latencyMsec?: number;
+}
+```
+
+All field types are existing DIAL types. Three types total.
+
+### Registry helpers
+
+```typescript
+createGate(definition: GateDefinition): GateDefinition
+getGate(gateId: string): GateDefinition
+listGates(): GateDefinition[]
+deleteGate(gateId: string): void
+clearGateRegistry(): void
+```
+
+In-memory Map for Phase 1. Phase 2 adds store persistence.
+
+### Exports in `index.ts`
+
+```typescript
+export type { GateDefinition, GateContext, GateResult } from "./types.js";
+export { createGate, getGate, listGates, deleteGate, clearGateRegistry, invokeGate } from "./gate.js";
+```
+
+## The LLM-as-Judge Arbiter
+
+The judge is a custom `strategyFn` on the arbiter — no framework changes needed. The consumer provides it via `runtimeSpecialists`:
+
+```typescript
+const result = await invokeGate("10-model-poll", {
+  promptSuffix: "Who won the 2025 World Series?"
+}, {
+  arbiter: {
+    specialistId: "judge",
+    machineName: "10-model-poll",
+    strategyFn: async (ctx: ArbiterContext): Promise<ArbiterStrategyResult> => {
+      const responses = ctx.proposals.map((p, i) =>
+        `Model ${i + 1} (${p.specialistId}): ${p.reasoning}`
+      ).join("\n\n");
+
+      const { content } = await callLlm(
+        "anthropic/claude-sonnet-4-20250514",
+        "You are a consensus judge. Read all model responses to a question. " +
+        "Determine if there is meaningful agreement. " +
+        "Respond with JSON: { \"consensusReached\": true/false, " +
+        "\"winningProposalId\": \"<proposalId of best response>\", " +
+        "\"reasoning\": \"<narrative: how many agreed, what they said, why>\" }",
+        `Question: ${ctx.prompt}\n\n${ctx.proposals.length} models responded:\n\n${responses}`
+      );
+
+      const parsed = JSON.parse(content);
+      return {
+        consensusReached: parsed.consensusReached,
+        winningProposalId: parsed.winningProposalId,
+        reasoning: parsed.reasoning,
+      };
+    },
+  },
+});
+```
+
+The judge reads all N proposals, clusters the answers semantically ("LA Dodgers" = "The Dodgers" = "Los Angeles Dodgers"), produces a narrative summary ("7/10 said Dodgers because they won in 5 games, 2 said Yankees, 1 said Mets"), and picks the best-articulated winning response.
+
+This is a regular custom arbiter. The DIAL framework doesn't need to know it's backed by an LLM.
+
+## How a Question Flows Through
+
+```
+1. Consumer calls: invokeGate("10-model-poll", { promptSuffix: "Who won the 2025 WS?" })
+
+2. invokeGate builds synthetic machine:
+   machineName: "10-model-poll"
+   states:
+     evaluate:
+       prompt: "Answer the following question accurately and concisely.\n\nWho won the 2025 WS?"
+       transitions: { resolved: { target: "done", description: "Consensus answer found" } }
+     done: {}
+
+3. createSession("10-model-poll", {}) → session with sessionId + roundId
+
+4. Register 10 proposers + 1 arbiter under machineName "10-model-poll"
+
+5. Promise.all → 10 concurrent submitProposal calls
+   Each proposer:
+   - Gets ProposerContext with prompt, transitions: { resolved → done }, exemplars
+   - LLM mode: contextFn builds context → callLlm → parses response
+   - Returns { transitionName: "resolved", toState: "done", reasoning: "The LA Dodgers won..." }
+   - Stored as Proposal in the round
+
+6. submitArbitration({ sessionId })
+   - Loads all 10 proposals
+   - Calls judge arbiter strategyFn
+   - Judge LLM reads all 10 answers, determines consensus
+   - Returns { consensusReached: true, winningProposalId: "...", reasoning: "7/10 said Dodgers..." }
+   - If consensus: executes transition, session moves to "done"
+   - If no consensus: returns needsHuman
+
+7. GateResult returned:
+   { evaluationId, gateId: "10-model-poll", transitionName: "resolved",
+     reasoning: "7/10 said Dodgers...", needsHuman: false,
+     proposals: [all 10] }
+```
+
+## Human Override
+
+When the judge says `needsHuman` (or a human disagrees with the consensus), the consumer can call `submitArbitration` directly on the session (the `evaluationId` in `GateResult` maps to the underlying `sessionId`):
+
+```typescript
+const result = await invokeGate("10-model-poll", { promptSuffix: "Who won the 2025 WS?" });
+
+if (result.needsHuman) {
+  // Register a human specialist (once)
+  await registerProposer({
+    specialistId: "human-reviewer",
+    machineName: "10-model-poll",
+    isHuman: true,
+    strategyFnName: "firstAvailable",
+  });
+
+  // Human forces the answer using the evaluationId as sessionId
+  await submitArbitration({
+    sessionId: result.evaluationId,
+    specialistId: "human-reviewer",
+    transitionName: "resolved",
+    reasoning: "The correct answer is the LA Dodgers. They won in 5 games against the Yankees.",
+  });
+}
+```
+
+This triggers the standard DIAL learning cycle:
+- Alignment updated for all 10 proposers (did they agree with the human?)
+- Exemplar captured (question context + all proposals + human's answer)
+- Future invocations include this exemplar as a few-shot example
+
+Over time, the gate collapses: models that consistently agree with humans earn high alignment, the arbiter's job gets easier, and eventually a champion model handles questions autonomously.
+
+## What Doesn't Change
+
+Nothing. The gate is built entirely from existing DIAL 1.5 primitives:
+
+- `createSession` / `submitProposal` / `submitArbitration` — unchanged
+- `registerProposer` / `registerArbiter` — unchanged
+- Alignment tracking — unchanged (scoped by `machineName` = `gateId`)
+- Exemplar system — unchanged (scoped by `machineName` = `gateId`)
+- Store interface — unchanged
+- Engine / tick loop — not used (gates use `Promise.all` for parallel fan-out)
+- LLM integration — unchanged (proposers use `contextFn + modelId`, judge uses `callLlm` inside a `strategyFn`)
+- Strategies — unchanged (consumer provides custom `strategyFn` for the judge)
+
+## Files Touched
+
+| File | Change |
+|---|---|
+| `src/dialai/types.ts` | Add 3 types: `GateDefinition`, `GateContext`, `GateResult` |
+| `src/dialai/gate.ts` | **New file** — `createGate`, `invokeGate`, registry helpers |
+| `src/dialai/index.ts` | Export new types + gate functions |
+| `tests/unit/gate.test.ts` | Gate tests |
+
+Zero changes to `api.ts`, `engine.ts`, `llm.ts`, `strategies.ts`, `store.ts`, `alignment.ts`, `exemplars.ts`.

package/dist/dialai/asl/choice-extractor.d.ts

@@ -0,0 +1,60 @@
+import type { TransitionOption } from "./types.js";
+interface ChoiceRule {
+    Variable?: string;
+    StringEquals?: string;
+    StringEqualsPath?: string;
+    StringLessThan?: string;
+    StringLessThanPath?: string;
+    StringGreaterThan?: string;
+    StringGreaterThanPath?: string;
+    StringLessThanEquals?: string;
+    StringLessThanEqualsPath?: string;
+    StringGreaterThanEquals?: string;
+    StringGreaterThanEqualsPath?: string;
+    StringMatches?: string;
+    NumericEquals?: number;
+    NumericEqualsPath?: string;
+    NumericLessThan?: number;
+    NumericLessThanPath?: string;
+    NumericGreaterThan?: number;
+    NumericGreaterThanPath?: string;
+    NumericLessThanEquals?: number;
+    NumericLessThanEqualsPath?: string;
+    NumericGreaterThanEquals?: number;
+    NumericGreaterThanEqualsPath?: string;
+    BooleanEquals?: boolean;
+    BooleanEqualsPath?: string;
+    TimestampEquals?: string;
+    TimestampEqualsPath?: string;
+    TimestampLessThan?: string;
+    TimestampLessThanPath?: string;
+    TimestampGreaterThan?: string;
+    TimestampGreaterThanPath?: string;
+    TimestampLessThanEquals?: string;
+    TimestampLessThanEqualsPath?: string;
+    TimestampGreaterThanEquals?: string;
+    TimestampGreaterThanEqualsPath?: string;
+    IsNull?: boolean;
+    IsPresent?: boolean;
+    IsNumeric?: boolean;
+    IsString?: boolean;
+    IsBoolean?: boolean;
+    IsTimestamp?: boolean;
+    And?: ChoiceRule[];
+    Or?: ChoiceRule[];
+    Not?: ChoiceRule;
+    Next?: string;
+}
+interface ChoiceState {
+    Type: "Choice";
+    Comment?: string;
+    Choices: ChoiceRule[];
+    Default?: string;
+}
+/**
+ * Extract transition options from a Choice state.
+ * For $.transition StringEquals rules, uses the value as the transition name.
+ */
+export declare function extractTransitions(choiceState: ChoiceState): TransitionOption[];
+export {};
+//# sourceMappingURL=choice-extractor.d.ts.map

package/dist/dialai/asl/choice-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"choice-extractor.d.ts","sourceRoot":"","sources":["../../../src/dialai/asl/choice-extractor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEpE,UAAU,UAAU;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,2BAA2B,CAAC,EAAE,MAAM,CAAC;IACrC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,4BAA4B,CAAC,EAAE,MAAM,CAAC;IACtC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,2BAA2B,CAAC,EAAE,MAAM,CAAC;IACrC,0BAA0B,CAAC,EAAE,MAAM,CAAC;IACpC,8BAA8B,CAAC,EAAE,MAAM,CAAC;IACxC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,GAAG,CAAC,EAAE,UAAU,EAAE,CAAC;IACnB,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC;IAClB,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,UAAU,WAAW;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,WAAW,GAAG,gBAAgB,EAAE,CA0B/E"}

package/dist/dialai/asl/choice-extractor.js

@@ -0,0 +1,131 @@
+/**
+ * Extract transition options from a Choice state.
+ * For $.transition StringEquals rules, uses the value as the transition name.
+ */
+export function extractTransitions(choiceState) {
+    const transitions = [];
+    for (const rule of choiceState.Choices) {
+        const condition = extractCondition(rule);
+        const name = deriveTransitionName(rule, condition);
+        if (rule.Next) {
+            transitions.push({
+                name,
+                targetState: rule.Next,
+                condition,
+            });
+        }
+    }
+    // Add Default as a fallback option
+    if (choiceState.Default) {
+        transitions.push({
+            name: "default",
+            targetState: choiceState.Default,
+            condition: { operator: "default" },
+        });
+    }
+    return transitions;
+}
+/**
+ * Derive a human-readable transition name from the rule.
+ * For $.transition StringEquals, use the value.
+ * Otherwise, generate a descriptive name.
+ */
+function deriveTransitionName(rule, condition) {
+    // Special case: $.transition StringEquals "value" -> use "value" as name
+    if (rule.Variable === "$.transition" &&
+        rule.StringEquals !== undefined) {
+        return rule.StringEquals;
+    }
+    // For compound rules, try to find a $.transition StringEquals in children
+    if (condition.children) {
+        for (const child of condition.children) {
+            if (child.variable === "$.transition" &&
+                child.operator === "StringEquals" &&
+                typeof child.value === "string") {
+                return child.value;
+            }
+        }
+    }
+    // Generate name from condition
+    if (condition.variable && condition.value !== undefined) {
+        return `${condition.operator}_${String(condition.value)}`;
+    }
+    return `to_${rule.Next}`;
+}
+/**
+ * Extract a ChoiceCondition from a rule.
+ */
+function extractCondition(rule) {
+    // Compound rules
+    if (rule.And) {
+        return {
+            operator: "And",
+            children: rule.And.map(extractCondition),
+        };
+    }
+    if (rule.Or) {
+        return {
+            operator: "Or",
+            children: rule.Or.map(extractCondition),
+        };
+    }
+    if (rule.Not) {
+        return {
+            operator: "Not",
+            children: [extractCondition(rule.Not)],
+        };
+    }
+    // Simple comparison operators
+    const operators = [
+        "StringEquals",
+        "StringEqualsPath",
+        "StringLessThan",
+        "StringLessThanPath",
+        "StringGreaterThan",
+        "StringGreaterThanPath",
+        "StringLessThanEquals",
+        "StringLessThanEqualsPath",
+        "StringGreaterThanEquals",
+        "StringGreaterThanEqualsPath",
+        "StringMatches",
+        "NumericEquals",
+        "NumericEqualsPath",
+        "NumericLessThan",
+        "NumericLessThanPath",
+        "NumericGreaterThan",
+        "NumericGreaterThanPath",
+        "NumericLessThanEquals",
+        "NumericLessThanEqualsPath",
+        "NumericGreaterThanEquals",
+        "NumericGreaterThanEqualsPath",
+        "BooleanEquals",
+        "BooleanEqualsPath",
+        "TimestampEquals",
+        "TimestampEqualsPath",
+        "TimestampLessThan",
+        "TimestampLessThanPath",
+        "TimestampGreaterThan",
+        "TimestampGreaterThanPath",
+        "TimestampLessThanEquals",
+        "TimestampLessThanEqualsPath",
+        "TimestampGreaterThanEquals",
+        "TimestampGreaterThanEqualsPath",
+        "IsNull",
+        "IsPresent",
+        "IsNumeric",
+        "IsString",
+        "IsBoolean",
+        "IsTimestamp",
+    ];
+    for (const op of operators) {
+        if (rule[op] !== undefined) {
+            return {
+                variable: rule.Variable,
+                operator: op,
+                value: rule[op],
+            };
+        }
+    }
+    return { operator: "unknown" };
+}
+//# sourceMappingURL=choice-extractor.js.map

package/dist/dialai/asl/choice-extractor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"choice-extractor.js","sourceRoot":"","sources":["../../../src/dialai/asl/choice-extractor.ts"],"names":[],"mappings":"AAwDA;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAAC,WAAwB;IACzD,MAAM,WAAW,GAAuB,EAAE,CAAC;IAE3C,KAAK,MAAM,IAAI,IAAI,WAAW,CAAC,OAAO,EAAE,CAAC;QACvC,MAAM,SAAS,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;QACzC,MAAM,IAAI,GAAG,oBAAoB,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QAEnD,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YACd,WAAW,CAAC,IAAI,CAAC;gBACf,IAAI;gBACJ,WAAW,EAAE,IAAI,CAAC,IAAI;gBACtB,SAAS;aACV,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,mCAAmC;IACnC,IAAI,WAAW,CAAC,OAAO,EAAE,CAAC;QACxB,WAAW,CAAC,IAAI,CAAC;YACf,IAAI,EAAE,SAAS;YACf,WAAW,EAAE,WAAW,CAAC,OAAO;YAChC,SAAS,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE;SACnC,CAAC,CAAC;IACL,CAAC;IAED,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;;;GAIG;AACH,SAAS,oBAAoB,CAAC,IAAgB,EAAE,SAA0B;IACxE,yEAAyE;IACzE,IACE,IAAI,CAAC,QAAQ,KAAK,cAAc;QAChC,IAAI,CAAC,YAAY,KAAK,SAAS,EAC/B,CAAC;QACD,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED,0EAA0E;IAC1E,IAAI,SAAS,CAAC,QAAQ,EAAE,CAAC;QACvB,KAAK,MAAM,KAAK,IAAI,SAAS,CAAC,QAAQ,EAAE,CAAC;YACvC,IACE,KAAK,CAAC,QAAQ,KAAK,cAAc;gBACjC,KAAK,CAAC,QAAQ,KAAK,cAAc;gBACjC,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ,EAC/B,CAAC;gBACD,OAAO,KAAK,CAAC,KAAK,CAAC;YACrB,CAAC;QACH,CAAC;IACH,CAAC;IAED,+BAA+B;IAC/B,IAAI,SAAS,CAAC,QAAQ,IAAI,SAAS,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;QACxD,OAAO,GAAG,SAAS,CAAC,QAAQ,IAAI,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;IAC5D,CAAC;IAED,OAAO,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;AAC3B,CAAC;AAED;;GAEG;AACH,SAAS,gBAAgB,CAAC,IAAgB;IACxC,iBAAiB;IACjB,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;QACb,OAAO;YACL,QAAQ,EAAE,KAAK;YACf,QAAQ,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,gBAAgB,CAAC;SACzC,CAAC;IACJ,CAAC;IACD,IAAI,IAAI,CAAC,EAAE,EAAE,CAAC;QACZ,OAAO;YACL,QAAQ,EAAE,IAAI;YACd,QAAQ,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,gBAAgB,CAAC;SACxC,CAAC;IACJ,CAAC;IACD,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;QACb,OAAO;YACL,QAAQ,EAAE,KAAK;YACf,QAAQ,EAAE,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;SACvC,CAAC;IACJ,CAAC;IAED,8BAA8B;IAC9B,MAAM,SAAS,GAAG;QAChB,cAAc;QACd,kBAAkB;QAClB,gBAAgB;QAChB,oBAAoB;QACpB,mBAAmB;QACnB,uBAAuB;QACvB,sBAAsB;QACtB,0BAA0B;QAC1B,yBAAyB;QACzB,6BAA6B;QAC7B,eAAe;QACf,eAAe;QACf,mBAAmB;QACnB,iBAAiB;QACjB,qBAAqB;QACrB,oBAAoB;QACpB,wBAAwB;QACxB,uBAAuB;QACvB,2BAA2B;QAC3B,0BAA0B;QAC1B,8BAA8B;QAC9B,eAAe;QACf,mBAAmB;QACnB,iBAAiB;QACjB,qBAAqB;QACrB,mBAAmB;QACnB,uBAAuB;QACvB,sBAAsB;QACtB,0BAA0B;QAC1B,yBAAyB;QACzB,6BAA6B;QAC7B,4BAA4B;QAC5B,gCAAgC;QAChC,QAAQ;QACR,WAAW;QACX,WAAW;QACX,UAAU;QACV,WAAW;QACX,aAAa;KACL,CAAC;IAEX,KAAK,MAAM,EAAE,IAAI,SAAS,EAAE,CAAC;QAC3B,IAAI,IAAI,CAAC,EAAE,CAAC,KAAK,SAAS,EAAE,CAAC;YAC3B,OAAO;gBACL,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,QAAQ,EAAE,EAAE;gBACZ,KAAK,EAAE,IAAI,CAAC,EAAE,CAAC;aAChB,CAAC;QACJ,CAAC;IACH,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC;AACjC,CAAC"}

package/dist/dialai/asl/index.d.ts

@@ -0,0 +1,6 @@
+export type { DIALStateMachine, StateResult, TransitionOption, ChoiceCondition, TaskHandler, InterpreterConfig, ExecutionContext, } from "./types.js";
+export { validateDIALStateMachine, parseDIALStateMachine, type ValidationResult, } from "./validator.js";
+export { extractTransitions } from "./choice-extractor.js";
+export { executeState } from "./interpreter.js";
+export { getJsonPathValue, setJsonPathValue, applyInputPath, applyOutputPath, applyResultPath, applyParameters, applyResultSelector, } from "./jsonpath.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/dialai/asl/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/dialai/asl/index.ts"],"names":[],"mappings":"AACA,YAAY,EACV,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,eAAe,EACf,WAAW,EACX,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,wBAAwB,EACxB,qBAAqB,EACrB,KAAK,gBAAgB,GACtB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAG3D,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAGhD,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,eAAe,EACf,eAAe,EACf,eAAe,EACf,mBAAmB,GACpB,MAAM,eAAe,CAAC"}

package/dist/dialai/asl/index.js

@@ -0,0 +1,9 @@
+// Validator
+export { validateDIALStateMachine, parseDIALStateMachine, } from "./validator.js";
+// Choice extractor
+export { extractTransitions } from "./choice-extractor.js";
+// Interpreter
+export { executeState } from "./interpreter.js";
+// JSONPath utilities
+export { getJsonPathValue, setJsonPathValue, applyInputPath, applyOutputPath, applyResultPath, applyParameters, applyResultSelector, } from "./jsonpath.js";
+//# sourceMappingURL=index.js.map

package/dist/dialai/asl/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/dialai/asl/index.ts"],"names":[],"mappings":"AAWA,YAAY;AACZ,OAAO,EACL,wBAAwB,EACxB,qBAAqB,GAEtB,MAAM,gBAAgB,CAAC;AAExB,mBAAmB;AACnB,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE3D,cAAc;AACd,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEhD,qBAAqB;AACrB,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,eAAe,EACf,eAAe,EACf,eAAe,EACf,mBAAmB,GACpB,MAAM,eAAe,CAAC"}

package/dist/dialai/asl/interpreter.d.ts

@@ -0,0 +1,6 @@
+import type { DIALStateMachine, StateResult, InterpreterConfig, ExecutionContext } from "./types.js";
+/**
+ * Execute a single state in the state machine.
+ */
+export declare function executeState(machine: DIALStateMachine, stateName: string, context: ExecutionContext, config?: InterpreterConfig): Promise<StateResult>;
+//# sourceMappingURL=interpreter.d.ts.map

package/dist/dialai/asl/interpreter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpreter.d.ts","sourceRoot":"","sources":["../../../src/dialai/asl/interpreter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,WAAW,EACX,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAsCpB;;GAEG;AACH,wBAAsB,YAAY,CAChC,OAAO,EAAE,gBAAgB,EACzB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,gBAAgB,EACzB,MAAM,GAAE,iBAAsB,GAC7B,OAAO,CAAC,WAAW,CAAC,CA0BtB"}