@opengeni/react 0.28.2 → 0.32.1

package/src/hooks/use-composer.ts

@@ -19,7 +19,7 @@ export type UseComposerOptions = EmbeddedSessionClientOverride &
     /** Called with the exact accepted wire input after a successful send. */
     onSent?: ((text: string, input: SendMessageInput) => void) | undefined;
     /**
-     * Extra message fields (resources, tools, model, reasoningEffort) merged
+     * Extra message fields (resources, tools, model, reasoningEffort, latencyMode) merged
      * into every send. A function is evaluated at send time so it can read the
      * surrounding UI state (attachment pickers, model selectors, ...).
      */
@@ -448,12 +448,21 @@ export function useComposer(
             replaceLocal ||
             (!localWasDirtyAtStart && localAtStart === localEditRevision.current)
           ) {
+            // Model/effort ride in sendExtras (outside localEditRevision). If
+            // the picker changed during this fetch, skip onDraftApplied so a
+            // stale server model/effort cannot undo the operator's pick.
+            const extrasNow = resolveSendExtras(sendExtrasRef.current);
+            const pickerChangedDuringFetch =
+              extrasNow.model !== extrasAtStart.model ||
+              extrasNow.reasoningEffort !== extrasAtStart.reasoningEffort;
             valueRef.current = fetched.text;
             restoredResourcesRef.current = fetched.resources;
             lastSavedSignature.current = draftSignature(draftPayload(fetched));
             setValue(fetched.text);
             setRestoredResources(fetched.resources);
-            onDraftAppliedRef.current?.(fetched);
+            if (replaceLocal || !pickerChangedDuringFetch) {
+              onDraftAppliedRef.current?.(fetched);
+            }
           }
         }
       } catch (cause) {
@@ -773,14 +782,8 @@ export function useComposer(
         // The wire contract requires non-empty text (z.string().min(1)) and the
         // worker rejects whitespace-only text; a file-only message therefore
         // carries a minimal default so the attachments still get delivered.
-        const acknowledgedDraft = draftRef.current;
-        const sendExtras =
-          acknowledgedDraft?.toolsProvided === true &&
-          !Object.prototype.hasOwnProperty.call(extras, "tools")
-            ? { ...extras, tools: acknowledgedDraft.tools }
-            : extras;
         pendingClientEventId.current ??= generateClientEventId();
-        const input = composeSendInput(sendText, pendingClientEventId.current, sendExtras, {
+        const input = composeSendInput(sendText, pendingClientEventId.current, extras, {
           ...(options.effectiveControl?.controlEtag
             ? { controlEtag: options.effectiveControl.controlEtag }
             : {}),
@@ -1033,13 +1036,10 @@ export function useComposer(
   const hasDraftContent = useCallback((): boolean => {
     const current = draftRef.current;
     const extras = resolveSendExtras(sendExtrasRef.current);
-    const toolsProvidedByHost = Object.prototype.hasOwnProperty.call(extras, "tools");
-    const tools = toolsProvidedByHost ? (extras.tools ?? []) : (current?.tools ?? []);
     return (
       valueRef.current.length > 0 ||
       restoredResourcesRef.current.length > 0 ||
       (extras.resources?.length ?? 0) > 0 ||
-      tools.length > 0 ||
       (current?.sourceTurnId !== null && current?.sourceTurnId !== undefined)
     );
   }, []);
@@ -1201,10 +1201,9 @@ function draftPayload(draft: ComposerDraft): SaveComposerDraftRequest {
     expectedRevision: draft.revision,
     text: draft.text,
     resources: draft.resources,
-    tools: draft.tools,
-    toolsProvided: draft.toolsProvided,
     model: draft.model,
     reasoningEffort: draft.reasoningEffort,
+    latencyMode: draft.latencyMode ?? "standard",
   };
 }
 
@@ -1214,15 +1213,13 @@ function composerDraftPayload(
   restoredResources: ResourceRef[],
   extras: ComposerSendExtras,
 ): SaveComposerDraftRequest {
-  const toolsProvidedByHost = Object.prototype.hasOwnProperty.call(extras, "tools");
   return {
     expectedRevision: base.revision,
     text,
     resources: mergeResources(restoredResources, extras.resources ?? []),
-    tools: toolsProvidedByHost ? (extras.tools ?? []) : base.tools,
-    toolsProvided: toolsProvidedByHost ? true : base.toolsProvided,
     model: extras.model ?? base.model,
     reasoningEffort: extras.reasoningEffort ?? base.reasoningEffort,
+    latencyMode: extras.latencyMode ?? base.latencyMode ?? "standard",
   };
 }
 
@@ -1234,7 +1231,16 @@ function draftSignature(payload: SaveComposerDraftRequest): string {
 function mergeResources(base: ResourceRef[], additions: ResourceRef[]): ResourceRef[] {
   const seen = new Set<string>();
   return [...base, ...additions].filter((resource) => {
-    const key = JSON.stringify(resource);
+    // Reconnect reconciliation can restore the canonical server form while
+    // the still-mounted upload card supplies the same ready file without its
+    // default mount. Treat those two wire shapes as one selected attachment;
+    // preserving the first representation keeps custom mounts and ordering
+    // intact while preventing the draft and command paths from seeing
+    // different duplicate counts after server normalization.
+    const key =
+      resource.kind === "file"
+        ? `file:${resource.fileId}\u0000${resource.mountPath ?? `files/${resource.fileId}`}`
+        : JSON.stringify(resource);
     if (seen.has(key)) return false;
     seen.add(key);
     return true;

package/src/hooks/use-last-started-turn-policy.ts

@@ -0,0 +1,95 @@
+import type { LatencyMode, ReasoningEffort, SessionEvent, SessionTurn } from "@opengeni/sdk";
+import { useCallback, useEffect } from "react";
+import { useOpenGeni, type ClientOverride } from "../session-context";
+import { usePolledValue, useSessionEventTrigger, type SessionEventFeedOptions } from "./internal";
+
+/** Refresh when a turn actually admits — not on composer picker / queue-only changes. */
+export function isLastStartedTurnPolicyEvent(event: Pick<SessionEvent, "type">): boolean {
+  return event.type === "turn.started";
+}
+
+export type LastStartedTurnPolicy = {
+  model: string;
+  reasoningEffort: ReasoningEffort;
+  latencyMode: LatencyMode;
+  turnId: string;
+};
+
+export type UseLastStartedTurnPolicyOptions = ClientOverride &
+  SessionEventFeedOptions & {
+    pollIntervalMs?: number | undefined;
+  };
+
+export type UseLastStartedTurnPolicyResult = {
+  /** Null until some turn has durably emitted `turn.started`. */
+  policy: LastStartedTurnPolicy | null;
+  loading: boolean;
+  error: Error | null;
+  refresh: () => Promise<void>;
+};
+
+function policyFromTurn(turn: SessionTurn | null | undefined): LastStartedTurnPolicy | null {
+  if (!turn) return null;
+  return {
+    model: turn.model,
+    reasoningEffort: turn.reasoningEffort,
+    latencyMode: turn.latencyMode ?? "standard",
+    turnId: turn.id,
+  };
+}
+
+/**
+ * Model·effort·latency of the newest admitted turn (`turn.started`). This is
+ * historical runtime truth for the session header — not the composer next-turn
+ * picker and not the frozen session creation defaults.
+ */
+export function useLastStartedTurnPolicy(
+  sessionId: string | null | undefined,
+  options: UseLastStartedTurnPolicyOptions = {},
+): UseLastStartedTurnPolicyResult {
+  const { client, workspaceId, workspaceControlEvent, registerSessionReconciler } =
+    useOpenGeni(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+
+  const load = useCallback(async (): Promise<LastStartedTurnPolicy | null> => {
+    if (!sessionId) return null;
+    const turns = await client.listTurns(workspaceId, sessionId, { latestStarted: true });
+    return policyFromTurn(turns[0]);
+  }, [client, workspaceId, sessionId]);
+
+  const { data, loading, error, refresh } = usePolledValue(load, {
+    pollIntervalMs: options.pollIntervalMs,
+    enabled,
+  });
+
+  useEffect(() => {
+    if (enabled && workspaceControlEvent) void refresh();
+  }, [enabled, refresh, workspaceControlEvent]);
+
+  useEffect(() => {
+    if (!sessionId || !enabled) return;
+    return registerSessionReconciler(sessionId, "last-started-turn-policy", refresh);
+  }, [enabled, refresh, registerSessionReconciler, sessionId]);
+
+  // Shared-feed only: the session header lives outside the route event log and
+  // must not open a second SSE. Without `events`, rely on the initial fetch +
+  // optional poll / workspace-control / reconciler.
+  useSessionEventTrigger(
+    client,
+    workspaceId,
+    sessionId,
+    isLastStartedTurnPolicyEvent,
+    () => void refresh(),
+    {
+      events: options.events,
+      enabled: enabled && options.events !== undefined,
+    },
+  );
+
+  return {
+    policy: enabled ? data : null,
+    loading,
+    error,
+    refresh,
+  };
+}