Add slot extractor and commit

Author: MaxLinCode

CLAUDE.md

@@ -0,0 +1,131 @@
+import { describe, expect, it, vi } from "vitest";
+
+import type { RawSlotExtraction, SlotExtractorInput } from "@atlas/core";
+
+import { extractSlots } from "./slot-extractor";
+
+function mockClient(output: Partial<RawSlotExtraction>) {
+  const full: RawSlotExtraction = {
+    time: null,
+    day: null,
+    duration: null,
+    target: null,
+    confidence: {},
+    unresolvable: [],
+    ...output
+  };
+  return {
+    responses: {
+      parse: vi.fn().mockResolvedValue({ output_parsed: full })
+    }
+  };
+}
+
+function failingClient() {
+  return {
+    responses: {
+      parse: vi.fn().mockRejectedValue(new Error("LLM unavailable"))
+    }
+  };
+}
+
+const baseInput: SlotExtractorInput = {
+  currentTurnText: "5pm",
+  pendingSlots: ["time"],
+  priorResolvedSlots: {}
+};
+
+describe("extractSlots", () => {
+  it("normalizes a successful time extraction", async () => {
+    const client = mockClient({
+      time: { hour: 17, minute: 0 },
+      confidence: { time: 0.9 },
+      unresolvable: []
+    });
+
+    const result = await extractSlots(baseInput, client);
+
+    expect(result.extractedValues).toEqual({ time: "17:00" });
+    expect(result.confidence).toEqual({ time: 0.9 });
+    expect(result.unresolvable).toEqual([]);
+  });
+
+  it("returns unresolvable for vague inputs", async () => {
+    const client = mockClient({
+      confidence: {},
+      unresolvable: ["time"]
+    });
+
+    const result = await extractSlots(baseInput, client);
+
+    expect(result.extractedValues).toEqual({});
+    expect(result.unresolvable).toEqual(["time"]);
+  });
+
+  it("handles multiple slots", async () => {
+    const client = mockClient({
+      time: { hour: 14, minute: 30 },
+      day: { kind: "relative", value: "Tomorrow" },
+      confidence: { time: 0.95, day: 0.92 },
+      unresolvable: []
+    });
+
+    const input: SlotExtractorInput = {
+      currentTurnText: "tomorrow at 2:30pm",
+      pendingSlots: ["time", "day"],
+      priorResolvedSlots: {}
+    };
+
+    const result = await extractSlots(input, client);
+
+    expect(result.extractedValues).toEqual({ time: "14:30", day: "tomorrow" });
+  });
+
+  it("degrades gracefully on LLM failure", async () => {
+    const client = failingClient();
+
+    const result = await extractSlots(baseInput, client);
+
+    expect(result.extractedValues).toEqual({});
+    expect(result.unresolvable).toEqual(["time"]);
+  });
+
+  it("degrades gracefully on malformed LLM response", async () => {
+    const client = {
+      responses: {
+        parse: vi.fn().mockResolvedValue({ output_parsed: { invalid: true } })
+      }
+    };
+
+    const input: SlotExtractorInput = {
+      currentTurnText: "5pm",
+      pendingSlots: ["time", "day"],
+      priorResolvedSlots: {}
+    };
+
+    const result = await extractSlots(input, client);
+
+    expect(result.extractedValues).toEqual({});
+    expect(result.unresolvable).toEqual(["time", "day"]);
+  });
+
+  it("passes conversation context to the client", async () => {
+    const client = mockClient({
+      time: { hour: 9, minute: 30 },
+      confidence: { time: 0.88 },
+      unresolvable: []
+    });
+
+    const input: SlotExtractorInput = {
+      currentTurnText: "after the standup",
+      pendingSlots: ["time"],
+      priorResolvedSlots: { day: "tomorrow" },
+      conversationContext: "standup is at 9:30am"
+    };
+
+    const result = await extractSlots(input, client);
+
+    expect(result.extractedValues).toEqual({ time: "09:30" });
+    expect(client.responses.parse).toHaveBeenCalledOnce();
+  });
+});

apps/web/src/lib/server/slot-extractor.test.ts

@@ -0,0 +1,37 @@
+import {
+  normalizeRawExtraction,
+  rawSlotExtractionSchema,
+  type SlotExtractorInput,
+  type SlotExtractorOutput
+} from "@atlas/core";
+import { extractSlotsWithResponses, type OpenAIResponsesClient } from "@atlas/integrations";
+
+export async function extractSlots(
+  input: SlotExtractorInput,
+  client?: OpenAIResponsesClient
+): Promise<SlotExtractorOutput> {
+  try {
+    const raw = await extractSlotsWithResponses(input, client);
+    const parsed = rawSlotExtractionSchema.safeParse(raw);
+
+    if (!parsed.success) {
+      return {
+        extractedValues: {},
+        confidence: {},
+        unresolvable: [...input.pendingSlots]
+      };
+    }
+
+    return {
+      extractedValues: normalizeRawExtraction(parsed.data),
+      confidence: parsed.data.confidence,
+      unresolvable: parsed.data.unresolvable
+    };
+  } catch {
+    return {
+      extractedValues: {},
+      confidence: {},
+      unresolvable: [...input.pendingSlots]
+    };
+  }
+}

apps/web/src/lib/server/slot-extractor.ts

@@ -0,0 +1,199 @@
+import { describe, expect, it } from "vitest";
+
+import type { CommitPolicyInput } from "./commit-policy";
+import { applyCommitPolicy } from "./commit-policy";
+import type { WriteContract } from "./index";
+
+const defaultContract: WriteContract = {
+  requiredSlots: ["day", "time"],
+  intentKind: "plan"
+};
+
+function buildInput(overrides: Partial<CommitPolicyInput>): CommitPolicyInput {
+  return {
+    turnType: "planning_request",
+    extractedValues: {},
+    confidence: {},
+    unresolvable: [],
+    priorResolvedSlots: {},
+    activeContract: defaultContract,
+    ...overrides
+  };
+}
+
+describe("applyCommitPolicy", () => {
+  it("does not commit slots for informational turns", () => {
+    const result = applyCommitPolicy(buildInput({
+      turnType: "informational",
+      extractedValues: { time: "15:00" },
+      confidence: { time: 0.95 }
+    }));
+
+    expect(result.committedSlots.time).toBeUndefined();
+  });
+
+  it("does not commit slots for confirmation turns", () => {
+    const result = applyCommitPolicy(buildInput({
+      turnType: "confirmation",
+      extractedValues: { time: "15:00" },
+      confidence: { time: 0.95 }
+    }));
+
+    expect(result.committedSlots.time).toBeUndefined();
+  });
+
+  it("commits slots above confidence threshold for planning_request", () => {
+    const result = applyCommitPolicy(buildInput({
+      turnType: "planning_request",
+      extractedValues: { time: "17:00", day: "tomorrow" },
+      confidence: { time: 0.9, day: 0.85 }
+    }));
+
+    expect(result.committedSlots.time).toBe("17:00");
+    expect(result.committedSlots.day).toBe("tomorrow");
+    expect(result.needsClarification).toEqual([]);
+  });
+
+  it("routes low confidence extraction to needsClarification", () => {
+    const result = applyCommitPolicy(buildInput({
+      turnType: "planning_request",
+      extractedValues: { time: "17:00" },
+      confidence: { time: 0.6 }
+    }));
+
+    expect(result.committedSlots.time).toBeUndefined();
+    expect(result.needsClarification).toContain("time");
+  });
+
+  it("does not commit correction below correction threshold", () => {
+    const result = applyCommitPolicy(buildInput({
+      turnType: "clarification_answer",
+      extractedValues: { time: "15:00" },
+      confidence: { time: 0.8 },
+      priorResolvedSlots: { time: "14:00" }
+    }));
+
+    expect(result.committedSlots.time).toBe("14:00");
+    expect(result.needsClarification).toContain("time");
+  });
+
+  it("commits correction at or above correction threshold", () => {
+    const result = applyCommitPolicy(buildInput({
+      turnType: "clarification_answer",
+      extractedValues: { time: "15:00" },
+      confidence: { time: 0.92 },
+      priorResolvedSlots: { time: "14:00" }
+    }));
+
+    expect(result.committedSlots.time).toBe("15:00");
+    expect(result.needsClarification).not.toContain("time");
+  });
+
+  it("routes unresolvable slots to needsClarification", () => {
+    const result = applyCommitPolicy(buildInput({
+      turnType: "clarification_answer",
+      extractedValues: {},
+      unresolvable: ["time"]
+    }));
+
+    expect(result.committedSlots.time).toBeUndefined();
+    expect(result.needsClarification).toContain("time");
+  });
+
+  it("resets prior slots on contract change", () => {
+    const result = applyCommitPolicy(buildInput({
+      turnType: "planning_request",
+      extractedValues: { day: "friday" },
+      confidence: { day: 0.9 },
+      priorResolvedSlots: { time: "14:00", day: "tomorrow" },
+      activeContract: { requiredSlots: ["day", "time"], intentKind: "edit" },
+      priorContract: { requiredSlots: ["day", "time"], intentKind: "plan" }
+    }));
+
+    expect(result.committedSlots.time).toBeUndefined();
+    expect(result.committedSlots.day).toBe("friday");
+  });
+
+  it("does not reset slots when contract intentKind is unchanged", () => {
+    const result = applyCommitPolicy(buildInput({
+      turnType: "planning_request",
+      extractedValues: { day: "friday" },
+      confidence: { day: 0.9 },
+      priorResolvedSlots: { time: "14:00" },
+      activeContract: { requiredSlots: ["day", "time"], intentKind: "plan" },
+      priorContract: { requiredSlots: ["day"], intentKind: "plan" }
+    }));
+
+    expect(result.committedSlots.time).toBe("14:00");
+    expect(result.committedSlots.day).toBe("friday");
+  });
+
+  it("derives missingSlots from post-commit state", () => {
+    const result = applyCommitPolicy(buildInput({
+      turnType: "planning_request",
+      extractedValues: { day: "tomorrow" },
+      confidence: { day: 0.9 },
+      activeContract: { requiredSlots: ["day", "time"], intentKind: "plan" }
+    }));
+
+    expect(result.missingSlots).toEqual(["time"]);
+    expect(result.missingSlots).not.toContain("day");
+  });
+
+  it("reports all required slots as missing when nothing is committed", () => {
+    const result = applyCommitPolicy(buildInput({
+      turnType: "planning_request",
+      extractedValues: {},
+      activeContract: { requiredSlots: ["day", "time", "target"], intentKind: "plan" }
+    }));
+
+    expect(result.missingSlots).toEqual(["day", "time", "target"]);
+  });
+
+  it("preserves prior resolved slots when new turn adds more", () => {
+    const result = applyCommitPolicy(buildInput({
+      turnType: "clarification_answer",
+      extractedValues: { time: "17:00" },
+      confidence: { time: 0.9 },
+      priorResolvedSlots: { day: "tomorrow" }
+    }));
+
+    expect(result.committedSlots.day).toBe("tomorrow");
+    expect(result.committedSlots.time).toBe("17:00");
+  });
+
+  it("commits slots for edit_request turn type", () => {
+    const result = applyCommitPolicy(buildInput({
+      turnType: "edit_request",
+      extractedValues: { time: "10:00" },
+      confidence: { time: 0.88 },
+      activeContract: { requiredSlots: ["time"], intentKind: "edit" }
+    }));
+
+    expect(result.committedSlots.time).toBe("10:00");
+    expect(result.missingSlots).toEqual([]);
+  });
+
+  it("treats missing confidence as zero", () => {
+    const result = applyCommitPolicy(buildInput({
+      turnType: "planning_request",
+      extractedValues: { time: "17:00" },
+      confidence: {}
+    }));
+
+    expect(result.committedSlots.time).toBeUndefined();
+    expect(result.needsClarification).toContain("time");
+  });
+
+  it("handles unresolvable slots not in extractedValues", () => {
+    const result = applyCommitPolicy(buildInput({
+      turnType: "clarification_answer",
+      extractedValues: { day: "friday" },
+      confidence: { day: 0.9 },
+      unresolvable: ["time"]
+    }));
+
+    expect(result.committedSlots.day).toBe("friday");
+    expect(result.needsClarification).toContain("time");
+  });
+});