@oddkin/ai 0.0.0-stage → 1.0.0-beta.0

package/dist/prod/controllers/diff.js

@@ -0,0 +1,41 @@
+const wordTokens = (text) => text.match(/\s+|[^\s]+/gu) ?? [], lineTokens = (text) => text.match(/[^\n]*\n|[^\n]+$/gu) ?? [];
+function diffTokens(before, after, maxCells = 25e4) {
+  let start = 0;
+  for (; start < before.length && start < after.length && before[start] === after[start]; )
+    start++;
+  let endB = before.length, endA = after.length;
+  for (; endB > start && endA > start && before[endB - 1] === after[endA - 1]; )
+    endB--, endA--;
+  const out = [], push = (kind, text) => {
+    if (!text)
+      return;
+    const last = out[out.length - 1];
+    last?.kind === kind ? out[out.length - 1] = { kind, text: last.text + text } : out.push({ kind, text });
+  };
+  push("equal", before.slice(0, start).join(""));
+  const b = before.slice(start, endB), a = after.slice(start, endA);
+  if (b.length * a.length > maxCells)
+    push("delete", b.join("")), push("insert", a.join(""));
+  else {
+    const width = a.length + 1, lengths = new Uint32Array((b.length + 1) * width);
+    for (let i2 = b.length - 1; i2 >= 0; i2--)
+      for (let j2 = a.length - 1; j2 >= 0; j2--)
+        lengths[i2 * width + j2] = b[i2] === a[j2] ? lengths[(i2 + 1) * width + j2 + 1] + 1 : Math.max(lengths[(i2 + 1) * width + j2], lengths[i2 * width + j2 + 1]);
+    let i = 0, j = 0;
+    for (; i < b.length && j < a.length; )
+      b[i] === a[j] ? (push("equal", b[i++]), j++) : lengths[(i + 1) * width + j] >= lengths[i * width + j + 1] ? push("delete", b[i++]) : push("insert", a[j++]);
+    for (; i < b.length; )
+      push("delete", b[i++]);
+    for (; j < a.length; )
+      push("insert", a[j++]);
+  }
+  return push("equal", before.slice(endB).join("")), out;
+}
+const diffWords = (before, after) => diffTokens(wordTokens(before), wordTokens(after)), diffLines = (before, after) => diffTokens(lineTokens(before), lineTokens(after));
+export {
+  diffLines,
+  diffTokens,
+  diffWords,
+  lineTokens,
+  wordTokens
+};

package/dist/prod/controllers/document.js

@@ -0,0 +1,128 @@
+import { signal } from "@oddkin/core/reactive";
+const isHigh = (code) => code >= 55296 && code <= 56319, isLow = (code) => code >= 56320 && code <= 57343;
+function isBoundary(text, offset) {
+  return offset <= 0 || offset >= text.length ? offset === 0 || offset === text.length : !(isHigh(text.charCodeAt(offset - 1)) && isLow(text.charCodeAt(offset)));
+}
+function isValidRange(text, range) {
+  return Number.isInteger(range.start) && Number.isInteger(range.end) && range.start >= 0 && range.end >= range.start && range.end <= text.length && isBoundary(text, range.start) && isBoundary(text, range.end);
+}
+function toCodePointOffset(text, offset) {
+  let points = 0;
+  for (let i = 0; i < offset && i < text.length; i++)
+    isLow(text.charCodeAt(i)) && i > 0 && isHigh(text.charCodeAt(i - 1)) || points++;
+  return points;
+}
+function fromCodePointOffset(text, points) {
+  let offset = 0;
+  for (let p = 0; p < points && offset < text.length; p++)
+    offset += isHigh(text.charCodeAt(offset)) && isLow(text.charCodeAt(offset + 1)) ? 2 : 1;
+  return offset;
+}
+function captureSelection(control, revision) {
+  const start = control.selectionStart ?? 0, end = control.selectionEnd ?? start;
+  if (end <= start)
+    return;
+  const range = { start, end };
+  if (isValidRange(control.value, range))
+    return { revision, start, end, text: control.value.slice(start, end) };
+}
+class DocumentSession {
+  #state;
+  state;
+  #counter = 0;
+  #prefix;
+  #undo = [];
+  constructor(text, options = {}) {
+    this.#prefix = options.revisionPrefix ?? "rev", this.#state = signal({ text, revision: this.#nextRevision(), proposals: [] }), this.state = this.#state;
+  }
+  getSnapshot() {
+    return this.#state.peek();
+  }
+  /** A user edit. Proposals for older revisions become stale. */
+  setText(text) {
+    const now = this.#state.peek();
+    if (text === now.text)
+      return now.revision;
+    const revision = this.#nextRevision();
+    return this.#state.value = {
+      text,
+      revision,
+      proposals: now.proposals.map((p) => p.status === "proposed" ? { ...p, status: "stale" } : p)
+    }, this.#undo.length = 0, revision;
+  }
+  /** Register a proposal from the assistant. Invalid ranges are rejected; stale ones recorded as stale. */
+  propose(proposal) {
+    const now = this.#state.peek();
+    let status = "proposed";
+    proposal.baseRevision !== now.revision ? status = "stale" : (!isValidRange(now.text, proposal.range) || now.text.slice(proposal.range.start, proposal.range.end) !== proposal.original) && (status = "failed");
+    const record = {
+      ...proposal,
+      status,
+      ...status === "failed" ? { error: { code: "ai.edit.range", message: "The proposal does not match the text." } } : {}
+    };
+    return this.#state.value = {
+      ...now,
+      proposals: [...now.proposals.filter((p) => p.proposalId !== record.proposalId), record]
+    }, record;
+  }
+  /** Accept and apply a proposal to its base revision. */
+  accept(proposalId) {
+    const now = this.#state.peek(), proposal = now.proposals.find((p) => p.proposalId === proposalId);
+    if (!proposal)
+      return { ok: !1, reason: "not-found" };
+    if (proposal.status !== "proposed")
+      return { ok: !1, reason: proposal.status === "stale" ? "stale" : "invalid" };
+    if (proposal.baseRevision !== now.revision)
+      return this.#setStatus(proposalId, "stale"), { ok: !1, reason: "stale" };
+    if (now.text.slice(proposal.range.start, proposal.range.end) !== proposal.original)
+      return this.#setStatus(proposalId, "failed"), { ok: !1, reason: "conflict" };
+    const text = now.text.slice(0, proposal.range.start) + proposal.replacement + now.text.slice(proposal.range.end), revision = this.#nextRevision();
+    return this.#undo.push({
+      proposalId,
+      before: now.text,
+      beforeRevision: now.revision,
+      afterRevision: revision
+    }), this.#state.value = {
+      text,
+      revision,
+      proposals: now.proposals.map((p) => p.proposalId === proposalId ? { ...p, status: "applied", appliedRevision: revision } : p.status === "proposed" ? { ...p, status: "stale" } : p)
+    }, { ok: !0, revision };
+  }
+  reject(proposalId) {
+    const proposal = this.#state.peek().proposals.find((p) => p.proposalId === proposalId);
+    return proposal ? proposal.status !== "proposed" && proposal.status !== "stale" ? { ok: !1, reason: "invalid" } : (this.#setStatus(proposalId, "rejected"), { ok: !0, revision: this.#state.peek().revision }) : { ok: !1, reason: "not-found" };
+  }
+  /** Undo an applied proposal if it is the latest change and nothing changed since. */
+  undo(proposalId) {
+    const now = this.#state.peek(), last = this.#undo[this.#undo.length - 1];
+    if (!last || last.proposalId !== proposalId)
+      return { ok: !1, reason: "not-applied" };
+    if (last.afterRevision !== now.revision)
+      return { ok: !1, reason: "stale" };
+    this.#undo.pop();
+    const revision = this.#nextRevision();
+    return this.#state.value = {
+      text: last.before,
+      revision,
+      proposals: now.proposals.map((p) => p.proposalId === proposalId ? { ...p, status: "undone" } : p)
+    }, { ok: !0, revision };
+  }
+  #setStatus(proposalId, status) {
+    const now = this.#state.peek();
+    this.#state.value = {
+      ...now,
+      proposals: now.proposals.map((p) => p.proposalId === proposalId ? { ...p, status } : p)
+    };
+  }
+  #nextRevision() {
+    return `${this.#prefix}-${++this.#counter}`;
+  }
+}
+export {
+  DocumentSession,
+  captureSelection,
+  fromCodePointOffset,
+  isBoundary,
+  isValidRange,
+  toCodePointOffset
+};

package/dist/prod/controllers/external-store.js

@@ -0,0 +1,49 @@
+import { normalizeApproval, normalizeArtifact, normalizeMessage, normalizeToolCall } from "../contracts/normalize.js";
+function selectSource(source, select) {
+  let input = UNSET, output;
+  const read = () => {
+    const next = source.getSnapshot();
+    return next !== input && (input = next, output = select(next)), output;
+  };
+  return {
+    getSnapshot: read,
+    subscribe(listener) {
+      let last = read();
+      return source.subscribe(() => {
+        const next = read();
+        next !== last && (last = next, listener());
+      });
+    }
+  };
+}
+const UNSET = /* @__PURE__ */ Symbol("unset");
+function createConversationView(input, onDiagnostic) {
+  const keep = (items, normalize, path) => {
+    const out = [];
+    return (items ?? []).forEach((item, i) => {
+      const result = normalize(item, `${path}/${i}`);
+      for (const d of result.diagnostics)
+        onDiagnostic?.(d);
+      result.value && out.push(result.value);
+    }), out;
+  }, messages = keep(input.messages, normalizeMessage, "/messages");
+  return {
+    conversationId: input.conversationId,
+    revision: input.revision ?? 0,
+    messages,
+    tools: Object.fromEntries(keep(input.tools, normalizeToolCall, "/tools").map((t) => [t.toolCallId, t])),
+    approvals: Object.fromEntries(keep(input.approvals, normalizeApproval, "/approvals").map((a) => [a.approvalId, a])),
+    artifacts: Object.fromEntries(keep(input.artifacts, normalizeArtifact, "/artifacts").map((a) => [a.artifactId, a])),
+    attempts: Object.fromEntries((input.attempts ?? []).map((a) => [a.attemptId, a])),
+    branches: input.branches ?? {},
+    activeAttemptId: input.activeAttemptId,
+    capabilities: input.capabilities,
+    history: input.history ?? (input.hasMoreHistory ? "idle" : "complete"),
+    hasMoreHistory: input.hasMoreHistory ?? !1,
+    feedback: input.feedback ?? {}
+  };
+}
+export {
+  createConversationView,
+  selectSource
+};

package/dist/prod/controllers/index.js

@@ -0,0 +1,43 @@
+import { ConversationController } from "./conversation.js";
+import { ComposerController, matchesAccept } from "./composer.js";
+import { DocumentSession, captureSelection, fromCodePointOffset, isBoundary, isValidRange, toCodePointOffset } from "./document.js";
+import { diffLines, diffTokens, diffWords, lineTokens, wordTokens } from "./diff.js";
+import { VoiceController, createScriptedVoiceAdapter } from "./voice.js";
+import { DEFAULT_ANNOUNCEMENTS, describeConversationChange, format } from "./announcer.js";
+import { APPROVAL_TRANSITIONS, ATTEMPT_TRANSITIONS, CONNECTION_TRANSITIONS, TOOL_TRANSITIONS, applyStopOutcome, canTransition, isActive, isTerminal, stopAfterTerminal } from "./transitions.js";
+import { bindIntents, controllerIntents } from "./intents.js";
+import { createConversationView, selectSource } from "./external-store.js";
+export {
+  APPROVAL_TRANSITIONS,
+  ATTEMPT_TRANSITIONS,
+  CONNECTION_TRANSITIONS,
+  ComposerController,
+  ConversationController,
+  DEFAULT_ANNOUNCEMENTS,
+  DocumentSession,
+  TOOL_TRANSITIONS,
+  VoiceController,
+  applyStopOutcome,
+  bindIntents,
+  canTransition,
+  captureSelection,
+  controllerIntents,
+  createConversationView,
+  createScriptedVoiceAdapter,
+  describeConversationChange,
+  diffLines,
+  diffTokens,
+  diffWords,
+  format,
+  fromCodePointOffset,
+  isActive,
+  isBoundary,
+  isTerminal,
+  isValidRange,
+  lineTokens,
+  matchesAccept,
+  selectSource,
+  stopAfterTerminal,
+  toCodePointOffset,
+  wordTokens
+};

package/dist/prod/controllers/intents.js

@@ -0,0 +1,73 @@
+function bindIntents(target, handlers) {
+  const releases = [];
+  for (const [type, handler] of Object.entries(handlers)) {
+    if (typeof handler != "function")
+      continue;
+    const listener = (event) => handler(event.detail, event);
+    target.addEventListener(type, listener), releases.push(() => target.removeEventListener(type, listener));
+  }
+  return () => {
+    for (const release of releases.splice(0))
+      release();
+  };
+}
+function controllerIntents(controller, composer, options = {}) {
+  const report = (intent) => (result) => options.onResult?.(intent, result);
+  return {
+    "odd-prompt-submit": (detail) => {
+      const files = detail.attachments.map((a) => ({
+        type: "file",
+        id: a.id,
+        name: a.name,
+        mediaType: a.mediaType,
+        size: a.size,
+        ...a.url ? { url: a.url } : {}
+      }));
+      controller.send({ text: detail.text, files }).then((result) => {
+        composer && (result.ok ? composer.acknowledge(detail.submissionId) : composer.fail(detail.submissionId, result.error ?? {
+          code: `ai.send.${result.reason}`,
+          message: "The message could not be sent.",
+          retryable: !0
+        })), report("odd-prompt-submit")(result);
+      });
+    },
+    "odd-prompt-stop": (detail) => {
+      controller.stop(detail.attemptId).then(report("odd-prompt-stop"));
+    },
+    "odd-history-request": () => {
+      controller.loadHistory().then(report("odd-history-request"));
+    },
+    "odd-message-edit": (detail) => {
+      controller.edit(detail.messageId, detail.text).then(report("odd-message-edit"));
+    },
+    "odd-message-regenerate": (detail) => {
+      controller.regenerate(detail.messageId).then(report("odd-message-regenerate"));
+    },
+    "odd-attempt-retry": (detail) => {
+      controller.retry(detail.attemptId).then(report("odd-attempt-retry"));
+    },
+    "odd-attempt-resume": (detail) => {
+      controller.resume(detail.attemptId).then(report("odd-attempt-resume"));
+    },
+    "odd-branch-switch": (detail) => report("odd-branch-switch")(controller.switchBranch(detail.targetMessageId)),
+    "odd-approval-decide": (detail) => {
+      controller.decide(detail.approvalId, detail.revision, detail.decision, detail.reason).then(report("odd-approval-decide"));
+    },
+    "odd-feedback-submit": (detail) => {
+      controller.submitFeedback({
+        messageId: detail.messageId,
+        rating: detail.rating,
+        reasons: [...detail.reasons],
+        ...detail.comment ? { comment: detail.comment } : {}
+      }).then(report("odd-feedback-submit"));
+    },
+    "odd-suggestion-submit": (detail) => {
+      controller.send({ text: detail.prompt }).then(report("odd-suggestion-submit"));
+    },
+    "odd-suggestion-select": (detail) => composer?.setText(detail.prompt)
+  };
+}
+export {
+  bindIntents,
+  controllerIntents
+};

package/dist/prod/controllers/transitions.js

@@ -0,0 +1,90 @@
+const ATTEMPT_TRANSITIONS = {
+  submitted: [
+    "accepted",
+    "streaming",
+    "awaiting-input",
+    "completed",
+    "cancelled",
+    "failed",
+    "interrupted"
+  ],
+  accepted: ["streaming", "awaiting-input", "completed", "cancelled", "failed", "interrupted"],
+  streaming: ["awaiting-input", "completed", "cancelled", "failed", "interrupted"],
+  "awaiting-input": ["streaming", "completed", "cancelled", "failed", "interrupted"],
+  // A resumed stream may continue or end an interrupted attempt.
+  interrupted: ["streaming", "awaiting-input", "completed", "cancelled", "failed"],
+  completed: [],
+  cancelled: [],
+  failed: []
+}, TOOL_TRANSITIONS = {
+  "input-streaming": ["input-available", "output-error", "cancelled"],
+  "input-available": [
+    "awaiting-approval",
+    "executing",
+    "output-available",
+    "output-error",
+    "denied",
+    "cancelled"
+  ],
+  "awaiting-approval": ["executing", "output-available", "output-error", "denied", "cancelled"],
+  executing: ["output-available", "output-error", "cancelled"],
+  // A host retry runs the tool again.
+  "output-error": ["executing"],
+  "output-available": [],
+  denied: [],
+  cancelled: []
+}, APPROVAL_TRANSITIONS = {
+  // approved/rejected directly: decided elsewhere (another client or an automatic policy).
+  requested: ["decision-pending", "approved", "rejected", "expired", "superseded"],
+  "decision-pending": ["approved", "rejected", "decision-failed", "expired", "superseded"],
+  "decision-failed": ["decision-pending", "approved", "rejected", "expired", "superseded"],
+  approved: [],
+  rejected: [],
+  expired: [],
+  superseded: []
+}, CONNECTION_TRANSITIONS = {
+  idle: ["connecting", "open", "closed"],
+  connecting: ["open", "closed", "disconnected"],
+  open: ["closed", "disconnected"],
+  disconnected: ["reconnecting"],
+  closed: ["reconnecting"],
+  reconnecting: ["open", "closed", "disconnected"]
+};
+function canTransition(table, from, to) {
+  return from === to || table[from].includes(to);
+}
+const TERMINAL = /* @__PURE__ */ new Set(["completed", "cancelled", "failed"]), isTerminal = (status) => TERMINAL.has(status), isActive = (status) => status === "submitted" || status === "accepted" || status === "streaming" || status === "awaiting-input", TOOL_SETTLED = /* @__PURE__ */ new Set([
+  "output-available",
+  "output-error",
+  "denied",
+  "cancelled"
+]);
+function applyStopOutcome(status, outcome) {
+  const terminal = isTerminal(status);
+  switch (outcome) {
+    case "cancelled":
+      return terminal ? { status, stop: status === "cancelled" ? "confirmed" : "too-late" } : { status: "cancelled", stop: "confirmed" };
+    case "already-finished":
+      return { status, stop: "too-late" };
+    case "not-found":
+    case "unknown":
+      return { status, stop: "unknown" };
+    case "rejected":
+      return { status, stop: "failed" };
+  }
+}
+function stopAfterTerminal(stop, terminal) {
+  return stop !== "requested" ? stop : terminal === "cancelled" ? "confirmed" : "too-late";
+}
+export {
+  APPROVAL_TRANSITIONS,
+  ATTEMPT_TRANSITIONS,
+  CONNECTION_TRANSITIONS,
+  TOOL_SETTLED,
+  TOOL_TRANSITIONS,
+  applyStopOutcome,
+  canTransition,
+  isActive,
+  isTerminal,
+  stopAfterTerminal
+};

package/dist/prod/controllers/voice.js

@@ -0,0 +1,134 @@
+import { signal } from "@oddkin/core/reactive";
+import { createId } from "../internal/ids.js";
+const STATUS_FOR_ERROR = {
+  "permission-denied": "denied",
+  "no-device": "unavailable",
+  network: "error",
+  interrupted: "interrupted",
+  other: "error"
+};
+class VoiceController {
+  #state;
+  state;
+  #adapter;
+  #session;
+  #generation = 0;
+  constructor(adapter) {
+    this.#adapter = adapter, this.#state = signal({
+      status: adapter?.supported ? "idle" : "unsupported",
+      interim: "",
+      segments: []
+    }), this.state = this.#state;
+  }
+  getSnapshot() {
+    return this.#state.peek();
+  }
+  /** Replace the adapter; any running session is cancelled. */
+  setAdapter(adapter) {
+    this.cancel(), this.#adapter = adapter, this.#set({ status: adapter?.supported ? "idle" : "unsupported", interim: "" });
+  }
+  get active() {
+    return this.#session !== void 0;
+  }
+  start() {
+    const adapter = this.#adapter;
+    if (!adapter?.supported || this.#session)
+      return !1;
+    const generation = ++this.#generation, live = () => generation === this.#generation;
+    this.#set({ status: "requesting-permission", interim: "", error: void 0 });
+    const session = adapter.start({
+      started: () => live() && this.#set({ status: "recording" }),
+      interim: (text) => live() && this.#set({ interim: text }),
+      final: (text) => {
+        if (!live() || !text)
+          return;
+        const now = this.#state.peek();
+        this.#set({
+          interim: "",
+          segments: [...now.segments, { id: createId("segment"), text, final: !0 }]
+        });
+      },
+      processing: () => live() && this.#set({ status: "processing" }),
+      ended: (reason, error) => {
+        live() && (this.#session = void 0, this.#generation++, reason === "error" ? this.#set({
+          status: STATUS_FOR_ERROR[error ?? "other"],
+          interim: "",
+          error: error ?? "other"
+        }) : this.#set({ status: "idle", interim: "" }));
+      }
+    });
+    return live() && (this.#session = session), !0;
+  }
+  /** Finish recording and keep the final transcript. */
+  stop() {
+    this.#session?.stop();
+  }
+  /** Discard the current recording and interim text; final segments already received stay. */
+  cancel() {
+    const session = this.#session;
+    session && (this.#session = void 0, this.#generation++, session.cancel(), this.#set({ status: "idle", interim: "" }));
+  }
+  /** Replace or edit the transcript (user edits). */
+  setSegments(segments) {
+    this.#set({ segments });
+  }
+  clear() {
+    this.#set({ segments: [], interim: "" });
+  }
+  dispose() {
+    this.cancel(), this.#adapter = void 0;
+  }
+  #set(patch) {
+    this.#state.value = { ...this.#state.peek(), ...patch };
+  }
+}
+function createScriptedVoiceAdapter(script, options = {}) {
+  let open = 0;
+  return {
+    supported: !0,
+    get openResources() {
+      return open;
+    },
+    start(handlers) {
+      const timers = /* @__PURE__ */ new Set();
+      let ended = !1;
+      open++;
+      const schedule = (ms, fn) => {
+        const id = setTimeout(() => {
+          timers.delete(id), ended || fn();
+        }, ms);
+        timers.add(id);
+      }, finish = (reason, error) => {
+        if (!ended) {
+          ended = !0;
+          for (const id of timers)
+            clearTimeout(id);
+          timers.clear(), open--, reason !== "cancelled" && handlers.ended(reason, error);
+        }
+      };
+      return schedule(options.permissionDelay ?? 0, () => {
+        if (options.denyPermission)
+          return finish("error", "permission-denied");
+        if (options.noDevice)
+          return finish("error", "no-device");
+        handlers.started();
+        let at = 0;
+        for (const step of script)
+          at += step.after, schedule(at, () => {
+            "interim" in step ? handlers.interim(step.interim) : "final" in step ? handlers.final(step.final) : finish("error", step.error);
+          });
+      }), {
+        stop() {
+          ended || (handlers.processing(), schedule(0, () => finish("stopped")));
+        },
+        cancel() {
+          finish("cancelled");
+        }
+      };
+    }
+  };
+}
+export {
+  VoiceController,
+  createScriptedVoiceAdapter
+};

package/dist/prod/conversation/conversation.define.js

@@ -0,0 +1,3 @@
+import { define } from "@oddkin/core/element";
+import { conversationDefinition } from "./conversation.definition.js";
+define(conversationDefinition);

package/dist/prod/conversation/conversation.definition.js

@@ -0,0 +1,17 @@
+import { compose } from "@oddkin/core/element";
+import { activityDefinition } from "../activity/activity.definition.js";
+import { aiBaseStyles } from "../internal/base.styles.js";
+import { messageDefinition } from "../message/message.definition.js";
+import { OddkinConversation } from "./conversation.js";
+import { conversationStyles } from "./conversation.styles.js";
+import { conversationTemplate } from "./conversation.template.js";
+const conversationDefinition = compose({
+  name: "odd-conversation",
+  element: OddkinConversation,
+  template: conversationTemplate,
+  styles: [aiBaseStyles, conversationStyles],
+  dependencies: { message: messageDefinition, activity: activityDefinition }
+});
+export {
+  conversationDefinition
+};