taias 0.4.1 → 0.6.0

package/README.md

@@ -25,14 +25,14 @@ npm install taias
 
 ## Quick Start
 
-**1. Define a flow** — Map out your tool sequence:
+**1. Define a flow** — Express your logic as structured data:
 
 ```ts
 import { defineFlow, createTaias } from "taias";
 
 const flow = defineFlow("onboard", (flow) => {
-  flow.step("scan_repo", () => ({ nextTool: "configure_app" }));
-  flow.step("configure_app", () => ({ nextTool: "deploy" }));
+  flow.step({ toolName: "scan_repo" }, { nextTool: "configure_app" });
+  flow.step({ toolName: "configure_app" }, { nextTool: "deploy" });
 });
 ```
 
@@ -53,7 +53,11 @@ const taias = createTaias({
 ```ts
 // Inside your tool handler
 
-const affordances = await taias.resolve({ toolName: "scan_repo" });
+const affordances = await taias.resolve({
+  toolName: "scan_repo",
+  params: input,  // Pass tool input parameters (optional)
+  result: { language: scanResult.language },  // Pass tool output (optional)
+});
 
 let message = "Scan successful!";
 
@@ -76,13 +80,11 @@ return {
 
 ### `defineFlow(flowId, builder)`
 
-Creates a flow definition.
+Creates a flow definition. Each step is a logic statement: a match condition paired with a decision.
 
 ```ts
 const myFlow = defineFlow("my_flow", (flow) => {
-  flow.step("tool_name", (ctx) => ({
-    nextTool: "next_tool_name",
-  }));
+  flow.step({ toolName: "tool_name" }, { nextTool: "next_tool_name" });
 });
 ```
 
@@ -115,10 +117,14 @@ const taias = createTaias({
 
 ### `taias.resolve(ctx)`
 
-Resolves a tool call to get the suggested next step. Advice text to send the LLM is generated based on the `nextTool` specified in your step handler.
+Resolves a tool call to get the decision and its manifestations. Evaluates the matching logic statement and produces advice text, the decision object, and UI selections.
 
 ```ts
-const affordances = await taias.resolve({ toolName: "scan_repo" });
+const affordances = await taias.resolve({
+  toolName: "scan_repo",
+  params: { repoUrl: "https://github.com/..." },  // optional
+  result: { language: "python", hasConfig: true },  // optional
+});
 // affordances.advice → "FOR THE BEST USER EXPERIENCE, TELL THE USER TO USE THE configure_app TOOL NEXT!!!!!"
 ```
 
@@ -126,10 +132,12 @@ const affordances = await taias.resolve({ toolName: "scan_repo" });
 
 **Parameters:**
 - `ctx.toolName` - The name of the tool being called
+- `ctx.params` - The input parameters of the tool call (optional)
+- `ctx.result` - The output of the tool's execution (optional)
 
 **Returns:** `Affordances | null`
-- Returns an `Affordances` object with `advice` (and more) if a matching step is found
-- Returns `null` if no step matches or handler returns null
+- Returns an `Affordances` object with `advice`, `decision`, and `selections` if a matching step is found
+- Returns `null` if no step matches
 
 See the [full documentation](https://taias.xyz/docs) for complete API reference and types.
 
@@ -140,12 +148,12 @@ See the [full documentation](https://taias.xyz/docs) for complete API reference
 
 When `devMode: true`, Taias performs additional validation:
 
-1. **Duplicate toolName detection** — Throws an error if a flow defines the same tool name twice:
+1. **Duplicate match condition detection** — Throws an error if a flow defines two steps with the same match condition:
    ```
-   Taias: Duplicate step for tool 'scan_repo' in flow 'onboard_repo'. Only one handler per tool is supported.
+   Taias: Duplicate match condition 'scan_repo' in flow 'onboard_repo'. Each step must have a unique match condition.
    ```
 
-2. **Empty nextTool warning** — Logs a warning if a handler returns empty nextTool:
+2. **Empty nextTool warning** — Logs a warning if a logic statement has an empty nextTool:
    ```
    Taias: nextTool for tool 'scan_repo' is empty.
    ```

package/dist/index.cjs

@@ -31,8 +31,19 @@ module.exports = __toCommonJS(index_exports);
 function defineFlow(flowId, builder) {
   const steps = [];
   const flowBuilder = {
-    step(toolName, handler) {
-      steps.push({ toolName, handler });
+    step(match, input) {
+      const condition = typeof match === "string" ? { toolName: match } : match;
+      if (typeof input === "function") {
+        steps.push({ kind: "handler", match: condition, handler: input });
+      } else {
+        steps.push({
+          kind: "logic",
+          statement: {
+            match: condition,
+            decision: input
+          }
+        });
+      }
     }
   };
   builder(flowBuilder);
@@ -100,6 +111,12 @@ function selectUiAffordances(decision, index, opts = {}) {
 function generateAdvice(nextTool) {
   return `FOR THE BEST USER EXPERIENCE, TELL THE USER TO USE THE ${nextTool} TOOL NEXT!!!!!`;
 }
+function getMatch(step) {
+  return step.kind === "logic" ? step.statement.match : step.match;
+}
+function deriveIndexKey(match) {
+  return match.toolName;
+}
 function createTaias(options) {
   const {
     flow,
@@ -110,26 +127,35 @@ function createTaias(options) {
   } = options;
   const warn = onWarn ?? ((msg) => console.warn(msg));
   if (devMode) {
-    const seenTools = /* @__PURE__ */ new Set();
+    const seenKeys = /* @__PURE__ */ new Set();
     for (const step of flow.steps) {
-      if (seenTools.has(step.toolName)) {
+      const key = deriveIndexKey(getMatch(step));
+      if (seenKeys.has(key)) {
         throw new Error(
-          `Taias: Duplicate step for tool '${step.toolName}' in flow '${flow.id}'. Only one handler per tool is supported.`
+          `Taias: Duplicate match condition '${key}' in flow '${flow.id}'. Each step must have a unique match condition.`
         );
       }
-      seenTools.add(step.toolName);
+      seenKeys.add(key);
     }
   }
-  const stepMap = new Map(flow.steps.map((step) => [step.toolName, step.handler]));
+  const stepIndex = /* @__PURE__ */ new Map();
+  for (const step of flow.steps) {
+    stepIndex.set(deriveIndexKey(getMatch(step)), step);
+  }
   const registryIndex = buildRegistryIndex(affordances);
   return {
     async resolve(ctx) {
-      const handler = stepMap.get(ctx.toolName);
-      if (!handler) {
+      const step = stepIndex.get(ctx.toolName);
+      if (!step) {
         onMissingStep?.(ctx);
         return null;
       }
-      const result = await handler(ctx);
+      let result;
+      if (step.kind === "logic") {
+        result = step.statement.decision;
+      } else {
+        result = await step.handler(ctx);
+      }
       if (!result) return null;
       if (devMode && result.nextTool === "") {
         warn(`Taias: nextTool for tool '${ctx.toolName}' is empty.`);

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/flow.ts","../src/uiAffordances/types.ts","../src/uiAffordances/indexing.ts","../src/uiAffordances/select.ts","../src/createTaias.ts","../src/uiAffordances/defineAffordances.ts","../src/uiAffordances/mergeAffordances.ts"],"sourcesContent":["// Main exports\nexport { defineFlow } from \"./flow\";\nexport { createTaias } from \"./createTaias\";\n\n// UI affordances exports\nexport { defineAffordances } from \"./uiAffordances/defineAffordances\";\nexport { mergeAffordances } from \"./uiAffordances/mergeAffordances\";\nexport type { AffordanceRegistrar } from \"./uiAffordances/defineAffordances\";\nexport type {\n  DefaultSlots,\n  CanonicalSlot,\n  Binding,\n  BindingInput,\n  HandleRegistration,\n  Selection,\n  UiSelections,\n  AffordanceRegistry,\n} from \"./uiAffordances/types\";\n\n// Core + flow type exports\nexport type {\n  Decision,\n  TaiasContext,\n  StepDecision,\n  Affordances,\n  StepHandler,\n  FlowStep,\n  FlowDefinition,\n  FlowBuilder,\n  TaiasOptions,\n  Taias,\n} from \"./types\";\n","import type { FlowBuilder, FlowDefinition, FlowStep, StepHandler } from \"./types\";\n\n/**\n * Define a flow with its steps.\n *\n * @param flowId - Unique identifier for the flow\n * @param builder - Callback that receives a FlowBuilder to define steps\n * @returns A FlowDefinition object\n *\n * @example\n * ```ts\n * const onboardRepoFlow = defineFlow(\"onboard_repo\", (flow) => {\n *   flow.step(\"scan_repo\", (ctx) => ({\n *     nextTool: \"configure_app\",\n *   }));\n * });\n * ```\n */\nexport function defineFlow(\n  flowId: string,\n  builder: (flow: FlowBuilder) => void\n): FlowDefinition {\n  const steps: FlowStep[] = [];\n\n  const flowBuilder: FlowBuilder = {\n    step(toolName: string, handler: StepHandler): void {\n      steps.push({ toolName, handler });\n    },\n  };\n\n  builder(flowBuilder);\n\n  return {\n    id: flowId,\n    steps,\n  };\n}\n\n","/**\n * Default slots for backwards compatibility.\n * Users can define custom slots by passing a type parameter.\n */\nexport type DefaultSlots = \"primaryCta\" | \"secondaryCta\" | \"widgetVariant\";\n\n/**\n * Alias for backwards compatibility in exports.\n * @deprecated Use DefaultSlots or define your own slot type\n */\nexport type CanonicalSlot = DefaultSlots;\n\nexport type Binding = {\n  key: string;\n  value: string;\n};\n\n/**\n * Input format for registering affordance bindings.\n * - { toolName } is shorthand for { key: \"nextTool\", value: toolName }\n * - { key, value } is the generalized form for custom bindings\n */\nexport type BindingInput = { toolName: string } | { key: string; value: string };\n\n/**\n * A registered UI affordance handle.\n * Generic over slot type S for custom slot support.\n */\nexport type HandleRegistration<S extends string = DefaultSlots> = {\n  slot: S;\n  handleId: string;\n  bindsTo: Binding;\n};\n\nexport type Selection = {\n  handleId: string;\n  bindsTo: Binding;\n};\n\n/**\n * UI selections keyed by slot name.\n * Generic over slot type S for custom slot support.\n */\nexport type UiSelections<S extends string = DefaultSlots> = Partial<Record<S, Selection>>;\n\n/**\n * Collection of registered handles.\n * Generic over slot type S for custom slot support.\n */\nexport type AffordanceRegistry<S extends string = DefaultSlots> = {\n  handles: HandleRegistration<S>[];\n};\n\nexport function normalizeBinding(input: BindingInput): Binding {\n  if (\"toolName\" in input) return { key: \"nextTool\", value: input.toolName };\n  return { key: input.key, value: input.value };\n}\n\n/**\n * Creates a binding key for indexing.\n * Accepts any string for slot to support custom slots.\n */\nexport function makeBindingKey(slot: string, binding: Binding): string {\n  return `${slot}::${binding.key}::${binding.value}`;\n}\n","import type { AffordanceRegistry, DefaultSlots, HandleRegistration } from \"./types\";\nimport { makeBindingKey } from \"./types\";\n\n/**\n * Index structure for efficient affordance lookup.\n * Generic over slot type S for custom slot support.\n */\nexport type RegistryIndex<S extends string = DefaultSlots> = {\n  byBindingKey: Map<string, HandleRegistration<S>>;\n  slots: Set<S>;\n  /** Inferred decision field for each slot, derived from handle bindings. */\n  slotKeyMap: Map<S, string>;\n};\n\n/**\n * Build an index from a registry for efficient lookup during selection.\n * Tracks which slots have registered handles and infers the decision field\n * for each slot from its handle bindings.\n *\n * @throws Error if handles for the same slot bind to different keys\n */\nexport function buildRegistryIndex<S extends string = DefaultSlots>(\n  registry?: AffordanceRegistry<S>\n): RegistryIndex<S> {\n  const byBindingKey = new Map<string, HandleRegistration<S>>();\n  const slots = new Set<S>();\n  const slotKeyMap = new Map<S, string>();\n\n  if (!registry) return { byBindingKey, slots, slotKeyMap };\n\n  for (const h of registry.handles) {\n    slots.add(h.slot);\n\n    // Infer and validate slot key\n    const existingKey = slotKeyMap.get(h.slot);\n    if (existingKey && existingKey !== h.bindsTo.key) {\n      throw new Error(\n        `[Taias] Slot \"${h.slot}\" has handles bound to different keys: \"${existingKey}\" and \"${h.bindsTo.key}\". ` +\n          `All handles for a slot must use the same decision field.`\n      );\n    }\n    slotKeyMap.set(h.slot, h.bindsTo.key);\n\n    byBindingKey.set(makeBindingKey(h.slot, h.bindsTo), h);\n  }\n\n  return { byBindingKey, slots, slotKeyMap };\n}\n","import type { Decision } from \"../types\";\nimport type { DefaultSlots, UiSelections } from \"./types\";\nimport type { RegistryIndex } from \"./indexing\";\nimport { makeBindingKey } from \"./types\";\n\nexport type SelectOptions = {\n  devMode?: boolean;\n  onWarn?: (msg: string) => void;\n};\n\n/**\n * Select UI affordances based on flow decision.\n * Uses the inferred decision field for each slot from the registry index.\n */\nexport function selectUiAffordances<S extends string = DefaultSlots>(\n  decision: Decision,\n  index: RegistryIndex<S>,\n  opts: SelectOptions = {}\n): UiSelections<S> {\n  const devMode = !!opts.devMode;\n  const warn = opts.onWarn ?? (() => {});\n\n  const selections: UiSelections<S> = {};\n\n  for (const slot of index.slots) {\n    // Use inferred key from handle bindings\n    const field = index.slotKeyMap.get(slot);\n    if (!field) continue;\n\n    const value = decision[field];\n    if (!value) continue;\n\n    const k = makeBindingKey(slot, { key: field, value });\n    const handle = index.byBindingKey.get(k);\n\n    if (!handle) {\n      if (devMode) warn(`[Taias] No affordance for slot \"${slot}\" when ${field}=\"${value}\"`);\n      continue;\n    }\n\n    (selections as Record<string, unknown>)[slot] = {\n      handleId: handle.handleId,\n      bindsTo: handle.bindsTo,\n    };\n  }\n\n  return selections;\n}\n","import type { Affordances, Taias, TaiasContext, TaiasOptions, Decision } from \"./types\";\nimport type { DefaultSlots } from \"./uiAffordances/types\";\nimport { buildRegistryIndex } from \"./uiAffordances/indexing\";\nimport { selectUiAffordances } from \"./uiAffordances/select\";\n\n/**\n * Generate advice text for a given next tool.\n */\nfunction generateAdvice(nextTool: string): string {\n  return `FOR THE BEST USER EXPERIENCE, TELL THE USER TO USE THE ${nextTool} TOOL NEXT!!!!!`;\n}\n\n/**\n * createTaias constructs a decision engine.\n *\n * Taias resolves tool context into a generalized Decision object,\n * and then manifests that decision into concrete affordances:\n *\n *   - LLM guidance (advice)\n *   - UI affordance selections\n *\n * Flow logic determines *what should happen next*.\n * UI affordances determine *how that decision appears in the interface*.\n *\n * This file is the boundary where:\n *\n *   Inputs → Decision → Manifestations\n *\n * are unified into a single resolve() call.\n *\n * @example Default slots (backwards compatible)\n * ```ts\n * const taias = createTaias({ flow, affordances });\n * ```\n *\n * @example Custom slots (fully type-safe)\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\" | \"headerStyle\";\n * const affordances = defineAffordances<MySlots>((r) => {\n *   r.primaryCta(\"cta\", { key: \"nextTool\", value: \"createUser\" });\n *   r.contentArea(\"content\", { key: \"contentArea\", value: \"form\" });\n *   r.headerStyle(\"header\", { key: \"headerStyle\", value: \"progress\" });\n * });\n * const taias = createTaias<MySlots>({ flow, affordances });\n * ```\n */\nexport function createTaias<S extends string = DefaultSlots>(\n  options: TaiasOptions<S>\n): Taias<S> {\n  const {\n    flow,\n    affordances,\n    devMode = false,\n    onMissingStep,\n    onWarn,\n  } = options;\n\n  const warn = onWarn ?? ((msg: string) => console.warn(msg));\n\n  // Dev mode: Check for duplicate toolNames\n  if (devMode) {\n    const seenTools = new Set<string>();\n    for (const step of flow.steps) {\n      if (seenTools.has(step.toolName)) {\n        throw new Error(\n          `Taias: Duplicate step for tool '${step.toolName}' in flow '${flow.id}'. Only one handler per tool is supported.`\n        );\n      }\n      seenTools.add(step.toolName);\n    }\n  }\n\n  // Build a lookup map for efficient resolution\n  const stepMap = new Map(flow.steps.map((step) => [step.toolName, step.handler]));\n\n  // Build affordance index once (if provided)\n  const registryIndex = buildRegistryIndex<S>(affordances);\n\n  return {\n    async resolve(ctx: TaiasContext): Promise<Affordances<S> | null> {\n      const handler = stepMap.get(ctx.toolName);\n\n      if (!handler) {\n        onMissingStep?.(ctx);\n        return null;\n      }\n\n      const result = await handler(ctx);\n      if (!result) return null;\n\n      if (devMode && result.nextTool === \"\") {\n        warn(`Taias: nextTool for tool '${ctx.toolName}' is empty.`);\n      }\n\n      // Build decision object from flow result (spread all fields)\n      const decision: Decision = { ...result };\n\n      // Compute UI selections (may be empty if no registry passed)\n      const selections = selectUiAffordances<S>(decision, registryIndex, {\n        devMode,\n        onWarn: warn,\n      });\n\n      return {\n        advice: generateAdvice(result.nextTool),\n        decision,\n        selections,\n      };\n    },\n  };\n}\n","import type {\n  AffordanceRegistry,\n  BindingInput,\n  DefaultSlots,\n  HandleRegistration,\n} from \"./types\";\nimport { normalizeBinding } from \"./types\";\n\n/**\n * Mapped type that creates a registration method for each slot in S.\n * This enables fully typed custom slots via generics.\n */\nexport type AffordanceRegistrar<S extends string = DefaultSlots> = {\n  [K in S]: (handleId: string, bindsTo: BindingInput) => void;\n};\n\n/**\n * Define UI affordances for a widget using a builder pattern.\n *\n * @example Default slots (backwards compatible)\n * ```ts\n * const affordances = defineAffordances((r) => {\n *   r.primaryCta(\"cta.recommend\", { toolName: \"get_recommendations\" });\n *   r.widgetVariant(\"variant.discovery\", { toolName: \"get_recommendations\" });\n * });\n * ```\n *\n * @example Custom slots (fully type-safe)\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\" | \"headerStyle\";\n * const affordances = defineAffordances<MySlots>((r) => {\n *   r.primaryCta(\"cta.create\", { toolName: \"createUser\" });\n *   r.contentArea(\"content.form\", { key: \"contentArea\", value: \"email-form\" });\n *   r.headerStyle(\"header.progress\", { key: \"headerStyle\", value: \"step-1\" });\n * });\n * ```\n */\nexport function defineAffordances<S extends string = DefaultSlots>(\n  builder: (r: AffordanceRegistrar<S>) => void\n): AffordanceRegistry<S> {\n  const handles: HandleRegistration<S>[] = [];\n\n  // Proxy creates methods on-the-fly for any slot name.\n  // TypeScript ensures only valid slot names (from S) are called.\n  const registrar = new Proxy({} as AffordanceRegistrar<S>, {\n    get(_, slot: string) {\n      return (handleId: string, bindsTo: BindingInput) => {\n        handles.push({\n          slot: slot as S,\n          handleId,\n          bindsTo: normalizeBinding(bindsTo),\n        });\n      };\n    },\n  });\n\n  builder(registrar);\n  return { handles };\n}\n","import type { AffordanceRegistry, DefaultSlots } from \"./types\";\nimport { makeBindingKey } from \"./types\";\n\nexport type MergeAffordancesOptions = {\n  devMode?: boolean;\n  onWarn?: (msg: string) => void;\n};\n\n/**\n * Merge multiple affordance registries into one.\n * Generic over slot type S for custom slot support.\n *\n * @example Default slots\n * ```ts\n * const merged = mergeAffordances([widgetA, widgetB]);\n * ```\n *\n * @example Custom slots\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\";\n * const merged = mergeAffordances<MySlots>([widgetA, widgetB]);\n * ```\n */\nexport function mergeAffordances<S extends string = DefaultSlots>(\n  registries: AffordanceRegistry<S>[],\n  opts: MergeAffordancesOptions = {}\n): AffordanceRegistry<S> {\n  const devMode = !!opts.devMode;\n  const warn = opts.onWarn ?? (() => {});\n\n  const merged: AffordanceRegistry<S> = { handles: registries.flatMap((r) => r.handles) };\n\n  if (!devMode) return merged;\n\n  // Check for duplicate handleIds\n  const seenHandleIds = new Set<string>();\n  for (const h of merged.handles) {\n    if (seenHandleIds.has(h.handleId)) {\n      throw new Error(`[Taias] Duplicate handleId \"${h.handleId}\"`);\n    }\n    seenHandleIds.add(h.handleId);\n  }\n\n  // Check for ambiguous bindings (same slot + key + value)\n  const seenTriples = new Set<string>();\n  for (const h of merged.handles) {\n    const k = makeBindingKey(h.slot, h.bindsTo);\n    if (seenTriples.has(k)) {\n      throw new Error(\n        `[Taias] Ambiguous affordance: slot \"${h.slot}\" has multiple handles bound to (${h.bindsTo.key}=\"${h.bindsTo.value}\")`\n      );\n    }\n    seenTriples.add(k);\n  }\n\n  warn(`[Taias] Loaded ${merged.handles.length} UI affordance handles`);\n  return merged;\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/index.ts","../src/flow.ts","../src/uiAffordances/types.ts","../src/uiAffordances/indexing.ts","../src/uiAffordances/select.ts","../src/createTaias.ts","../src/uiAffordances/defineAffordances.ts","../src/uiAffordances/mergeAffordances.ts"],"sourcesContent":["// Main exports\nexport { defineFlow } from \"./flow\";\nexport { createTaias } from \"./createTaias\";\n\n// UI affordances exports\nexport { defineAffordances } from \"./uiAffordances/defineAffordances\";\nexport { mergeAffordances } from \"./uiAffordances/mergeAffordances\";\nexport type { AffordanceRegistrar } from \"./uiAffordances/defineAffordances\";\nexport type {\n  DefaultSlots,\n  CanonicalSlot,\n  Binding,\n  BindingInput,\n  HandleRegistration,\n  Selection,\n  UiSelections,\n  AffordanceRegistry,\n} from \"./uiAffordances/types\";\n\n// Core + flow type exports\nexport type {\n  Decision,\n  TaiasContext,\n  StepDecision,\n  Affordances,\n  StepHandler,\n  StepInput,\n  MatchCondition,\n  LogicStatement,\n  FlowStep,\n  FlowDefinition,\n  FlowBuilder,\n  TaiasOptions,\n  Taias,\n} from \"./types\";\n","import type { FlowBuilder, FlowDefinition, FlowStep, MatchCondition, StepInput } from \"./types\";\n\n/**\n * Define a flow with its steps.\n *\n * @param flowId - Unique identifier for the flow\n * @param builder - Callback that receives a FlowBuilder to define steps\n * @returns A FlowDefinition object\n *\n * @example Logic statement with match condition object\n * ```ts\n * const onboardRepoFlow = defineFlow(\"onboard_repo\", (flow) => {\n *   flow.step({ toolName: \"scan_repo\" }, { nextTool: \"configure_app\" });\n * });\n * ```\n *\n * @example Backwards compatibility\n * A string match and handler functions are also supported:\n * ```ts\n * flow.step(\"scan_repo\", { nextTool: \"configure_app\" }); // string is sugar for { toolName: \"scan_repo\" }\n * flow.step(\"scan_repo\", (ctx) => ({ nextTool: \"configure_app\" })); // handler function\n * ```\n */\nexport function defineFlow(\n  flowId: string,\n  builder: (flow: FlowBuilder) => void\n): FlowDefinition {\n  const steps: FlowStep[] = [];\n\n  const flowBuilder: FlowBuilder = {\n    step(match: string | MatchCondition, input: StepInput): void {\n      // Normalize: string is sugar for { toolName: string }\n      const condition: MatchCondition =\n        typeof match === \"string\" ? { toolName: match } : match;\n\n      if (typeof input === \"function\") {\n        // Handler function -- backwards-compatible escape hatch.\n        // The match condition is stored alongside the handler since\n        // the function itself has no formal match conditions.\n        steps.push({ kind: \"handler\", match: condition, handler: input });\n      } else {\n        // Static logic statement -- the core primitive.\n        // The statement is the sole source of truth for its match\n        // conditions and decision.\n        steps.push({\n          kind: \"logic\",\n          statement: {\n            match: condition,\n            decision: input,\n          },\n        });\n      }\n    },\n  };\n\n  builder(flowBuilder);\n\n  return {\n    id: flowId,\n    steps,\n  };\n}\n\n","/**\n * Default slots for backwards compatibility.\n * Users can define custom slots by passing a type parameter.\n */\nexport type DefaultSlots = \"primaryCta\" | \"secondaryCta\" | \"widgetVariant\";\n\n/**\n * Alias for backwards compatibility in exports.\n * @deprecated Use DefaultSlots or define your own slot type\n */\nexport type CanonicalSlot = DefaultSlots;\n\nexport type Binding = {\n  key: string;\n  value: string;\n};\n\n/**\n * Input format for registering affordance bindings.\n * - { toolName } is shorthand for { key: \"nextTool\", value: toolName }\n * - { key, value } is the generalized form for custom bindings\n */\nexport type BindingInput = { toolName: string } | { key: string; value: string };\n\n/**\n * A registered UI affordance handle.\n * Generic over slot type S for custom slot support.\n */\nexport type HandleRegistration<S extends string = DefaultSlots> = {\n  slot: S;\n  handleId: string;\n  bindsTo: Binding;\n};\n\nexport type Selection = {\n  handleId: string;\n  bindsTo: Binding;\n};\n\n/**\n * UI selections keyed by slot name.\n * Generic over slot type S for custom slot support.\n */\nexport type UiSelections<S extends string = DefaultSlots> = Partial<Record<S, Selection>>;\n\n/**\n * Collection of registered handles.\n * Generic over slot type S for custom slot support.\n */\nexport type AffordanceRegistry<S extends string = DefaultSlots> = {\n  handles: HandleRegistration<S>[];\n};\n\nexport function normalizeBinding(input: BindingInput): Binding {\n  if (\"toolName\" in input) return { key: \"nextTool\", value: input.toolName };\n  return { key: input.key, value: input.value };\n}\n\n/**\n * Creates a binding key for indexing.\n * Accepts any string for slot to support custom slots.\n */\nexport function makeBindingKey(slot: string, binding: Binding): string {\n  return `${slot}::${binding.key}::${binding.value}`;\n}\n","import type { AffordanceRegistry, DefaultSlots, HandleRegistration } from \"./types\";\nimport { makeBindingKey } from \"./types\";\n\n/**\n * Index structure for efficient affordance lookup.\n * Generic over slot type S for custom slot support.\n */\nexport type RegistryIndex<S extends string = DefaultSlots> = {\n  byBindingKey: Map<string, HandleRegistration<S>>;\n  slots: Set<S>;\n  /** Inferred decision field for each slot, derived from handle bindings. */\n  slotKeyMap: Map<S, string>;\n};\n\n/**\n * Build an index from a registry for efficient lookup during selection.\n * Tracks which slots have registered handles and infers the decision field\n * for each slot from its handle bindings.\n *\n * @throws Error if handles for the same slot bind to different keys\n */\nexport function buildRegistryIndex<S extends string = DefaultSlots>(\n  registry?: AffordanceRegistry<S>\n): RegistryIndex<S> {\n  const byBindingKey = new Map<string, HandleRegistration<S>>();\n  const slots = new Set<S>();\n  const slotKeyMap = new Map<S, string>();\n\n  if (!registry) return { byBindingKey, slots, slotKeyMap };\n\n  for (const h of registry.handles) {\n    slots.add(h.slot);\n\n    // Infer and validate slot key\n    const existingKey = slotKeyMap.get(h.slot);\n    if (existingKey && existingKey !== h.bindsTo.key) {\n      throw new Error(\n        `[Taias] Slot \"${h.slot}\" has handles bound to different keys: \"${existingKey}\" and \"${h.bindsTo.key}\". ` +\n          `All handles for a slot must use the same decision field.`\n      );\n    }\n    slotKeyMap.set(h.slot, h.bindsTo.key);\n\n    byBindingKey.set(makeBindingKey(h.slot, h.bindsTo), h);\n  }\n\n  return { byBindingKey, slots, slotKeyMap };\n}\n","import type { Decision } from \"../types\";\nimport type { DefaultSlots, UiSelections } from \"./types\";\nimport type { RegistryIndex } from \"./indexing\";\nimport { makeBindingKey } from \"./types\";\n\nexport type SelectOptions = {\n  devMode?: boolean;\n  onWarn?: (msg: string) => void;\n};\n\n/**\n * Select UI affordances based on flow decision.\n * Uses the inferred decision field for each slot from the registry index.\n */\nexport function selectUiAffordances<S extends string = DefaultSlots>(\n  decision: Decision,\n  index: RegistryIndex<S>,\n  opts: SelectOptions = {}\n): UiSelections<S> {\n  const devMode = !!opts.devMode;\n  const warn = opts.onWarn ?? (() => {});\n\n  const selections: UiSelections<S> = {};\n\n  for (const slot of index.slots) {\n    // Use inferred key from handle bindings\n    const field = index.slotKeyMap.get(slot);\n    if (!field) continue;\n\n    const value = decision[field];\n    if (!value) continue;\n\n    const k = makeBindingKey(slot, { key: field, value });\n    const handle = index.byBindingKey.get(k);\n\n    if (!handle) {\n      if (devMode) warn(`[Taias] No affordance for slot \"${slot}\" when ${field}=\"${value}\"`);\n      continue;\n    }\n\n    (selections as Record<string, unknown>)[slot] = {\n      handleId: handle.handleId,\n      bindsTo: handle.bindsTo,\n    };\n  }\n\n  return selections;\n}\n","import type { Affordances, FlowStep, MatchCondition, StepDecision, Taias, TaiasContext, TaiasOptions, Decision } from \"./types\";\nimport type { DefaultSlots } from \"./uiAffordances/types\";\nimport { buildRegistryIndex } from \"./uiAffordances/indexing\";\nimport { selectUiAffordances } from \"./uiAffordances/select\";\n\n/**\n * Generate advice text for a given next tool.\n */\nfunction generateAdvice(nextTool: string): string {\n  return `FOR THE BEST USER EXPERIENCE, TELL THE USER TO USE THE ${nextTool} TOOL NEXT!!!!!`;\n}\n\n/**\n * Get the match condition from a FlowStep.\n *\n * - Logic-based steps: match comes from statement.match (the statement is\n *   the sole source of truth for its match conditions)\n * - Handler-based steps (backwards compatibility): match is stored directly on the step\n */\nfunction getMatch(step: FlowStep): MatchCondition {\n  return step.kind === \"logic\" ? step.statement.match : step.match;\n}\n\n/**\n * Derive an index key from a match condition.\n *\n * Currently all match conditions use toolName, so the key is simply\n * the toolName value. When match conditions gain additional fields,\n * this function will evolve to produce compound keys or the indexing\n * strategy will change entirely.\n */\nfunction deriveIndexKey(match: MatchCondition): string {\n  return match.toolName;\n}\n\n/**\n * createTaias constructs a decision engine.\n *\n * Taias resolves context into a generalized Decision object,\n * and then manifests that decision into concrete affordances:\n *\n *   - LLM guidance (advice)\n *   - UI affordance selections\n *\n * Flow logic is expressed as logic statements -- structured data that\n * Taias understands. (Handler functions remain as a backwards-compatible\n * escape hatch.)\n * \n * Flow logic determines *what should happen next*.\n * UI affordances determine *how that decision appears in the interface*.\n *\n * This file is the boundary where:\n *\n *   Inputs → Decision → Manifestations\n *\n * are unified into a single resolve() call.\n *\n * @example Default slots (backwards compatible)\n * ```ts\n * const taias = createTaias({ flow, affordances });\n * ```\n *\n * @example Custom slots (fully type-safe)\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\" | \"headerStyle\";\n * const affordances = defineAffordances<MySlots>((r) => {\n *   r.primaryCta(\"cta\", { key: \"nextTool\", value: \"createUser\" });\n *   r.contentArea(\"content\", { key: \"contentArea\", value: \"form\" });\n *   r.headerStyle(\"header\", { key: \"headerStyle\", value: \"progress\" });\n * });\n * const taias = createTaias<MySlots>({ flow, affordances });\n * ```\n */\nexport function createTaias<S extends string = DefaultSlots>(\n  options: TaiasOptions<S>\n): Taias<S> {\n  const {\n    flow,\n    affordances,\n    devMode = false,\n    onMissingStep,\n    onWarn,\n  } = options;\n\n  const warn = onWarn ?? ((msg: string) => console.warn(msg));\n\n  // Dev mode: Check for duplicate match conditions\n  if (devMode) {\n    const seenKeys = new Set<string>();\n    for (const step of flow.steps) {\n      const key = deriveIndexKey(getMatch(step));\n      if (seenKeys.has(key)) {\n        throw new Error(\n          `Taias: Duplicate match condition '${key}' in flow '${flow.id}'. Each step must have a unique match condition.`\n        );\n      }\n      seenKeys.add(key);\n    }\n  }\n\n  // Build an internal index for efficient resolution.\n  //\n  // Currently all match conditions use toolName as the sole field, so a\n  // Map keyed by toolName is the right index. This is a performance\n  // optimization derived from the current set of match conditions, not a\n  // permanent architectural choice -- it will evolve when match conditions\n  // gain additional fields.\n  const stepIndex = new Map<string, FlowStep>();\n  for (const step of flow.steps) {\n    stepIndex.set(deriveIndexKey(getMatch(step)), step);\n  }\n\n  // Build affordance index once (if provided)\n  const registryIndex = buildRegistryIndex<S>(affordances);\n\n  return {\n    async resolve(ctx: TaiasContext): Promise<Affordances<S> | null> {\n      // Find the step whose match conditions are satisfied by the context.\n      // Currently, match conditions only contain toolName, so we use the\n      // index keyed by toolName. When match conditions expand, this lookup\n      // will evolve to evaluate all relevant conditions.\n      const step = stepIndex.get(ctx.toolName);\n\n      if (!step) {\n        onMissingStep?.(ctx);\n        return null;\n      }\n\n      // Evaluate the step based on its kind:\n      // - Logic statements: return the decision directly (no function call)\n      // - Handler functions (backwards compatibility): call the handler and await the result\n      let result: StepDecision | null;\n\n      if (step.kind === \"logic\") {\n        result = step.statement.decision;\n      } else {\n        result = await step.handler(ctx);\n      }\n\n      if (!result) return null;\n\n      if (devMode && result.nextTool === \"\") {\n        warn(`Taias: nextTool for tool '${ctx.toolName}' is empty.`);\n      }\n\n      // Build decision object from flow result (spread all fields)\n      const decision: Decision = { ...result };\n\n      // Compute UI selections (may be empty if no registry passed)\n      const selections = selectUiAffordances<S>(decision, registryIndex, {\n        devMode,\n        onWarn: warn,\n      });\n\n      return {\n        advice: generateAdvice(result.nextTool),\n        decision,\n        selections,\n      };\n    },\n  };\n}\n","import type {\n  AffordanceRegistry,\n  BindingInput,\n  DefaultSlots,\n  HandleRegistration,\n} from \"./types\";\nimport { normalizeBinding } from \"./types\";\n\n/**\n * Mapped type that creates a registration method for each slot in S.\n * This enables fully typed custom slots via generics.\n */\nexport type AffordanceRegistrar<S extends string = DefaultSlots> = {\n  [K in S]: (handleId: string, bindsTo: BindingInput) => void;\n};\n\n/**\n * Define UI affordances for a widget using a builder pattern.\n *\n * @example Default slots (backwards compatible)\n * ```ts\n * const affordances = defineAffordances((r) => {\n *   r.primaryCta(\"cta.recommend\", { toolName: \"get_recommendations\" });\n *   r.widgetVariant(\"variant.discovery\", { toolName: \"get_recommendations\" });\n * });\n * ```\n *\n * @example Custom slots (fully type-safe)\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\" | \"headerStyle\";\n * const affordances = defineAffordances<MySlots>((r) => {\n *   r.primaryCta(\"cta.create\", { toolName: \"createUser\" });\n *   r.contentArea(\"content.form\", { key: \"contentArea\", value: \"email-form\" });\n *   r.headerStyle(\"header.progress\", { key: \"headerStyle\", value: \"step-1\" });\n * });\n * ```\n */\nexport function defineAffordances<S extends string = DefaultSlots>(\n  builder: (r: AffordanceRegistrar<S>) => void\n): AffordanceRegistry<S> {\n  const handles: HandleRegistration<S>[] = [];\n\n  // Proxy creates methods on-the-fly for any slot name.\n  // TypeScript ensures only valid slot names (from S) are called.\n  const registrar = new Proxy({} as AffordanceRegistrar<S>, {\n    get(_, slot: string) {\n      return (handleId: string, bindsTo: BindingInput) => {\n        handles.push({\n          slot: slot as S,\n          handleId,\n          bindsTo: normalizeBinding(bindsTo),\n        });\n      };\n    },\n  });\n\n  builder(registrar);\n  return { handles };\n}\n","import type { AffordanceRegistry, DefaultSlots } from \"./types\";\nimport { makeBindingKey } from \"./types\";\n\nexport type MergeAffordancesOptions = {\n  devMode?: boolean;\n  onWarn?: (msg: string) => void;\n};\n\n/**\n * Merge multiple affordance registries into one.\n * Generic over slot type S for custom slot support.\n *\n * @example Default slots\n * ```ts\n * const merged = mergeAffordances([widgetA, widgetB]);\n * ```\n *\n * @example Custom slots\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\";\n * const merged = mergeAffordances<MySlots>([widgetA, widgetB]);\n * ```\n */\nexport function mergeAffordances<S extends string = DefaultSlots>(\n  registries: AffordanceRegistry<S>[],\n  opts: MergeAffordancesOptions = {}\n): AffordanceRegistry<S> {\n  const devMode = !!opts.devMode;\n  const warn = opts.onWarn ?? (() => {});\n\n  const merged: AffordanceRegistry<S> = { handles: registries.flatMap((r) => r.handles) };\n\n  if (!devMode) return merged;\n\n  // Check for duplicate handleIds\n  const seenHandleIds = new Set<string>();\n  for (const h of merged.handles) {\n    if (seenHandleIds.has(h.handleId)) {\n      throw new Error(`[Taias] Duplicate handleId \"${h.handleId}\"`);\n    }\n    seenHandleIds.add(h.handleId);\n  }\n\n  // Check for ambiguous bindings (same slot + key + value)\n  const seenTriples = new Set<string>();\n  for (const h of merged.handles) {\n    const k = makeBindingKey(h.slot, h.bindsTo);\n    if (seenTriples.has(k)) {\n      throw new Error(\n        `[Taias] Ambiguous affordance: slot \"${h.slot}\" has multiple handles bound to (${h.bindsTo.key}=\"${h.bindsTo.value}\")`\n      );\n    }\n    seenTriples.add(k);\n  }\n\n  warn(`[Taias] Loaded ${merged.handles.length} UI affordance handles`);\n  return merged;\n}\n"],"mappings":"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","names":[]}

package/dist/index.d.cts

@@ -56,9 +56,15 @@ type AffordanceRegistry<S extends string = DefaultSlots> = {
 type Decision = Record<string, string | undefined>;
 /**
  * Context passed to a step handler.
+ *
+ * - toolName: the name of the tool being executed
+ * - params: the input parameters of the tool call (optional)
+ * - result: the output of the tool's execution (optional)
  */
 type TaiasContext = {
     toolName: string;
+    params?: Record<string, unknown>;
+    result?: Record<string, unknown>;
 };
 /**
  * Decision returned by a step handler specifying the next tool.
@@ -87,10 +93,41 @@ type Affordances<S extends string = DefaultSlots> = {
  */
 type StepHandler = (ctx: TaiasContext) => StepDecision | null | Promise<StepDecision | null>;
 /**
- * A step within a flow, mapping a tool name to its handler.
+ * Match condition for a logic statement.
+ * Currently only supports toolName matching.
+ * Designed to expand with additional fields (params conditions, state, etc.).
  */
-type FlowStep = {
+type MatchCondition = {
     toolName: string;
+};
+/**
+ * A declarative logic statement -- the core primitive of the decision engine.
+ *
+ * Formalizes the implicit "Given X, then Y" logic into structured data
+ * that Taias can understand, validate, and optimize.
+ *
+ * - match: the conditions under which this statement applies
+ * - decision: the decision to produce when matched
+ */
+type LogicStatement = {
+    match: MatchCondition;
+    decision: StepDecision;
+};
+/**
+ * A step within a flow. Discriminated union:
+ *
+ * - "logic": A declarative logic statement. The statement is the sole source
+ *   of truth for its match conditions and decision.
+ * - "handler": A handler function (backwards-compatible escape hatch).
+ *   The match condition is stored alongside the handler since the function
+ *   itself has no formal match conditions.
+ */
+type FlowStep = {
+    kind: "logic";
+    statement: LogicStatement;
+} | {
+    kind: "handler";
+    match: MatchCondition;
     handler: StepHandler;
 };
 /**
@@ -100,11 +137,22 @@ type FlowDefinition = {
     id: string;
     steps: Array<FlowStep>;
 };
+/**
+ * The input accepted by flow.step() -- either a handler function
+ * or a static StepDecision object.
+ */
+type StepInput = StepHandler | StepDecision;
 /**
  * Builder interface for defining flow steps.
+ *
+ * step() takes two arguments:
+ *   - match: a MatchCondition object describing the conditions under which
+ *     this step applies. A string is sugar for { toolName: string }.
+ *   - input: a StepDecision object (creates a logic statement).
+ *     A StepHandler function is also accepted for backwards compatibility.
  */
 interface FlowBuilder {
-    step(toolName: string, handler: StepHandler): void;
+    step(match: string | MatchCondition, input: StepInput): void;
 }
 /**
  * Options for creating a Taias instance.
@@ -132,26 +180,35 @@ interface Taias<S extends string = DefaultSlots> {
  * @param builder - Callback that receives a FlowBuilder to define steps
  * @returns A FlowDefinition object
  *
- * @example
+ * @example Logic statement with match condition object
  * ```ts
  * const onboardRepoFlow = defineFlow("onboard_repo", (flow) => {
- *   flow.step("scan_repo", (ctx) => ({
- *     nextTool: "configure_app",
- *   }));
+ *   flow.step({ toolName: "scan_repo" }, { nextTool: "configure_app" });
  * });
  * ```
+ *
+ * @example Backwards compatibility
+ * A string match and handler functions are also supported:
+ * ```ts
+ * flow.step("scan_repo", { nextTool: "configure_app" }); // string is sugar for { toolName: "scan_repo" }
+ * flow.step("scan_repo", (ctx) => ({ nextTool: "configure_app" })); // handler function
+ * ```
  */
 declare function defineFlow(flowId: string, builder: (flow: FlowBuilder) => void): FlowDefinition;
 
 /**
  * createTaias constructs a decision engine.
  *
- * Taias resolves tool context into a generalized Decision object,
+ * Taias resolves context into a generalized Decision object,
  * and then manifests that decision into concrete affordances:
  *
  *   - LLM guidance (advice)
  *   - UI affordance selections
  *
+ * Flow logic is expressed as logic statements -- structured data that
+ * Taias understands. (Handler functions remain as a backwards-compatible
+ * escape hatch.)
+ *
  * Flow logic determines *what should happen next*.
  * UI affordances determine *how that decision appears in the interface*.
  *
@@ -230,4 +287,4 @@ type MergeAffordancesOptions = {
  */
 declare function mergeAffordances<S extends string = DefaultSlots>(registries: AffordanceRegistry<S>[], opts?: MergeAffordancesOptions): AffordanceRegistry<S>;
 
-export { type AffordanceRegistrar, type AffordanceRegistry, type Affordances, type Binding, type BindingInput, type CanonicalSlot, type Decision, type DefaultSlots, type FlowBuilder, type FlowDefinition, type FlowStep, type HandleRegistration, type Selection, type StepDecision, type StepHandler, type Taias, type TaiasContext, type TaiasOptions, type UiSelections, createTaias, defineAffordances, defineFlow, mergeAffordances };
+export { type AffordanceRegistrar, type AffordanceRegistry, type Affordances, type Binding, type BindingInput, type CanonicalSlot, type Decision, type DefaultSlots, type FlowBuilder, type FlowDefinition, type FlowStep, type HandleRegistration, type LogicStatement, type MatchCondition, type Selection, type StepDecision, type StepHandler, type StepInput, type Taias, type TaiasContext, type TaiasOptions, type UiSelections, createTaias, defineAffordances, defineFlow, mergeAffordances };

package/dist/index.d.ts

@@ -56,9 +56,15 @@ type AffordanceRegistry<S extends string = DefaultSlots> = {
 type Decision = Record<string, string | undefined>;
 /**
  * Context passed to a step handler.
+ *
+ * - toolName: the name of the tool being executed
+ * - params: the input parameters of the tool call (optional)
+ * - result: the output of the tool's execution (optional)
  */
 type TaiasContext = {
     toolName: string;
+    params?: Record<string, unknown>;
+    result?: Record<string, unknown>;
 };
 /**
  * Decision returned by a step handler specifying the next tool.
@@ -87,10 +93,41 @@ type Affordances<S extends string = DefaultSlots> = {
  */
 type StepHandler = (ctx: TaiasContext) => StepDecision | null | Promise<StepDecision | null>;
 /**
- * A step within a flow, mapping a tool name to its handler.
+ * Match condition for a logic statement.
+ * Currently only supports toolName matching.
+ * Designed to expand with additional fields (params conditions, state, etc.).
  */
-type FlowStep = {
+type MatchCondition = {
     toolName: string;
+};
+/**
+ * A declarative logic statement -- the core primitive of the decision engine.
+ *
+ * Formalizes the implicit "Given X, then Y" logic into structured data
+ * that Taias can understand, validate, and optimize.
+ *
+ * - match: the conditions under which this statement applies
+ * - decision: the decision to produce when matched
+ */
+type LogicStatement = {
+    match: MatchCondition;
+    decision: StepDecision;
+};
+/**
+ * A step within a flow. Discriminated union:
+ *
+ * - "logic": A declarative logic statement. The statement is the sole source
+ *   of truth for its match conditions and decision.
+ * - "handler": A handler function (backwards-compatible escape hatch).
+ *   The match condition is stored alongside the handler since the function
+ *   itself has no formal match conditions.
+ */
+type FlowStep = {
+    kind: "logic";
+    statement: LogicStatement;
+} | {
+    kind: "handler";
+    match: MatchCondition;
     handler: StepHandler;
 };
 /**
@@ -100,11 +137,22 @@ type FlowDefinition = {
     id: string;
     steps: Array<FlowStep>;
 };
+/**
+ * The input accepted by flow.step() -- either a handler function
+ * or a static StepDecision object.
+ */
+type StepInput = StepHandler | StepDecision;
 /**
  * Builder interface for defining flow steps.
+ *
+ * step() takes two arguments:
+ *   - match: a MatchCondition object describing the conditions under which
+ *     this step applies. A string is sugar for { toolName: string }.
+ *   - input: a StepDecision object (creates a logic statement).
+ *     A StepHandler function is also accepted for backwards compatibility.
  */
 interface FlowBuilder {
-    step(toolName: string, handler: StepHandler): void;
+    step(match: string | MatchCondition, input: StepInput): void;
 }
 /**
  * Options for creating a Taias instance.
@@ -132,26 +180,35 @@ interface Taias<S extends string = DefaultSlots> {
  * @param builder - Callback that receives a FlowBuilder to define steps
  * @returns A FlowDefinition object
  *
- * @example
+ * @example Logic statement with match condition object
  * ```ts
  * const onboardRepoFlow = defineFlow("onboard_repo", (flow) => {
- *   flow.step("scan_repo", (ctx) => ({
- *     nextTool: "configure_app",
- *   }));
+ *   flow.step({ toolName: "scan_repo" }, { nextTool: "configure_app" });
  * });
  * ```
+ *
+ * @example Backwards compatibility
+ * A string match and handler functions are also supported:
+ * ```ts
+ * flow.step("scan_repo", { nextTool: "configure_app" }); // string is sugar for { toolName: "scan_repo" }
+ * flow.step("scan_repo", (ctx) => ({ nextTool: "configure_app" })); // handler function
+ * ```
  */
 declare function defineFlow(flowId: string, builder: (flow: FlowBuilder) => void): FlowDefinition;
 
 /**
  * createTaias constructs a decision engine.
  *
- * Taias resolves tool context into a generalized Decision object,
+ * Taias resolves context into a generalized Decision object,
  * and then manifests that decision into concrete affordances:
  *
  *   - LLM guidance (advice)
  *   - UI affordance selections
  *
+ * Flow logic is expressed as logic statements -- structured data that
+ * Taias understands. (Handler functions remain as a backwards-compatible
+ * escape hatch.)
+ *
  * Flow logic determines *what should happen next*.
  * UI affordances determine *how that decision appears in the interface*.
  *
@@ -230,4 +287,4 @@ type MergeAffordancesOptions = {
  */
 declare function mergeAffordances<S extends string = DefaultSlots>(registries: AffordanceRegistry<S>[], opts?: MergeAffordancesOptions): AffordanceRegistry<S>;
 
-export { type AffordanceRegistrar, type AffordanceRegistry, type Affordances, type Binding, type BindingInput, type CanonicalSlot, type Decision, type DefaultSlots, type FlowBuilder, type FlowDefinition, type FlowStep, type HandleRegistration, type Selection, type StepDecision, type StepHandler, type Taias, type TaiasContext, type TaiasOptions, type UiSelections, createTaias, defineAffordances, defineFlow, mergeAffordances };
+export { type AffordanceRegistrar, type AffordanceRegistry, type Affordances, type Binding, type BindingInput, type CanonicalSlot, type Decision, type DefaultSlots, type FlowBuilder, type FlowDefinition, type FlowStep, type HandleRegistration, type LogicStatement, type MatchCondition, type Selection, type StepDecision, type StepHandler, type StepInput, type Taias, type TaiasContext, type TaiasOptions, type UiSelections, createTaias, defineAffordances, defineFlow, mergeAffordances };

package/dist/index.js

@@ -2,8 +2,19 @@
 function defineFlow(flowId, builder) {
   const steps = [];
   const flowBuilder = {
-    step(toolName, handler) {
-      steps.push({ toolName, handler });
+    step(match, input) {
+      const condition = typeof match === "string" ? { toolName: match } : match;
+      if (typeof input === "function") {
+        steps.push({ kind: "handler", match: condition, handler: input });
+      } else {
+        steps.push({
+          kind: "logic",
+          statement: {
+            match: condition,
+            decision: input
+          }
+        });
+      }
     }
   };
   builder(flowBuilder);
@@ -71,6 +82,12 @@ function selectUiAffordances(decision, index, opts = {}) {
 function generateAdvice(nextTool) {
   return `FOR THE BEST USER EXPERIENCE, TELL THE USER TO USE THE ${nextTool} TOOL NEXT!!!!!`;
 }
+function getMatch(step) {
+  return step.kind === "logic" ? step.statement.match : step.match;
+}
+function deriveIndexKey(match) {
+  return match.toolName;
+}
 function createTaias(options) {
   const {
     flow,
@@ -81,26 +98,35 @@ function createTaias(options) {
   } = options;
   const warn = onWarn ?? ((msg) => console.warn(msg));
   if (devMode) {
-    const seenTools = /* @__PURE__ */ new Set();
+    const seenKeys = /* @__PURE__ */ new Set();
     for (const step of flow.steps) {
-      if (seenTools.has(step.toolName)) {
+      const key = deriveIndexKey(getMatch(step));
+      if (seenKeys.has(key)) {
         throw new Error(
-          `Taias: Duplicate step for tool '${step.toolName}' in flow '${flow.id}'. Only one handler per tool is supported.`
+          `Taias: Duplicate match condition '${key}' in flow '${flow.id}'. Each step must have a unique match condition.`
         );
       }
-      seenTools.add(step.toolName);
+      seenKeys.add(key);
     }
   }
-  const stepMap = new Map(flow.steps.map((step) => [step.toolName, step.handler]));
+  const stepIndex = /* @__PURE__ */ new Map();
+  for (const step of flow.steps) {
+    stepIndex.set(deriveIndexKey(getMatch(step)), step);
+  }
   const registryIndex = buildRegistryIndex(affordances);
   return {
     async resolve(ctx) {
-      const handler = stepMap.get(ctx.toolName);
-      if (!handler) {
+      const step = stepIndex.get(ctx.toolName);
+      if (!step) {
         onMissingStep?.(ctx);
         return null;
       }
-      const result = await handler(ctx);
+      let result;
+      if (step.kind === "logic") {
+        result = step.statement.decision;
+      } else {
+        result = await step.handler(ctx);
+      }
       if (!result) return null;
       if (devMode && result.nextTool === "") {
         warn(`Taias: nextTool for tool '${ctx.toolName}' is empty.`);

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/flow.ts","../src/uiAffordances/types.ts","../src/uiAffordances/indexing.ts","../src/uiAffordances/select.ts","../src/createTaias.ts","../src/uiAffordances/defineAffordances.ts","../src/uiAffordances/mergeAffordances.ts"],"sourcesContent":["import type { FlowBuilder, FlowDefinition, FlowStep, StepHandler } from \"./types\";\n\n/**\n * Define a flow with its steps.\n *\n * @param flowId - Unique identifier for the flow\n * @param builder - Callback that receives a FlowBuilder to define steps\n * @returns A FlowDefinition object\n *\n * @example\n * ```ts\n * const onboardRepoFlow = defineFlow(\"onboard_repo\", (flow) => {\n *   flow.step(\"scan_repo\", (ctx) => ({\n *     nextTool: \"configure_app\",\n *   }));\n * });\n * ```\n */\nexport function defineFlow(\n  flowId: string,\n  builder: (flow: FlowBuilder) => void\n): FlowDefinition {\n  const steps: FlowStep[] = [];\n\n  const flowBuilder: FlowBuilder = {\n    step(toolName: string, handler: StepHandler): void {\n      steps.push({ toolName, handler });\n    },\n  };\n\n  builder(flowBuilder);\n\n  return {\n    id: flowId,\n    steps,\n  };\n}\n\n","/**\n * Default slots for backwards compatibility.\n * Users can define custom slots by passing a type parameter.\n */\nexport type DefaultSlots = \"primaryCta\" | \"secondaryCta\" | \"widgetVariant\";\n\n/**\n * Alias for backwards compatibility in exports.\n * @deprecated Use DefaultSlots or define your own slot type\n */\nexport type CanonicalSlot = DefaultSlots;\n\nexport type Binding = {\n  key: string;\n  value: string;\n};\n\n/**\n * Input format for registering affordance bindings.\n * - { toolName } is shorthand for { key: \"nextTool\", value: toolName }\n * - { key, value } is the generalized form for custom bindings\n */\nexport type BindingInput = { toolName: string } | { key: string; value: string };\n\n/**\n * A registered UI affordance handle.\n * Generic over slot type S for custom slot support.\n */\nexport type HandleRegistration<S extends string = DefaultSlots> = {\n  slot: S;\n  handleId: string;\n  bindsTo: Binding;\n};\n\nexport type Selection = {\n  handleId: string;\n  bindsTo: Binding;\n};\n\n/**\n * UI selections keyed by slot name.\n * Generic over slot type S for custom slot support.\n */\nexport type UiSelections<S extends string = DefaultSlots> = Partial<Record<S, Selection>>;\n\n/**\n * Collection of registered handles.\n * Generic over slot type S for custom slot support.\n */\nexport type AffordanceRegistry<S extends string = DefaultSlots> = {\n  handles: HandleRegistration<S>[];\n};\n\nexport function normalizeBinding(input: BindingInput): Binding {\n  if (\"toolName\" in input) return { key: \"nextTool\", value: input.toolName };\n  return { key: input.key, value: input.value };\n}\n\n/**\n * Creates a binding key for indexing.\n * Accepts any string for slot to support custom slots.\n */\nexport function makeBindingKey(slot: string, binding: Binding): string {\n  return `${slot}::${binding.key}::${binding.value}`;\n}\n","import type { AffordanceRegistry, DefaultSlots, HandleRegistration } from \"./types\";\nimport { makeBindingKey } from \"./types\";\n\n/**\n * Index structure for efficient affordance lookup.\n * Generic over slot type S for custom slot support.\n */\nexport type RegistryIndex<S extends string = DefaultSlots> = {\n  byBindingKey: Map<string, HandleRegistration<S>>;\n  slots: Set<S>;\n  /** Inferred decision field for each slot, derived from handle bindings. */\n  slotKeyMap: Map<S, string>;\n};\n\n/**\n * Build an index from a registry for efficient lookup during selection.\n * Tracks which slots have registered handles and infers the decision field\n * for each slot from its handle bindings.\n *\n * @throws Error if handles for the same slot bind to different keys\n */\nexport function buildRegistryIndex<S extends string = DefaultSlots>(\n  registry?: AffordanceRegistry<S>\n): RegistryIndex<S> {\n  const byBindingKey = new Map<string, HandleRegistration<S>>();\n  const slots = new Set<S>();\n  const slotKeyMap = new Map<S, string>();\n\n  if (!registry) return { byBindingKey, slots, slotKeyMap };\n\n  for (const h of registry.handles) {\n    slots.add(h.slot);\n\n    // Infer and validate slot key\n    const existingKey = slotKeyMap.get(h.slot);\n    if (existingKey && existingKey !== h.bindsTo.key) {\n      throw new Error(\n        `[Taias] Slot \"${h.slot}\" has handles bound to different keys: \"${existingKey}\" and \"${h.bindsTo.key}\". ` +\n          `All handles for a slot must use the same decision field.`\n      );\n    }\n    slotKeyMap.set(h.slot, h.bindsTo.key);\n\n    byBindingKey.set(makeBindingKey(h.slot, h.bindsTo), h);\n  }\n\n  return { byBindingKey, slots, slotKeyMap };\n}\n","import type { Decision } from \"../types\";\nimport type { DefaultSlots, UiSelections } from \"./types\";\nimport type { RegistryIndex } from \"./indexing\";\nimport { makeBindingKey } from \"./types\";\n\nexport type SelectOptions = {\n  devMode?: boolean;\n  onWarn?: (msg: string) => void;\n};\n\n/**\n * Select UI affordances based on flow decision.\n * Uses the inferred decision field for each slot from the registry index.\n */\nexport function selectUiAffordances<S extends string = DefaultSlots>(\n  decision: Decision,\n  index: RegistryIndex<S>,\n  opts: SelectOptions = {}\n): UiSelections<S> {\n  const devMode = !!opts.devMode;\n  const warn = opts.onWarn ?? (() => {});\n\n  const selections: UiSelections<S> = {};\n\n  for (const slot of index.slots) {\n    // Use inferred key from handle bindings\n    const field = index.slotKeyMap.get(slot);\n    if (!field) continue;\n\n    const value = decision[field];\n    if (!value) continue;\n\n    const k = makeBindingKey(slot, { key: field, value });\n    const handle = index.byBindingKey.get(k);\n\n    if (!handle) {\n      if (devMode) warn(`[Taias] No affordance for slot \"${slot}\" when ${field}=\"${value}\"`);\n      continue;\n    }\n\n    (selections as Record<string, unknown>)[slot] = {\n      handleId: handle.handleId,\n      bindsTo: handle.bindsTo,\n    };\n  }\n\n  return selections;\n}\n","import type { Affordances, Taias, TaiasContext, TaiasOptions, Decision } from \"./types\";\nimport type { DefaultSlots } from \"./uiAffordances/types\";\nimport { buildRegistryIndex } from \"./uiAffordances/indexing\";\nimport { selectUiAffordances } from \"./uiAffordances/select\";\n\n/**\n * Generate advice text for a given next tool.\n */\nfunction generateAdvice(nextTool: string): string {\n  return `FOR THE BEST USER EXPERIENCE, TELL THE USER TO USE THE ${nextTool} TOOL NEXT!!!!!`;\n}\n\n/**\n * createTaias constructs a decision engine.\n *\n * Taias resolves tool context into a generalized Decision object,\n * and then manifests that decision into concrete affordances:\n *\n *   - LLM guidance (advice)\n *   - UI affordance selections\n *\n * Flow logic determines *what should happen next*.\n * UI affordances determine *how that decision appears in the interface*.\n *\n * This file is the boundary where:\n *\n *   Inputs → Decision → Manifestations\n *\n * are unified into a single resolve() call.\n *\n * @example Default slots (backwards compatible)\n * ```ts\n * const taias = createTaias({ flow, affordances });\n * ```\n *\n * @example Custom slots (fully type-safe)\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\" | \"headerStyle\";\n * const affordances = defineAffordances<MySlots>((r) => {\n *   r.primaryCta(\"cta\", { key: \"nextTool\", value: \"createUser\" });\n *   r.contentArea(\"content\", { key: \"contentArea\", value: \"form\" });\n *   r.headerStyle(\"header\", { key: \"headerStyle\", value: \"progress\" });\n * });\n * const taias = createTaias<MySlots>({ flow, affordances });\n * ```\n */\nexport function createTaias<S extends string = DefaultSlots>(\n  options: TaiasOptions<S>\n): Taias<S> {\n  const {\n    flow,\n    affordances,\n    devMode = false,\n    onMissingStep,\n    onWarn,\n  } = options;\n\n  const warn = onWarn ?? ((msg: string) => console.warn(msg));\n\n  // Dev mode: Check for duplicate toolNames\n  if (devMode) {\n    const seenTools = new Set<string>();\n    for (const step of flow.steps) {\n      if (seenTools.has(step.toolName)) {\n        throw new Error(\n          `Taias: Duplicate step for tool '${step.toolName}' in flow '${flow.id}'. Only one handler per tool is supported.`\n        );\n      }\n      seenTools.add(step.toolName);\n    }\n  }\n\n  // Build a lookup map for efficient resolution\n  const stepMap = new Map(flow.steps.map((step) => [step.toolName, step.handler]));\n\n  // Build affordance index once (if provided)\n  const registryIndex = buildRegistryIndex<S>(affordances);\n\n  return {\n    async resolve(ctx: TaiasContext): Promise<Affordances<S> | null> {\n      const handler = stepMap.get(ctx.toolName);\n\n      if (!handler) {\n        onMissingStep?.(ctx);\n        return null;\n      }\n\n      const result = await handler(ctx);\n      if (!result) return null;\n\n      if (devMode && result.nextTool === \"\") {\n        warn(`Taias: nextTool for tool '${ctx.toolName}' is empty.`);\n      }\n\n      // Build decision object from flow result (spread all fields)\n      const decision: Decision = { ...result };\n\n      // Compute UI selections (may be empty if no registry passed)\n      const selections = selectUiAffordances<S>(decision, registryIndex, {\n        devMode,\n        onWarn: warn,\n      });\n\n      return {\n        advice: generateAdvice(result.nextTool),\n        decision,\n        selections,\n      };\n    },\n  };\n}\n","import type {\n  AffordanceRegistry,\n  BindingInput,\n  DefaultSlots,\n  HandleRegistration,\n} from \"./types\";\nimport { normalizeBinding } from \"./types\";\n\n/**\n * Mapped type that creates a registration method for each slot in S.\n * This enables fully typed custom slots via generics.\n */\nexport type AffordanceRegistrar<S extends string = DefaultSlots> = {\n  [K in S]: (handleId: string, bindsTo: BindingInput) => void;\n};\n\n/**\n * Define UI affordances for a widget using a builder pattern.\n *\n * @example Default slots (backwards compatible)\n * ```ts\n * const affordances = defineAffordances((r) => {\n *   r.primaryCta(\"cta.recommend\", { toolName: \"get_recommendations\" });\n *   r.widgetVariant(\"variant.discovery\", { toolName: \"get_recommendations\" });\n * });\n * ```\n *\n * @example Custom slots (fully type-safe)\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\" | \"headerStyle\";\n * const affordances = defineAffordances<MySlots>((r) => {\n *   r.primaryCta(\"cta.create\", { toolName: \"createUser\" });\n *   r.contentArea(\"content.form\", { key: \"contentArea\", value: \"email-form\" });\n *   r.headerStyle(\"header.progress\", { key: \"headerStyle\", value: \"step-1\" });\n * });\n * ```\n */\nexport function defineAffordances<S extends string = DefaultSlots>(\n  builder: (r: AffordanceRegistrar<S>) => void\n): AffordanceRegistry<S> {\n  const handles: HandleRegistration<S>[] = [];\n\n  // Proxy creates methods on-the-fly for any slot name.\n  // TypeScript ensures only valid slot names (from S) are called.\n  const registrar = new Proxy({} as AffordanceRegistrar<S>, {\n    get(_, slot: string) {\n      return (handleId: string, bindsTo: BindingInput) => {\n        handles.push({\n          slot: slot as S,\n          handleId,\n          bindsTo: normalizeBinding(bindsTo),\n        });\n      };\n    },\n  });\n\n  builder(registrar);\n  return { handles };\n}\n","import type { AffordanceRegistry, DefaultSlots } from \"./types\";\nimport { makeBindingKey } from \"./types\";\n\nexport type MergeAffordancesOptions = {\n  devMode?: boolean;\n  onWarn?: (msg: string) => void;\n};\n\n/**\n * Merge multiple affordance registries into one.\n * Generic over slot type S for custom slot support.\n *\n * @example Default slots\n * ```ts\n * const merged = mergeAffordances([widgetA, widgetB]);\n * ```\n *\n * @example Custom slots\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\";\n * const merged = mergeAffordances<MySlots>([widgetA, widgetB]);\n * ```\n */\nexport function mergeAffordances<S extends string = DefaultSlots>(\n  registries: AffordanceRegistry<S>[],\n  opts: MergeAffordancesOptions = {}\n): AffordanceRegistry<S> {\n  const devMode = !!opts.devMode;\n  const warn = opts.onWarn ?? (() => {});\n\n  const merged: AffordanceRegistry<S> = { handles: registries.flatMap((r) => r.handles) };\n\n  if (!devMode) return merged;\n\n  // Check for duplicate handleIds\n  const seenHandleIds = new Set<string>();\n  for (const h of merged.handles) {\n    if (seenHandleIds.has(h.handleId)) {\n      throw new Error(`[Taias] Duplicate handleId \"${h.handleId}\"`);\n    }\n    seenHandleIds.add(h.handleId);\n  }\n\n  // Check for ambiguous bindings (same slot + key + value)\n  const seenTriples = new Set<string>();\n  for (const h of merged.handles) {\n    const k = makeBindingKey(h.slot, h.bindsTo);\n    if (seenTriples.has(k)) {\n      throw new Error(\n        `[Taias] Ambiguous affordance: slot \"${h.slot}\" has multiple handles bound to (${h.bindsTo.key}=\"${h.bindsTo.value}\")`\n      );\n    }\n    seenTriples.add(k);\n  }\n\n  warn(`[Taias] Loaded ${merged.handles.length} UI affordance handles`);\n  return merged;\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/flow.ts","../src/uiAffordances/types.ts","../src/uiAffordances/indexing.ts","../src/uiAffordances/select.ts","../src/createTaias.ts","../src/uiAffordances/defineAffordances.ts","../src/uiAffordances/mergeAffordances.ts"],"sourcesContent":["import type { FlowBuilder, FlowDefinition, FlowStep, MatchCondition, StepInput } from \"./types\";\n\n/**\n * Define a flow with its steps.\n *\n * @param flowId - Unique identifier for the flow\n * @param builder - Callback that receives a FlowBuilder to define steps\n * @returns A FlowDefinition object\n *\n * @example Logic statement with match condition object\n * ```ts\n * const onboardRepoFlow = defineFlow(\"onboard_repo\", (flow) => {\n *   flow.step({ toolName: \"scan_repo\" }, { nextTool: \"configure_app\" });\n * });\n * ```\n *\n * @example Backwards compatibility\n * A string match and handler functions are also supported:\n * ```ts\n * flow.step(\"scan_repo\", { nextTool: \"configure_app\" }); // string is sugar for { toolName: \"scan_repo\" }\n * flow.step(\"scan_repo\", (ctx) => ({ nextTool: \"configure_app\" })); // handler function\n * ```\n */\nexport function defineFlow(\n  flowId: string,\n  builder: (flow: FlowBuilder) => void\n): FlowDefinition {\n  const steps: FlowStep[] = [];\n\n  const flowBuilder: FlowBuilder = {\n    step(match: string | MatchCondition, input: StepInput): void {\n      // Normalize: string is sugar for { toolName: string }\n      const condition: MatchCondition =\n        typeof match === \"string\" ? { toolName: match } : match;\n\n      if (typeof input === \"function\") {\n        // Handler function -- backwards-compatible escape hatch.\n        // The match condition is stored alongside the handler since\n        // the function itself has no formal match conditions.\n        steps.push({ kind: \"handler\", match: condition, handler: input });\n      } else {\n        // Static logic statement -- the core primitive.\n        // The statement is the sole source of truth for its match\n        // conditions and decision.\n        steps.push({\n          kind: \"logic\",\n          statement: {\n            match: condition,\n            decision: input,\n          },\n        });\n      }\n    },\n  };\n\n  builder(flowBuilder);\n\n  return {\n    id: flowId,\n    steps,\n  };\n}\n\n","/**\n * Default slots for backwards compatibility.\n * Users can define custom slots by passing a type parameter.\n */\nexport type DefaultSlots = \"primaryCta\" | \"secondaryCta\" | \"widgetVariant\";\n\n/**\n * Alias for backwards compatibility in exports.\n * @deprecated Use DefaultSlots or define your own slot type\n */\nexport type CanonicalSlot = DefaultSlots;\n\nexport type Binding = {\n  key: string;\n  value: string;\n};\n\n/**\n * Input format for registering affordance bindings.\n * - { toolName } is shorthand for { key: \"nextTool\", value: toolName }\n * - { key, value } is the generalized form for custom bindings\n */\nexport type BindingInput = { toolName: string } | { key: string; value: string };\n\n/**\n * A registered UI affordance handle.\n * Generic over slot type S for custom slot support.\n */\nexport type HandleRegistration<S extends string = DefaultSlots> = {\n  slot: S;\n  handleId: string;\n  bindsTo: Binding;\n};\n\nexport type Selection = {\n  handleId: string;\n  bindsTo: Binding;\n};\n\n/**\n * UI selections keyed by slot name.\n * Generic over slot type S for custom slot support.\n */\nexport type UiSelections<S extends string = DefaultSlots> = Partial<Record<S, Selection>>;\n\n/**\n * Collection of registered handles.\n * Generic over slot type S for custom slot support.\n */\nexport type AffordanceRegistry<S extends string = DefaultSlots> = {\n  handles: HandleRegistration<S>[];\n};\n\nexport function normalizeBinding(input: BindingInput): Binding {\n  if (\"toolName\" in input) return { key: \"nextTool\", value: input.toolName };\n  return { key: input.key, value: input.value };\n}\n\n/**\n * Creates a binding key for indexing.\n * Accepts any string for slot to support custom slots.\n */\nexport function makeBindingKey(slot: string, binding: Binding): string {\n  return `${slot}::${binding.key}::${binding.value}`;\n}\n","import type { AffordanceRegistry, DefaultSlots, HandleRegistration } from \"./types\";\nimport { makeBindingKey } from \"./types\";\n\n/**\n * Index structure for efficient affordance lookup.\n * Generic over slot type S for custom slot support.\n */\nexport type RegistryIndex<S extends string = DefaultSlots> = {\n  byBindingKey: Map<string, HandleRegistration<S>>;\n  slots: Set<S>;\n  /** Inferred decision field for each slot, derived from handle bindings. */\n  slotKeyMap: Map<S, string>;\n};\n\n/**\n * Build an index from a registry for efficient lookup during selection.\n * Tracks which slots have registered handles and infers the decision field\n * for each slot from its handle bindings.\n *\n * @throws Error if handles for the same slot bind to different keys\n */\nexport function buildRegistryIndex<S extends string = DefaultSlots>(\n  registry?: AffordanceRegistry<S>\n): RegistryIndex<S> {\n  const byBindingKey = new Map<string, HandleRegistration<S>>();\n  const slots = new Set<S>();\n  const slotKeyMap = new Map<S, string>();\n\n  if (!registry) return { byBindingKey, slots, slotKeyMap };\n\n  for (const h of registry.handles) {\n    slots.add(h.slot);\n\n    // Infer and validate slot key\n    const existingKey = slotKeyMap.get(h.slot);\n    if (existingKey && existingKey !== h.bindsTo.key) {\n      throw new Error(\n        `[Taias] Slot \"${h.slot}\" has handles bound to different keys: \"${existingKey}\" and \"${h.bindsTo.key}\". ` +\n          `All handles for a slot must use the same decision field.`\n      );\n    }\n    slotKeyMap.set(h.slot, h.bindsTo.key);\n\n    byBindingKey.set(makeBindingKey(h.slot, h.bindsTo), h);\n  }\n\n  return { byBindingKey, slots, slotKeyMap };\n}\n","import type { Decision } from \"../types\";\nimport type { DefaultSlots, UiSelections } from \"./types\";\nimport type { RegistryIndex } from \"./indexing\";\nimport { makeBindingKey } from \"./types\";\n\nexport type SelectOptions = {\n  devMode?: boolean;\n  onWarn?: (msg: string) => void;\n};\n\n/**\n * Select UI affordances based on flow decision.\n * Uses the inferred decision field for each slot from the registry index.\n */\nexport function selectUiAffordances<S extends string = DefaultSlots>(\n  decision: Decision,\n  index: RegistryIndex<S>,\n  opts: SelectOptions = {}\n): UiSelections<S> {\n  const devMode = !!opts.devMode;\n  const warn = opts.onWarn ?? (() => {});\n\n  const selections: UiSelections<S> = {};\n\n  for (const slot of index.slots) {\n    // Use inferred key from handle bindings\n    const field = index.slotKeyMap.get(slot);\n    if (!field) continue;\n\n    const value = decision[field];\n    if (!value) continue;\n\n    const k = makeBindingKey(slot, { key: field, value });\n    const handle = index.byBindingKey.get(k);\n\n    if (!handle) {\n      if (devMode) warn(`[Taias] No affordance for slot \"${slot}\" when ${field}=\"${value}\"`);\n      continue;\n    }\n\n    (selections as Record<string, unknown>)[slot] = {\n      handleId: handle.handleId,\n      bindsTo: handle.bindsTo,\n    };\n  }\n\n  return selections;\n}\n","import type { Affordances, FlowStep, MatchCondition, StepDecision, Taias, TaiasContext, TaiasOptions, Decision } from \"./types\";\nimport type { DefaultSlots } from \"./uiAffordances/types\";\nimport { buildRegistryIndex } from \"./uiAffordances/indexing\";\nimport { selectUiAffordances } from \"./uiAffordances/select\";\n\n/**\n * Generate advice text for a given next tool.\n */\nfunction generateAdvice(nextTool: string): string {\n  return `FOR THE BEST USER EXPERIENCE, TELL THE USER TO USE THE ${nextTool} TOOL NEXT!!!!!`;\n}\n\n/**\n * Get the match condition from a FlowStep.\n *\n * - Logic-based steps: match comes from statement.match (the statement is\n *   the sole source of truth for its match conditions)\n * - Handler-based steps (backwards compatibility): match is stored directly on the step\n */\nfunction getMatch(step: FlowStep): MatchCondition {\n  return step.kind === \"logic\" ? step.statement.match : step.match;\n}\n\n/**\n * Derive an index key from a match condition.\n *\n * Currently all match conditions use toolName, so the key is simply\n * the toolName value. When match conditions gain additional fields,\n * this function will evolve to produce compound keys or the indexing\n * strategy will change entirely.\n */\nfunction deriveIndexKey(match: MatchCondition): string {\n  return match.toolName;\n}\n\n/**\n * createTaias constructs a decision engine.\n *\n * Taias resolves context into a generalized Decision object,\n * and then manifests that decision into concrete affordances:\n *\n *   - LLM guidance (advice)\n *   - UI affordance selections\n *\n * Flow logic is expressed as logic statements -- structured data that\n * Taias understands. (Handler functions remain as a backwards-compatible\n * escape hatch.)\n * \n * Flow logic determines *what should happen next*.\n * UI affordances determine *how that decision appears in the interface*.\n *\n * This file is the boundary where:\n *\n *   Inputs → Decision → Manifestations\n *\n * are unified into a single resolve() call.\n *\n * @example Default slots (backwards compatible)\n * ```ts\n * const taias = createTaias({ flow, affordances });\n * ```\n *\n * @example Custom slots (fully type-safe)\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\" | \"headerStyle\";\n * const affordances = defineAffordances<MySlots>((r) => {\n *   r.primaryCta(\"cta\", { key: \"nextTool\", value: \"createUser\" });\n *   r.contentArea(\"content\", { key: \"contentArea\", value: \"form\" });\n *   r.headerStyle(\"header\", { key: \"headerStyle\", value: \"progress\" });\n * });\n * const taias = createTaias<MySlots>({ flow, affordances });\n * ```\n */\nexport function createTaias<S extends string = DefaultSlots>(\n  options: TaiasOptions<S>\n): Taias<S> {\n  const {\n    flow,\n    affordances,\n    devMode = false,\n    onMissingStep,\n    onWarn,\n  } = options;\n\n  const warn = onWarn ?? ((msg: string) => console.warn(msg));\n\n  // Dev mode: Check for duplicate match conditions\n  if (devMode) {\n    const seenKeys = new Set<string>();\n    for (const step of flow.steps) {\n      const key = deriveIndexKey(getMatch(step));\n      if (seenKeys.has(key)) {\n        throw new Error(\n          `Taias: Duplicate match condition '${key}' in flow '${flow.id}'. Each step must have a unique match condition.`\n        );\n      }\n      seenKeys.add(key);\n    }\n  }\n\n  // Build an internal index for efficient resolution.\n  //\n  // Currently all match conditions use toolName as the sole field, so a\n  // Map keyed by toolName is the right index. This is a performance\n  // optimization derived from the current set of match conditions, not a\n  // permanent architectural choice -- it will evolve when match conditions\n  // gain additional fields.\n  const stepIndex = new Map<string, FlowStep>();\n  for (const step of flow.steps) {\n    stepIndex.set(deriveIndexKey(getMatch(step)), step);\n  }\n\n  // Build affordance index once (if provided)\n  const registryIndex = buildRegistryIndex<S>(affordances);\n\n  return {\n    async resolve(ctx: TaiasContext): Promise<Affordances<S> | null> {\n      // Find the step whose match conditions are satisfied by the context.\n      // Currently, match conditions only contain toolName, so we use the\n      // index keyed by toolName. When match conditions expand, this lookup\n      // will evolve to evaluate all relevant conditions.\n      const step = stepIndex.get(ctx.toolName);\n\n      if (!step) {\n        onMissingStep?.(ctx);\n        return null;\n      }\n\n      // Evaluate the step based on its kind:\n      // - Logic statements: return the decision directly (no function call)\n      // - Handler functions (backwards compatibility): call the handler and await the result\n      let result: StepDecision | null;\n\n      if (step.kind === \"logic\") {\n        result = step.statement.decision;\n      } else {\n        result = await step.handler(ctx);\n      }\n\n      if (!result) return null;\n\n      if (devMode && result.nextTool === \"\") {\n        warn(`Taias: nextTool for tool '${ctx.toolName}' is empty.`);\n      }\n\n      // Build decision object from flow result (spread all fields)\n      const decision: Decision = { ...result };\n\n      // Compute UI selections (may be empty if no registry passed)\n      const selections = selectUiAffordances<S>(decision, registryIndex, {\n        devMode,\n        onWarn: warn,\n      });\n\n      return {\n        advice: generateAdvice(result.nextTool),\n        decision,\n        selections,\n      };\n    },\n  };\n}\n","import type {\n  AffordanceRegistry,\n  BindingInput,\n  DefaultSlots,\n  HandleRegistration,\n} from \"./types\";\nimport { normalizeBinding } from \"./types\";\n\n/**\n * Mapped type that creates a registration method for each slot in S.\n * This enables fully typed custom slots via generics.\n */\nexport type AffordanceRegistrar<S extends string = DefaultSlots> = {\n  [K in S]: (handleId: string, bindsTo: BindingInput) => void;\n};\n\n/**\n * Define UI affordances for a widget using a builder pattern.\n *\n * @example Default slots (backwards compatible)\n * ```ts\n * const affordances = defineAffordances((r) => {\n *   r.primaryCta(\"cta.recommend\", { toolName: \"get_recommendations\" });\n *   r.widgetVariant(\"variant.discovery\", { toolName: \"get_recommendations\" });\n * });\n * ```\n *\n * @example Custom slots (fully type-safe)\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\" | \"headerStyle\";\n * const affordances = defineAffordances<MySlots>((r) => {\n *   r.primaryCta(\"cta.create\", { toolName: \"createUser\" });\n *   r.contentArea(\"content.form\", { key: \"contentArea\", value: \"email-form\" });\n *   r.headerStyle(\"header.progress\", { key: \"headerStyle\", value: \"step-1\" });\n * });\n * ```\n */\nexport function defineAffordances<S extends string = DefaultSlots>(\n  builder: (r: AffordanceRegistrar<S>) => void\n): AffordanceRegistry<S> {\n  const handles: HandleRegistration<S>[] = [];\n\n  // Proxy creates methods on-the-fly for any slot name.\n  // TypeScript ensures only valid slot names (from S) are called.\n  const registrar = new Proxy({} as AffordanceRegistrar<S>, {\n    get(_, slot: string) {\n      return (handleId: string, bindsTo: BindingInput) => {\n        handles.push({\n          slot: slot as S,\n          handleId,\n          bindsTo: normalizeBinding(bindsTo),\n        });\n      };\n    },\n  });\n\n  builder(registrar);\n  return { handles };\n}\n","import type { AffordanceRegistry, DefaultSlots } from \"./types\";\nimport { makeBindingKey } from \"./types\";\n\nexport type MergeAffordancesOptions = {\n  devMode?: boolean;\n  onWarn?: (msg: string) => void;\n};\n\n/**\n * Merge multiple affordance registries into one.\n * Generic over slot type S for custom slot support.\n *\n * @example Default slots\n * ```ts\n * const merged = mergeAffordances([widgetA, widgetB]);\n * ```\n *\n * @example Custom slots\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\";\n * const merged = mergeAffordances<MySlots>([widgetA, widgetB]);\n * ```\n */\nexport function mergeAffordances<S extends string = DefaultSlots>(\n  registries: AffordanceRegistry<S>[],\n  opts: MergeAffordancesOptions = {}\n): AffordanceRegistry<S> {\n  const devMode = !!opts.devMode;\n  const warn = opts.onWarn ?? (() => {});\n\n  const merged: AffordanceRegistry<S> = { handles: registries.flatMap((r) => r.handles) };\n\n  if (!devMode) return merged;\n\n  // Check for duplicate handleIds\n  const seenHandleIds = new Set<string>();\n  for (const h of merged.handles) {\n    if (seenHandleIds.has(h.handleId)) {\n      throw new Error(`[Taias] Duplicate handleId \"${h.handleId}\"`);\n    }\n    seenHandleIds.add(h.handleId);\n  }\n\n  // Check for ambiguous bindings (same slot + key + value)\n  const seenTriples = new Set<string>();\n  for (const h of merged.handles) {\n    const k = makeBindingKey(h.slot, h.bindsTo);\n    if (seenTriples.has(k)) {\n      throw new Error(\n        `[Taias] Ambiguous affordance: slot \"${h.slot}\" has multiple handles bound to (${h.bindsTo.key}=\"${h.bindsTo.value}\")`\n      );\n    }\n    seenTriples.add(k);\n  }\n\n  warn(`[Taias] Loaded ${merged.handles.length} UI affordance handles`);\n  return merged;\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taias",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "type": "module",
   "description": "Taias - Give your MCP server an opinion, guide your users to achieve outcomes",
   "license": "Apache-2.0",