@jskit-ai/assistant-core 0.1.200 → 0.1.202

package/src/client/conversation/messageDelivery.js

@@ -1,26 +1,29 @@
-import { reactive } from "vue";
+import { reactive, toRaw, toValue, watch } from "vue";
 
 const messageText = value => String(value || "").trim();
 
 function turnMatchesOptimisticMessage(turn = {}, optimistic = {}) {
-  const canonicalMessageId = messageText(turn?.user?.messageId);
+  const authored = optimistic.origin === "application" ? turn.system : turn.user;
+  const canonicalMessageId = messageText(authored?.messageId);
   const optimisticMessageId = messageText(optimistic.id);
   if (canonicalMessageId && optimisticMessageId) {
     return canonicalMessageId === optimisticMessageId;
   }
-  if (messageText(turn?.user?.text) !== optimistic.text) {
+  if (messageText(authored?.text) !== optimistic.text) {
     return false;
   }
-  const userAtMs = Date.parse(String(turn?.user?.at || ""));
+  const userAtMs = Date.parse(String(authored?.at || ""));
   return Number.isFinite(userAtMs) && userAtMs >= optimistic.createdAtMs - 5000;
 }
 
-function unmatchedOptimisticMessages(turns = [], optimisticMessages = []) {
+function unmatchedOptimisticMessages(turns = [], optimisticMessages = [], { receiptsOnly = false } = {}) {
   const conversationTurns = Array.isArray(turns) ? turns : [];
   const matchedTurnIndexes = new Set();
   return (Array.isArray(optimisticMessages) ? optimisticMessages : []).filter((message) => {
     const turnIndex = conversationTurns.findIndex((turn, index) => (
-      !matchedTurnIndexes.has(index) && turnMatchesOptimisticMessage(turn, message)
+      !matchedTurnIndexes.has(index) && turnMatchesOptimisticMessage(turn, message) &&
+      (!receiptsOnly || message.status === "accepted" ||
+        (message.origin === "application" ? turn.system : turn.user)?.receipt !== false)
     ));
     if (turnIndex < 0) {
       return true;
@@ -31,9 +34,10 @@ function unmatchedOptimisticMessages(turns = [], optimisticMessages = []) {
 }
 
 // One delivery state per conversation. The caller owns transport and receipts;
-// the shared assistant element renders these pending and failed turns.
+// the shared assistant element renders pending, failed and uncertain turns.
 function createAssistantMessageDelivery({ deliver: defaultDeliver } = {}) {
   const state = reactive({ messages: [], sending: false });
+  const acceptanceCallbacks = new WeakMap();
   let deliveryTail = null;
   let pendingSends = new Map();
 
@@ -46,35 +50,64 @@ function createAssistantMessageDelivery({ deliver: defaultDeliver } = {}) {
   }
 
   function reconcile(turns) {
-    state.messages = unmatchedOptimisticMessages(turns, state.messages);
+    const unmatched = unmatchedOptimisticMessages(turns, state.messages, { receiptsOnly: true });
+    const retained = new Set(unmatched.map(message => message.id));
+    for (const message of state.messages) {
+      if (!retained.has(message.id)) accept(message.id);
+    }
+    state.messages = unmatched;
   }
 
   function turns(savedTurns = []) {
     return [
-      ...savedTurns,
-      ...unmatchedOptimisticMessages(savedTurns, state.messages).map((message) => ({
-        optimistic: { error: message.error, id: message.id, status: message.status },
-        turnId: message.id,
-        user: {
-          attachments: message.attachments,
-          at: message.createdAt,
-          messageId: message.id,
-          role: "user",
-          text: message.text
-        }
-      }))
+      ...savedTurns.map(turn => {
+        const message = state.messages.find(message => message.status !== "accepted" &&
+          turnMatchesOptimisticMessage(turn, message) &&
+          (message.origin === "application" ? turn.system : turn.user)?.receipt === false);
+        if (!message) return turn;
+        const pending = optimisticTurn(message);
+        return { ...turn, optimistic: pending.optimistic, ...(pending.system ? { system: pending.system } : {}) };
+      }),
+      ...unmatchedOptimisticMessages(savedTurns, state.messages).map(optimisticTurn)
     ];
   }
 
+  function optimisticTurn(message) {
+    const role = message.origin === "application" ? "system" : "user";
+    const authored = {
+      attachments: message.attachments,
+      at: message.createdAt,
+      messageId: message.id,
+      role,
+      text: message.text
+    };
+    const status = message.status === "uncertain" ? {
+      role: "system", text: "Message delivery is not confirmed.",
+      delivery: { messageId: message.id, error: message.error, checking: message.checking === true }
+    } : null;
+    return {
+      optimistic: { error: message.error, id: message.id, status: message.status },
+      turnId: message.id,
+      [role]: authored,
+      ...(status ? { system: role === "system" ? { ...authored, ...status, text: `${authored.text}\n\n${status.text}` } : status } : {})
+    };
+  }
+
   async function send(payload, {
     messageId = crypto.randomUUID(),
     deliver = defaultDeliver,
     isCurrent = () => true,
+    receiptTurns = null,
+    onAccepted,
+    uncertainOnError = false,
     queue = false
   } = {}) {
-    if ((state.sending && !queue) || pendingSends.has(messageId) || !messageText(payload?.message)) return false;
+    if ((state.sending && !queue) || pendingSends.has(messageId) || find(messageId)?.status === "uncertain" ||
+        (!messageText(payload?.message) && !payload?.displayAttachments?.length)) return false;
     if (typeof deliver !== "function") throw new TypeError("Message delivery requires a deliver function.");
     const snapshot = JSON.parse(JSON.stringify(payload));
+    const previous = find(messageId);
+    const acknowledge = previous && acceptanceCallbacks.get(toRaw(previous)) || onAccepted;
     const ownerPendingSends = pendingSends;
     const current = () => pendingSends === ownerPendingSends && isCurrent();
     const predecessor = deliveryTail;
@@ -90,27 +123,44 @@ function createAssistantMessageDelivery({ deliver: defaultDeliver } = {}) {
       id: messageId,
       payload: snapshot,
       status: "pending",
-      text: String(snapshot.displayMessage || snapshot.message).trim()
+      text: String(snapshot.displayMessage || snapshot.message || "").trim()
     };
+    if (typeof acknowledge === "function") acceptanceCallbacks.set(message, acknowledge);
     state.messages = [...state.messages.filter((entry) => entry.id !== messageId), message];
     state.sending = true;
+    let stopReceipt;
     try {
       if (predecessor) await predecessor;
       if (!current()) return false;
-      const response = await deliver({ ...snapshot, messageId });
+      if (uncertainOnError && state.messages.some(entry => entry.id !== messageId && entry.status === "uncertain")) {
+        fail(messageId, "Check the previous message's delivery before sending again.");
+        return false;
+      }
+      let receipt;
+      if (receiptTurns !== null) {
+        receipt = Promise.withResolvers();
+        settled.receipt = receipt;
+        stopReceipt = watch([current, () => toValue(receiptTurns)], ([isCurrent, turns]) => {
+          if (!isCurrent) receipt.resolve(false);
+          else if (turns?.some(turn => turn.user?.messageId === messageId && turn.user.receipt !== false)) receipt.resolve({ ok: true });
+        }, { immediate: true });
+      }
+      const submitted = deliver({ ...snapshot, messageId });
+      const response = await (receipt ? Promise.race([submitted, receipt.promise]) : submitted);
       if (!current()) return false;
       if (response === false || response?.ok === false) {
-        fail(messageId, response?.error || "Message could not be sent.");
+        fail(messageId, response?.error || "Message could not be sent.", response?.status === "uncertain" ? "uncertain" : "failed");
       } else {
-        const acceptedMessage = find(messageId);
-        if (acceptedMessage) acceptedMessage.status = "accepted";
+        accept(messageId);
       }
       return response;
     } catch (error) {
       if (!current()) return false;
-      fail(messageId, error);
+      if (find(messageId)?.status === "accepted") return { ok: true };
+      fail(messageId, error, uncertainOnError || error?.status === "uncertain" ? "uncertain" : "failed");
       throw error;
     } finally {
+      stopReceipt?.();
       ownerPendingSends.delete(messageId);
       if (pendingSends === ownerPendingSends) {
         state.sending = ownerPendingSends.size > 0;
@@ -120,14 +170,43 @@ function createAssistantMessageDelivery({ deliver: defaultDeliver } = {}) {
     }
   }
 
-  function fail(messageId, error) {
+  function fail(messageId, error, status = "failed") {
     const message = find(messageId);
-    if (message) {
+    if (message && message.status !== "accepted") {
       message.error = String(error?.message || error || "Message could not be sent.").trim();
-      message.status = "failed";
+      message.status = status;
+    }
+  }
+
+  function accept(messageId) {
+    const message = find(messageId);
+    if (message) { message.status = "accepted"; message.error = ""; }
+    pendingSends.get(messageId)?.receipt?.resolve({ ok: true });
+    if (message) {
+      const entry = toRaw(message);
+      const acknowledge = acceptanceCallbacks.get(entry);
+      acceptanceCallbacks.delete(entry);
+      acknowledge?.();
     }
   }
 
+  function restoreUncertain(request, savedTurns = []) {
+    const messageId = messageText(request?.messageId);
+    if (!messageId || savedTurns.some(turn => (turn.user || turn.system)?.messageId === messageId &&
+        (turn.user || turn.system).receipt !== false) ||
+        find(messageId)?.status === "accepted") return false;
+    if (!find(messageId)) {
+      const payload = JSON.parse(JSON.stringify({ message: request.text || "", displayAttachments: request.attachments || [] }));
+      const createdAt = request.at || new Date().toISOString();
+      state.messages = [...state.messages, { id: messageId, payload, text: payload.message, origin: request.origin,
+        attachments: payload.displayAttachments, createdAt, createdAtMs: Date.parse(createdAt),
+        status: "uncertain", error: "" }];
+    }
+    fail(messageId, request.error || "Delivery could not be confirmed.", "uncertain");
+    pendingSends.get(messageId)?.receipt?.resolve({ ok: false, status: "uncertain", error: request.error });
+    return true;
+  }
+
   function cancel(messageId) {
     if (find(messageId)?.status !== "failed") return false;
     remove(messageId);
@@ -148,13 +227,17 @@ function createAssistantMessageDelivery({ deliver: defaultDeliver } = {}) {
 
   function reset() {
     deliveryTail = null;
-    for (const pending of pendingSends.values()) pending.resolve();
+    for (const pending of pendingSends.values()) {
+      pending.receipt?.resolve(false);
+      pending.resolve();
+    }
     pendingSends = new Map();
     state.messages = [];
     state.sending = false;
   }
 
-  return { cancel, edit, find, reconcile, remove, resend, reset, send, state, turns };
+  return { accept, cancel, edit, find, reconcile, remove, resend, reset, restoreUncertain, send, state, turns };
 }
 
 export { createAssistantMessageDelivery, unmatchedOptimisticMessages };
+export { retainAssistantConversation } from "./retainedConversation.js";

package/src/client/conversation/retainedConversation.js

@@ -0,0 +1,32 @@
+import { effectScope, shallowReactive } from "vue";
+
+const applicationConversations = new WeakMap();
+
+/** Views and voice retain the same readers and delivery state for an exact target. */
+function retainAssistantConversation(app, key, createRuntime, reader = { active: true }) {
+  let conversations = applicationConversations.get(app);
+  if (!conversations) { conversations = new Map(); applicationConversations.set(app, conversations); }
+  let entry = conversations.get(key);
+  if (!entry) {
+    const scope = effectScope(true);
+    const readers = shallowReactive(new Map());
+    try {
+      const runtime = app.runWithContext(() => scope.run(() => createRuntime(readers)));
+      entry = { scope, readers, runtime };
+      runtime.retain = () => retainAssistantConversation(app, key, createRuntime);
+      conversations.set(key, entry);
+    } catch (error) { scope.stop(); throw error; }
+  }
+  const token = Symbol("conversation reader");
+  entry.readers.set(token, reader);
+  return {
+    runtime: entry.runtime,
+    release() {
+      if (!entry.readers.delete(token) || entry.readers.size) return;
+      entry.scope.stop();
+      conversations.delete(key);
+    }
+  };
+}
+
+export { retainAssistantConversation };

package/src/client/conversation/useAssistantQuestions.js

@@ -0,0 +1,76 @@
+import { computed, ref, toValue, watch } from "vue";
+import { numberedQuestionSubmissionText, parseNumberedQuestionPrompt } from "../../shared/conversation/numberedQuestionSugar.js";
+import { parseAnswerChoicePrompt } from "../../shared/conversation/answerChoiceSugar.js";
+
+/** Ordinary chat answer fields; the caller owns authorized message selection and delivery. */
+function useAssistantQuestions({ message = "", extraChoice = null } = {}) {
+  const questionText = computed(() => String(toValue(message) || ""));
+  const answers = ref({});
+  const choice = ref("");
+  const dismissedText = ref("");
+  const submittedText = ref("");
+  const numberedInput = computed(() => parseNumberedQuestionPrompt(questionText.value));
+  const questions = computed(() => (
+    [dismissedText.value, submittedText.value].includes(questionText.value)
+      ? []
+      : numberedInput.value.questions || []
+  ));
+  const selectItems = computed(() => Object.fromEntries(
+    questions.value.map((question) => {
+      const choices = Array.isArray(question.choices) ? question.choices : [];
+      const extra = toValue(extraChoice);
+      const includesExtra = extra && choices.some((item) => (
+        String(item?.value || "").trim().toLowerCase() === String(extra.value || "").trim().toLowerCase()
+      ));
+      return [question.name, !extra || includesExtra ? choices : [...choices, extra]];
+    })
+  ));
+  const choices = computed(() => (
+    questions.value.length || submittedText.value === questionText.value
+      ? []
+      : parseAnswerChoicePrompt(questionText.value).choices || []
+  ));
+  const active = computed(() => Boolean(questions.value.length || choices.value.length));
+
+  function capture(draft = "") {
+    const additionalContext = String(draft || "").trim();
+    return {
+      message: questions.value.length
+        ? [numberedQuestionSubmissionText(questions.value, answers.value), additionalContext].filter(Boolean).join("\n\n")
+        : choice.value || additionalContext,
+      questionText: active.value ? questionText.value : ""
+    };
+  }
+
+  function markSubmitted(text = "") {
+    submittedText.value = text;
+    answers.value = {};
+    choice.value = "";
+  }
+
+  function dismiss() {
+    if (!questions.value.length) return false;
+    dismissedText.value = questionText.value;
+    answers.value = {};
+    return true;
+  }
+
+  function reset() {
+    answers.value = {};
+    dismissedText.value = "";
+    submittedText.value = "";
+    choice.value = "";
+  }
+
+  watch(questionText, (text) => {
+    answers.value = {};
+    if (text !== dismissedText.value) dismissedText.value = "";
+    if (text !== submittedText.value) submittedText.value = "";
+    choice.value = "";
+  });
+
+  return { questions, selectItems, choices, answers, choice, active, capture, markSubmitted, dismiss, reset,
+    setAnswers(value) { answers.value = value; }, setChoice(value) { choice.value = value; } };
+}
+
+export { useAssistantQuestions };

package/src/client/lib/assistantApi.js

@@ -77,12 +77,82 @@ function resolveRequiredBasePath(resolveBasePath) {
 }
 
 function createAssistantApi({ request, requestStream, resolveBasePath, resolveSurfaceId = null } = {}) {
-  if (typeof request !== "function" || typeof requestStream !== "function") {
-    throw new Error("createAssistantApi requires request() and requestStream().");
+  if (typeof request !== "function") {
+    throw new Error("createAssistantApi requires request().");
+  }
+
+  function requestConversation(conversationId, suffix, options) {
+    const basePath = resolveRequiredBasePath(resolveBasePath);
+    const encodedId = encodeURIComponent(String(conversationId || "").trim());
+    const headers = resolveAssistantRequestHeaders(resolveSurfaceId);
+    return request(`${basePath}/conversations/${encodedId}${suffix}`, {
+      ...options,
+      ...(headers ? { headers } : {})
+    });
   }
 
   return Object.freeze({
+    readConversation(conversationId, { signal, beforeTurnId, limit } = {}) {
+      const params = new URLSearchParams();
+      appendQueryParam(params, "beforeTurnId", beforeTurnId);
+      appendQueryParam(params, "limit", limit);
+      return requestConversation(conversationId, params.size ? `?${params}` : "", { method: "GET", signal });
+    },
+
+    sendConversationMessage(conversationId, payload, { signal } = {}) {
+      return requestConversation(conversationId, "/messages", {
+        method: "POST", signal,
+        body: {
+          messageId: payload.messageId,
+          text: payload.text,
+          ...(Object.hasOwn(payload, "data") ? { data: payload.data } : {}),
+          ...(Object.hasOwn(payload, "attachmentIds") ? { attachmentIds: payload.attachmentIds } : {}),
+          ...(Object.hasOwn(payload, "steer") ? { steer: payload.steer } : {})
+        }
+      });
+    },
+
+    cancelConversation(conversationId, { signal } = {}) {
+      return requestConversation(conversationId, "/cancel", { method: "POST", signal });
+    },
+
+    inspectConversationDelivery(conversationId, messageId, { signal } = {}) {
+      const encodedMessageId = encodeURIComponent(String(messageId || "").trim());
+      return requestConversation(conversationId, `/deliveries/${encodedMessageId}/inspect`, { method: "POST", signal });
+    },
+
+    readConversationGoal(conversationId, { signal } = {}) {
+      return requestConversation(conversationId, "/goal", { method: "GET", signal });
+    },
+
+    updateConversationGoal(conversationId, payload, { signal } = {}) {
+      const body = {};
+      for (const key of ["action", "expectedSegmentId", "expectedGoalId", "messageId", "objective", "tokenBudget", "attachmentIds"]) {
+        if (Object.hasOwn(payload, key)) body[key] = payload[key];
+      }
+      return requestConversation(conversationId, "/goal", { method: "POST", signal, body });
+    },
+
+    configureConversation(conversationId, configuration, { signal } = {}) {
+      return requestConversation(conversationId, "/configuration", {
+        method: "PATCH", signal, body: { configuration }
+      });
+    },
+
+    selectConversation(conversationId, selection, { signal } = {}) {
+      return requestConversation(conversationId, "/selection", {
+        method: "POST", signal, body: { selection }
+      });
+    },
+
+    replaceConversation(conversationId, replacement, { signal } = {}) {
+      return requestConversation(conversationId, "/replacement", {
+        method: "POST", signal, body: { replacement }
+      });
+    },
+
     async streamChat(payload, { signal, onEvent, onMalformedLine, rejectOnErrorEvent = true } = {}) {
+      if (typeof requestStream !== "function") throw new TypeError("streamChat requires requestStream().");
       const basePath = resolveRequiredBasePath(resolveBasePath);
       let streamEventError = null;
       const requestHeaders = resolveAssistantRequestHeaders(resolveSurfaceId);

package/src/server/conversation/agentRun.js

@@ -0,0 +1,222 @@
+import { isPlainObject, normalizeText } from "./normalize.js";
+import { createReentrantConversationStorage } from "./storage.js";
+import { normalizeCodexAppServerRunState, codexAppServerRunStateIsActive,
+  codexAppServerRunStateIsTerminal } from "./codexTurn.js";
+
+const normalizeRunState = state => normalizeCodexAppServerRunState(normalizeText(state));
+const runStateIsActive = state => codexAppServerRunStateIsActive(normalizeText(state));
+const runStateIsTerminal = state => codexAppServerRunStateIsTerminal(normalizeText(state));
+
+export function conversationAgentRunRecord(record, normalizedRunId, {
+  normalizeState = normalizeRunState,
+  isActive = runStateIsActive
+} = {}) {
+  return isPlainObject(record)
+    ? {
+        ...record,
+        active: isActive(record.state),
+        events: Array.isArray(record.events) ? record.events.filter(isPlainObject) : [],
+        id: normalizedRunId,
+        state: normalizeState(record.state)
+      }
+    : null;
+}
+
+export function conversationAgentRunEvent(previous, normalizedRunId, {
+  event = {},
+  patch = {}
+} = {}, {
+  now = () => new Date(),
+  normalizeState = normalizeRunState,
+  isTerminal = runStateIsTerminal
+} = {}) {
+  const eventAt = normalizeText(event.at || patch.updatedAt) || now().toISOString();
+  const state = normalizeState(patch.state || event.state || previous.state);
+  const terminalState = isTerminal(state);
+  const eventRecord = {
+    ...event,
+    at: eventAt,
+    kind: normalizeText(event.kind || state || "updated"),
+    message: normalizeText(event.message || patch.message),
+    state
+  };
+  const record = {
+    ...previous,
+    ...patch,
+    active: !terminalState,
+    events: [
+      ...(Array.isArray(previous.events) ? previous.events : []),
+      eventRecord
+    ],
+    finishedAt: terminalState
+      ? normalizeText(patch.finishedAt || previous.finishedAt) || eventAt
+      : "",
+    id: normalizedRunId,
+    startedAt: normalizeText(previous.startedAt || patch.startedAt) || eventAt,
+    state,
+    updatedAt: eventAt
+  };
+  if (!terminalState && !Object.hasOwn(patch, "error")) {
+    record.error = "";
+  }
+  return record;
+}
+
+/** The original native run occupies its bound conversation segment. Reading a
+ * binding without a run never constructs historical ownership or writes state.
+ */
+export function createCodexConversationRunStore({ storage, scope, segmentId, isCurrent, clock = () => new Date() } = {}) {
+  if (typeof isCurrent !== "function") throw new TypeError("A native run store requires its provider ownership fence.");
+  storage = createReentrantConversationStorage(storage);
+  const runId = "codex_app_server";
+
+  function assertScope(sessionId, requestedRunId = runId) {
+    if (sessionId !== scope) throw new Error("The native run belongs to another conversation.");
+    if (normalizeText(requestedRunId) !== runId) throw new TypeError("This binding stores only its Codex app-server run.");
+    if (!isCurrent()) throw new Error("A retired provider cannot change a native binding.");
+  }
+
+  async function currentMetadata(transaction) {
+    const metadata = await transaction.readMetadata();
+    if (!isCurrent() || metadata.runtime?.segmentId !== segmentId || metadata.runtime?.engine !== "codex") {
+      throw new Error("A retired native conversation cannot change the current binding.");
+    }
+    return metadata;
+  }
+
+  async function readAgentRun(sessionId, requestedRunId) {
+    assertScope(sessionId, requestedRunId);
+    return storage.read(scope, async transaction => {
+      const metadata = await currentMetadata(transaction);
+      return conversationAgentRunRecord(metadata.runtime.binding?.codexAppServerRun, runId);
+    });
+  }
+
+  function mutateSession(sessionId, operation) {
+    assertScope(sessionId);
+    return storage.write(scope, async transaction => {
+      await currentMetadata(transaction);
+      return operation(transaction);
+    });
+  }
+
+  return Object.freeze({
+    readAgentRun,
+    mutateSession,
+    async getSession(sessionId) {
+      const run = await readAgentRun(sessionId, runId);
+      return { sessionId, agentRuns: run ? [run] : [] };
+    },
+    async writeAgentRunEvent(sessionId, requestedRunId, input = {}) {
+      assertScope(sessionId, requestedRunId);
+      return mutateSession(sessionId, async transaction => {
+        const previous = await readAgentRun(sessionId, runId) || { events: [], id: runId };
+        const record = conversationAgentRunEvent(previous, runId, input, { now: clock });
+        const metadata = await currentMetadata(transaction);
+        metadata.runtime.binding.codexAppServerRun = record;
+        await transaction.writeMetadata(metadata);
+        return record;
+      });
+    }
+  });
+}
+
+/** The native owner uses the existing transcript and transient streams through
+ * the same fenced transaction as its original run. Its private delivery read is
+ * a projection of the one authored request, never another stored journal.
+ */
+export function createCodexConversationStore({ storage, scope, segmentId, isCurrent, transcript, streams } = {}) {
+  const runStore = createCodexConversationRunStore({ storage, scope, segmentId, isCurrent });
+  const assertCurrent = sessionId => {
+    if (sessionId !== scope || !isCurrent()) throw new Error("A retired provider cannot change this conversation.");
+  };
+  const reader = name => (sessionId, ...args) => {
+    assertCurrent(sessionId);
+    return transcript[name](sessionId, ...args);
+  };
+  async function nativeOrigin(transaction, identity) {
+    if (!identity?.threadId || !identity.turnId) return undefined;
+    const { runtime } = await transaction.readMetadata();
+    const run = runtime.binding?.codexAppServerRun;
+    if (runtime.segmentId !== segmentId || runtime.binding.threadId !== identity.threadId ||
+        run?.providerThreadId !== identity.threadId || run.providerTurnId !== identity.turnId || !run.outerTurnId) return undefined;
+    for (const turnId of (await transaction.listTurnIds()).reverse()) {
+      const turn = await transaction.readTurn(turnId);
+      if (turn?.metadata?.runtime?.segmentId !== segmentId) continue;
+      if (turn.user?.messageId === run.outerTurnId) return "user";
+      if (turn.system?.messageId === run.outerTurnId && turn.system.origin === "application") return "application";
+    }
+    const request = runtime.request;
+    if (request?.messageId === run.outerTurnId && ["user", "application"].includes(request.origin)) return request.origin;
+    return undefined;
+  }
+  const writer = name => (sessionId, input) => runStore.mutateSession(sessionId, async transaction => {
+    const written = await transcript[name](sessionId, input);
+    if (!written || written.metadata?.runtime?.segmentId) return written;
+    const origin = await nativeOrigin(transaction, input.nativeIdentity);
+    await transaction.updateTurnMetadata(written.turnId, { runtime: {
+      status: "complete", engine: "codex", segmentId, ...(origin ? { origin } : {}),
+      ...(input.nativeIdentity?.turnId ? { nativeTurnId: input.nativeIdentity.turnId } : {})
+    } });
+    return transaction.readTurn(written.turnId);
+  });
+  return Object.freeze({
+    ...runStore,
+    readConversationLog: reader("readConversationLog"),
+    conversationMessageIdExists: reader("conversationMessageIdExists"),
+    writeConversationAssistantMessage: writer("writeConversationAssistantMessage"),
+    writeConversationCommentaryMessage: writer("writeConversationCommentaryMessage"),
+    writeConversationThinkingMessage: writer("writeConversationThinkingMessage"),
+    upsertConversationAssistantMessage: writer("upsertConversationAssistantMessage"),
+    async writeConversationUserMessage(sessionId, input = {}) {
+      return runStore.mutateSession(sessionId, async transaction => {
+        if (input.messageId && await transaction.hasMessage(input.messageId)) return null;
+        const metadata = await transaction.readMetadata();
+        const request = input.authoredRequest?.messageId === input.messageId ? input.authoredRequest
+          : metadata.runtime.request?.messageId === input.messageId ? metadata.runtime.request : null;
+        if (!request) {
+          const written = await transcript.writeConversationUserMessage(sessionId, input);
+          if (!written) return null;
+          await transaction.updateTurnMetadata(written.turnId, { runtime: {
+            status: "running", engine: "codex", segmentId, origin: "user",
+            ...(input.nativeIdentity?.turnId ? { nativeTurnId: input.nativeIdentity.turnId } : {})
+          } });
+          return transaction.readTurn(written.turnId);
+        }
+        const turnId = await transaction.nextTurnId();
+        await transaction.appendMessage(turnId, {
+          role: request.origin === "application" ? "system" : "user",
+          messageId: request.messageId, text: request.text, origin: request.origin || "user",
+          attachments: request.attachments || input.attachments || [], at: request.at || new Date().toISOString(),
+          ...(request.data !== undefined ? { data: request.data } : {}), ...(request.goal ? { goal: request.goal } : {}),
+          turnMetadata: { ...input.turnMetadata, runtime: { ...input.turnMetadata?.runtime,
+            status: "running", engine: "codex", segmentId, origin: request.origin || "user",
+            ...(input.nativeIdentity?.turnId ? { nativeTurnId: input.nativeIdentity.turnId } : {}),
+            ...(request.goal ? { goalMessageId: request.messageId } : {}) } }
+        });
+        return transaction.readTurn(turnId);
+      });
+    },
+    readMetadataValue(sessionId, key) {
+      assertCurrent(sessionId);
+      if (key !== "assistant_delivery") throw new Error("The native conversation requested unknown delivery metadata.");
+      return storage.read(sessionId, async transaction => {
+        const { runtime } = await transaction.readMetadata();
+        if (!isCurrent() || runtime.segmentId !== segmentId || runtime.engine !== "codex") {
+          throw new Error("A retired native conversation cannot read current delivery metadata.");
+        }
+        const request = runtime.request;
+        return JSON.stringify({ engines: { codex: { pending: request && { ...request,
+          displayMessage: request.displayMessage ?? request.text,
+          displayAttachments: request.displayAttachments ?? request.attachments } } } });
+      });
+    },
+    updateConversationStream(sessionId, input) {
+      return runStore.mutateSession(sessionId, async transaction => streams.update(sessionId, {
+        ...input, origin: await nativeOrigin(transaction, input.nativeIdentity)
+      }));
+    },
+    completeConversationStreamMessage(sessionId, messageId) { assertCurrent(sessionId); return streams.complete(sessionId, messageId); },
+    clearConversationStream(sessionId) { assertCurrent(sessionId); return streams.clear(sessionId); }
+  });
+}