@tutti-os/agent-activity-core 0.0.3

package/dist/index.js

@@ -0,0 +1,1083 @@
+// src/merge.ts
+function mergeAgentActivityMessages(currentMessages, incomingMessages) {
+  if (incomingMessages.length === 0) {
+    return [...currentMessages];
+  }
+  const byMessageId = /* @__PURE__ */ new Map();
+  for (const message of currentMessages) {
+    byMessageId.set(message.messageId, cloneAgentActivityMessage(message));
+  }
+  for (const incoming of incomingMessages) {
+    const existing = byMessageId.get(incoming.messageId);
+    if (!existing || shouldReplaceAgentActivityMessage(existing, incoming)) {
+      byMessageId.set(
+        incoming.messageId,
+        existing ? mergeAgentActivityMessage(existing, incoming) : cloneAgentActivityMessage(incoming)
+      );
+    }
+  }
+  return [...byMessageId.values()].sort(compareAgentActivityMessages);
+}
+function compareAgentActivityMessages(left, right) {
+  return left.version - right.version || (left.id ?? 0) - (right.id ?? 0) || left.messageId.localeCompare(right.messageId);
+}
+function latestAgentActivityMessageVersion(messages) {
+  return messages.reduce(
+    (latestVersion, message) => Math.max(latestVersion, message.version),
+    0
+  );
+}
+function areAgentActivityMessageArraysEqual(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  for (let index = 0; index < left.length; index += 1) {
+    if (!areAgentActivityMessagesEqual(left[index], right[index])) {
+      return false;
+    }
+  }
+  return true;
+}
+function areAgentActivityMessagesEqual(left, right) {
+  return left.workspaceId === right.workspaceId && left.agentSessionId === right.agentSessionId && left.messageId === right.messageId && Object.is(left.id, right.id) && left.version === right.version && Object.is(left.turnId, right.turnId) && left.role === right.role && left.kind === right.kind && Object.is(left.status, right.status) && Object.is(left.occurredAtUnixMs, right.occurredAtUnixMs) && Object.is(left.startedAtUnixMs, right.startedAtUnixMs) && Object.is(left.completedAtUnixMs, right.completedAtUnixMs) && areJsonLikeValuesEqual(left.payload, right.payload);
+}
+function cloneAgentActivityMessage(message) {
+  return {
+    ...message,
+    payload: { ...message.payload }
+  };
+}
+function mergeAgentActivityMessage(existing, incoming) {
+  return {
+    ...existing,
+    ...incoming,
+    payload: {
+      ...existing.payload,
+      ...incoming.payload
+    }
+  };
+}
+function shouldReplaceAgentActivityMessage(existing, incoming) {
+  if (incoming.version !== existing.version) {
+    return incoming.version > existing.version;
+  }
+  return (incoming.id ?? 0) >= (existing.id ?? 0);
+}
+function areJsonLikeValuesEqual(left, right) {
+  if (Object.is(left, right)) {
+    return true;
+  }
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right)) {
+      return false;
+    }
+    if (left.length !== right.length) {
+      return false;
+    }
+    for (let index = 0; index < left.length; index += 1) {
+      if (!areJsonLikeValuesEqual(left[index], right[index])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  const leftRecord = recordValue(left);
+  const rightRecord = recordValue(right);
+  if (!leftRecord || !rightRecord) {
+    return false;
+  }
+  const keys = /* @__PURE__ */ new Set([
+    ...Object.keys(leftRecord),
+    ...Object.keys(rightRecord)
+  ]);
+  for (const key of keys) {
+    if (!areJsonLikeValuesEqual(leftRecord[key], rightRecord[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function recordValue(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+
+// src/controller.ts
+function createAgentActivityController({
+  adapter,
+  autoRetainSessionEvents = true,
+  workspaceId
+}) {
+  const listeners = /* @__PURE__ */ new Set();
+  const activeMessageSyncs = /* @__PURE__ */ new Map();
+  const activeComposerOptionsLoads = /* @__PURE__ */ new Map();
+  const composerOptionsLoadVersions = /* @__PURE__ */ new Map();
+  const autoRetainedStreamReleases = /* @__PURE__ */ new Map();
+  const retainedStreams = /* @__PURE__ */ new Map();
+  let snapshot = createEmptyAgentActivitySnapshot(workspaceId);
+  const emit = () => {
+    for (const listener of listeners) {
+      listener(snapshot);
+    }
+  };
+  const updateSnapshot = (updater) => {
+    const nextSnapshot = updater(snapshot);
+    if (nextSnapshot === snapshot) {
+      return snapshot;
+    }
+    snapshot = cloneAgentActivitySnapshot(nextSnapshot);
+    emit();
+    return snapshot;
+  };
+  return {
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      listeners.add(listener);
+      listener(snapshot);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    async load(signal) {
+      const response = await adapter.listSessions({ workspaceId, signal });
+      const nextSessions = response.sessions;
+      const nextPresences = response.presences ?? [];
+      const nextSnapshot = updateSnapshot((current) => {
+        if (areShallowObjectArraysEqual(current.sessions, nextSessions) && areShallowObjectArraysEqual(current.presences, nextPresences)) {
+          return current;
+        }
+        return {
+          ...current,
+          presences: nextPresences,
+          sessions: nextSessions
+        };
+      });
+      if (autoRetainSessionEvents) {
+        reconcileAutoRetainedSessionStreams(nextSnapshot.sessions, signal);
+      }
+      return nextSnapshot;
+    },
+    async loadComposerOptions(input) {
+      const provider = input.provider.trim();
+      if (!provider) {
+        throw new Error("Agent composer options provider is required.");
+      }
+      if (!input.force) {
+        const cached = snapshot.composerOptionsByProvider?.[provider];
+        if (cached) {
+          return cloneAgentActivityComposerOptions(cached);
+        }
+      }
+      const existingLoad = activeComposerOptionsLoads.get(provider);
+      if (existingLoad && !input.force) {
+        return existingLoad.then(cloneAgentActivityComposerOptions);
+      }
+      const loadVersion = (composerOptionsLoadVersions.get(provider) ?? 0) + 1;
+      composerOptionsLoadVersions.set(provider, loadVersion);
+      const load = adapter.loadComposerOptions({
+        workspaceId,
+        provider,
+        cwd: input.cwd,
+        settings: input.settings,
+        signal: input.signal
+      }).then((options) => {
+        const normalizedOptions = cloneAgentActivityComposerOptions({
+          ...options,
+          provider,
+          loadedAtUnixMs: options.loadedAtUnixMs || Date.now()
+        });
+        if (composerOptionsLoadVersions.get(provider) !== loadVersion) {
+          return cloneAgentActivityComposerOptions(normalizedOptions);
+        }
+        updateSnapshot((current) => {
+          const currentOptions = current.composerOptionsByProvider?.[provider];
+          if (currentOptions && areComposerOptionsEqual(currentOptions, normalizedOptions)) {
+            return current;
+          }
+          return {
+            ...current,
+            composerOptionsByProvider: {
+              ...current.composerOptionsByProvider,
+              [provider]: normalizedOptions
+            }
+          };
+        });
+        return cloneAgentActivityComposerOptions(normalizedOptions);
+      }).finally(() => {
+        if (activeComposerOptionsLoads.get(provider) === load) {
+          activeComposerOptionsLoads.delete(provider);
+        }
+      });
+      activeComposerOptionsLoads.set(provider, load);
+      return load.then(cloneAgentActivityComposerOptions);
+    },
+    async listSessionMessages({
+      agentSessionId,
+      afterVersion,
+      beforeVersion,
+      limit,
+      order,
+      signal
+    }) {
+      const response = await adapter.listSessionMessages({
+        workspaceId,
+        agentSessionId,
+        afterVersion,
+        beforeVersion,
+        limit,
+        order,
+        signal
+      });
+      updateSnapshot(
+        (current) => mergeSnapshotMessages(current, agentSessionId, response.messages)
+      );
+      return {
+        ...response,
+        messages: response.messages.map((message) => ({
+          ...message,
+          payload: { ...message.payload }
+        }))
+      };
+    },
+    retainSessionEvents: retainSessionEventsImpl,
+    removeSession(agentSessionId) {
+      updateSnapshot(
+        (current) => removeSnapshotSession(current, agentSessionId)
+      );
+    },
+    upsertSession(session) {
+      if (session.workspaceId && session.workspaceId !== snapshot.workspaceId) {
+        return;
+      }
+      updateSnapshot((current) => upsertSnapshotSession(current, session));
+    },
+    applyActivityUpdatedEvent(event) {
+      const result = applyActivityUpdatedEvent(snapshot, event);
+      if (result.snapshot !== snapshot) {
+        snapshot = result.snapshot;
+        emit();
+      }
+      return {
+        applied: result.applied,
+        messages: result.messages.map(cloneAgentActivityMessage),
+        session: result.session ? { ...result.session } : null,
+        statePatch: result.statePatch ? cloneAgentActivityStatePatch(result.statePatch) : null
+      };
+    },
+    applySessionEvent(event) {
+      updateSnapshot((current) => applySessionEvent(current, event));
+    }
+  };
+  function retainSessionEventsImpl({
+    agentSessionId,
+    afterVersion,
+    onRetainFailed,
+    onError
+  }) {
+    const normalizedAgentSessionId = agentSessionId.trim();
+    if (!normalizedAgentSessionId) {
+      return () => {
+      };
+    }
+    const existing = retainedStreams.get(normalizedAgentSessionId);
+    if (existing) {
+      existing.refCount += 1;
+      return createRetainedStreamRelease(normalizedAgentSessionId);
+    }
+    const abortController = new AbortController();
+    const stream = {
+      abortController,
+      refCount: 1,
+      unsubscribe: null
+    };
+    retainedStreams.set(normalizedAgentSessionId, stream);
+    const cachedMessages = snapshot.sessionMessagesById[normalizedAgentSessionId] ?? [];
+    const streamAfterVersion = afterVersion ?? latestAgentActivityMessageVersion(cachedMessages);
+    void adapter.subscribeSessionEvents({
+      workspaceId,
+      agentSessionId: normalizedAgentSessionId,
+      afterVersion: streamAfterVersion,
+      signal: abortController.signal,
+      onEvent(event) {
+        if (!abortController.signal.aborted) {
+          updateSnapshot((current) => applySessionEvent(current, event));
+        }
+      },
+      onError
+    }).then((unsubscribe) => {
+      const retained = retainedStreams.get(normalizedAgentSessionId);
+      if (!retained || retained.abortController.signal.aborted) {
+        unsubscribe();
+        return;
+      }
+      retained.unsubscribe = unsubscribe;
+    }).catch((error) => {
+      if (!abortController.signal.aborted) {
+        onError?.(error);
+      }
+      if (retainedStreams.get(normalizedAgentSessionId) === stream) {
+        retainedStreams.delete(normalizedAgentSessionId);
+      }
+      onRetainFailed?.();
+      abortController.abort();
+      stream.unsubscribe?.();
+    });
+    return createRetainedStreamRelease(normalizedAgentSessionId);
+  }
+  function reconcileAutoRetainedSessionStreams(sessions, signal) {
+    const activeSessionIds = new Set(
+      sessions.filter(shouldAutoRetainSessionEvents).map((session) => session.agentSessionId.trim()).filter(Boolean)
+    );
+    for (const [agentSessionId, release] of autoRetainedStreamReleases) {
+      if (!activeSessionIds.has(agentSessionId)) {
+        release();
+        autoRetainedStreamReleases.delete(agentSessionId);
+      }
+    }
+    for (const agentSessionId of activeSessionIds) {
+      if (!autoRetainedStreamReleases.has(agentSessionId)) {
+        autoRetainedStreamReleases.set(
+          agentSessionId,
+          retainSessionEventsImpl({
+            agentSessionId,
+            onRetainFailed() {
+              autoRetainedStreamReleases.delete(agentSessionId);
+            }
+          })
+        );
+      }
+      syncSessionMessages(agentSessionId, signal);
+    }
+  }
+  function syncSessionMessages(agentSessionId, signal) {
+    if (activeMessageSyncs.has(agentSessionId)) {
+      return;
+    }
+    const cachedMessages = snapshot.sessionMessagesById[agentSessionId] ?? [];
+    const afterVersion = latestAgentActivityMessageVersion(cachedMessages);
+    const sync = adapter.listSessionMessages({
+      workspaceId,
+      agentSessionId,
+      afterVersion,
+      signal
+    }).then((response) => {
+      if (signal?.aborted) {
+        return;
+      }
+      updateSnapshot(
+        (current) => mergeSnapshotMessages(current, agentSessionId, response.messages)
+      );
+    }).catch(() => {
+    }).finally(() => {
+      if (activeMessageSyncs.get(agentSessionId) === sync) {
+        activeMessageSyncs.delete(agentSessionId);
+      }
+    });
+    activeMessageSyncs.set(agentSessionId, sync);
+  }
+  function createRetainedStreamRelease(agentSessionId) {
+    let released = false;
+    return () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      releaseRetainedStream(agentSessionId);
+    };
+  }
+  function releaseRetainedStream(agentSessionId) {
+    const stream = retainedStreams.get(agentSessionId);
+    if (!stream) {
+      return;
+    }
+    stream.refCount -= 1;
+    if (stream.refCount > 0) {
+      return;
+    }
+    retainedStreams.delete(agentSessionId);
+    stream.abortController.abort();
+    stream.unsubscribe?.();
+  }
+}
+function createEmptyAgentActivitySnapshot(workspaceId) {
+  return {
+    workspaceId,
+    sessions: [],
+    presences: [],
+    sessionMessagesById: {},
+    composerOptionsByProvider: {}
+  };
+}
+function cloneAgentActivitySnapshot(snapshot) {
+  return {
+    workspaceId: snapshot.workspaceId,
+    sessions: snapshot.sessions.map((session) => ({ ...session })),
+    presences: snapshot.presences.map((presence) => ({ ...presence })),
+    composerOptionsByProvider: Object.fromEntries(
+      Object.entries(snapshot.composerOptionsByProvider ?? {}).map(
+        ([provider, options]) => [
+          provider,
+          cloneAgentActivityComposerOptions(options)
+        ]
+      )
+    ),
+    sessionMessagesById: Object.fromEntries(
+      Object.entries(snapshot.sessionMessagesById).map(
+        ([agentSessionId, messages]) => [
+          agentSessionId,
+          messages.map((message) => ({
+            ...message,
+            payload: { ...message.payload }
+          }))
+        ]
+      )
+    )
+  };
+}
+function cloneAgentActivityComposerOptions(options) {
+  return {
+    provider: options.provider,
+    models: options.models.map((option) => ({ ...option })),
+    reasoningEfforts: options.reasoningEfforts.map((option) => ({
+      ...option
+    })),
+    permissionConfig: options.permissionConfig ? {
+      configurable: options.permissionConfig.configurable,
+      defaultValue: options.permissionConfig.defaultValue ?? null,
+      modes: options.permissionConfig.modes.map((mode) => ({ ...mode }))
+    } : options.permissionConfig ?? null,
+    runtimeContext: cloneJSONRecord(options.runtimeContext),
+    skills: options.skills.map((skill) => ({ ...skill })),
+    loadedAtUnixMs: options.loadedAtUnixMs
+  };
+}
+function areComposerOptionsEqual(left, right) {
+  const { loadedAtUnixMs: _leftLoadedAtUnixMs, ...leftComparable } = left;
+  const { loadedAtUnixMs: _rightLoadedAtUnixMs, ...rightComparable } = right;
+  return JSON.stringify(leftComparable) === JSON.stringify(rightComparable);
+}
+function cloneJSONRecord(value) {
+  if (value === void 0) {
+    return value;
+  }
+  return cloneJSONValue(value);
+}
+function cloneJSONValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(cloneJSONValue);
+  }
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [
+        key,
+        cloneJSONValue(entry)
+      ])
+    );
+  }
+  return value;
+}
+function areShallowObjectArraysEqual(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  for (let index = 0; index < left.length; index += 1) {
+    if (!areShallowObjectsEqual(left[index], right[index])) {
+      return false;
+    }
+  }
+  return true;
+}
+function areShallowObjectsEqual(left, right) {
+  const leftRecord = left;
+  const rightRecord = right;
+  const keys = /* @__PURE__ */ new Set([
+    ...Object.keys(leftRecord),
+    ...Object.keys(rightRecord)
+  ]);
+  for (const key of keys) {
+    if (!Object.is(leftRecord[key], rightRecord[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function applyActivityUpdatedEvent(snapshot, event) {
+  if (event.workspaceId && event.workspaceId !== snapshot.workspaceId) {
+    return emptyActivityUpdatedApplyResult(snapshot);
+  }
+  const workspaceId = event.workspaceId || snapshot.workspaceId;
+  const agentSessionId = event.agentSessionId.trim();
+  if (!agentSessionId) {
+    return emptyActivityUpdatedApplyResult(snapshot);
+  }
+  if (event.eventType === "message_update") {
+    return applyActivityUpdatedMessages(snapshot, {
+      agentSessionId,
+      data: event.data,
+      workspaceId
+    });
+  }
+  if (event.eventType === "state_patch") {
+    return applyActivityUpdatedStatePatch(snapshot, {
+      agentSessionId,
+      data: event.data,
+      workspaceId
+    });
+  }
+  return emptyActivityUpdatedApplyResult(snapshot);
+}
+function applyActivityUpdatedMessages(snapshot, input) {
+  const inlineMessages = inlineMessagesFromActivityUpdateData(input.data);
+  if (inlineMessages.length === 0) {
+    return emptyActivityUpdatedApplyResult(snapshot);
+  }
+  const sessionMessages = inlineMessages.filter(
+    (message) => inlineMessageBelongsToSession(message, input.agentSessionId)
+  );
+  if (sessionMessages.length === 0) {
+    return emptyActivityUpdatedApplyResult(snapshot);
+  }
+  const messages = sessionMessages.map(
+    (message) => agentActivityMessageFromInlineMessage({
+      agentSessionId: input.agentSessionId,
+      message,
+      workspaceId: input.workspaceId
+    })
+  );
+  const nextSnapshot = mergeSnapshotMessages(
+    snapshot,
+    input.agentSessionId,
+    messages
+  );
+  if (nextSnapshot === snapshot) {
+    return {
+      applied: true,
+      messages: [],
+      session: null,
+      snapshot,
+      statePatch: null
+    };
+  }
+  return {
+    applied: true,
+    messages,
+    session: null,
+    snapshot: nextSnapshot,
+    statePatch: null
+  };
+}
+function applyActivityUpdatedStatePatch(snapshot, input) {
+  const statePatch = inlineStatePatchFromActivityUpdateData(input.data);
+  if (!statePatch || statePatch.agentSessionId !== input.agentSessionId) {
+    return emptyActivityUpdatedApplyResult(snapshot);
+  }
+  const existingSession = snapshot.sessions.find(
+    (session2) => session2.agentSessionId === input.agentSessionId
+  ) ?? null;
+  if (!existingSession || isStaleStatePatch(existingSession, statePatch)) {
+    return emptyActivityUpdatedApplyResult(snapshot);
+  }
+  const session = agentActivitySessionFromInlineStatePatch({
+    existingSession,
+    patch: statePatch,
+    workspaceId: input.workspaceId
+  });
+  return {
+    applied: true,
+    messages: [],
+    session,
+    snapshot: upsertSnapshotSession(snapshot, session),
+    statePatch
+  };
+}
+function emptyActivityUpdatedApplyResult(snapshot) {
+  return {
+    applied: false,
+    messages: [],
+    session: null,
+    snapshot,
+    statePatch: null
+  };
+}
+function applySessionEvent(snapshot, event) {
+  if (event.workspaceId && event.workspaceId !== snapshot.workspaceId) {
+    return snapshot;
+  }
+  const data = recordValue2(event.data) ?? {};
+  if (event.eventType === "message_update") {
+    const message = messageFromEvent(event, data);
+    return message ? mergeSnapshotMessages(snapshot, message.agentSessionId, [message]) : snapshot;
+  }
+  if (event.eventType === "session_update") {
+    const session = sessionFromEvent(snapshot.workspaceId, event, data);
+    return session ? upsertSnapshotSession(snapshot, session) : snapshot;
+  }
+  return snapshot;
+}
+function mergeSnapshotMessages(snapshot, agentSessionId, messages) {
+  const normalizedAgentSessionId = agentSessionId.trim();
+  if (!normalizedAgentSessionId || messages.length === 0) {
+    return snapshot;
+  }
+  const currentMessages = snapshot.sessionMessagesById[normalizedAgentSessionId] ?? [];
+  const mergedMessages = mergeAgentActivityMessages(currentMessages, messages);
+  if (areAgentActivityMessageArraysEqual(currentMessages, mergedMessages)) {
+    return snapshot;
+  }
+  return {
+    ...snapshot,
+    sessionMessagesById: {
+      ...snapshot.sessionMessagesById,
+      [normalizedAgentSessionId]: mergedMessages
+    }
+  };
+}
+function upsertSnapshotSession(snapshot, session) {
+  const index = snapshot.sessions.findIndex(
+    (item) => item.agentSessionId === session.agentSessionId
+  );
+  if (index < 0) {
+    return {
+      ...snapshot,
+      sessions: [...snapshot.sessions, session]
+    };
+  }
+  const sessions = [...snapshot.sessions];
+  sessions[index] = session;
+  return {
+    ...snapshot,
+    sessions
+  };
+}
+function removeSnapshotSession(snapshot, agentSessionId) {
+  const normalizedAgentSessionId = agentSessionId.trim();
+  if (!normalizedAgentSessionId) {
+    return snapshot;
+  }
+  const sessions = snapshot.sessions.filter(
+    (session) => session.agentSessionId !== normalizedAgentSessionId
+  );
+  if (sessions.length === snapshot.sessions.length && !snapshot.sessionMessagesById[normalizedAgentSessionId]) {
+    return snapshot;
+  }
+  const sessionMessagesById = { ...snapshot.sessionMessagesById };
+  delete sessionMessagesById[normalizedAgentSessionId];
+  return {
+    ...snapshot,
+    sessions,
+    sessionMessagesById
+  };
+}
+function shouldAutoRetainSessionEvents(session) {
+  if (!session.agentSessionId.trim()) {
+    return false;
+  }
+  switch (session.status.trim()) {
+    case "canceled":
+    case "completed":
+    case "failed":
+      return false;
+    default:
+      return true;
+  }
+}
+function messageFromEvent(event, data) {
+  const source = recordValue2(data.message) ?? data;
+  const agentSessionId = stringValue(source.agentSessionId) || event.agentSessionId;
+  const messageId = stringValue(source.messageId);
+  const role = stringValue(source.role);
+  const kind = stringValue(source.kind);
+  if (!agentSessionId || !messageId || !role || !kind) {
+    return null;
+  }
+  return {
+    workspaceId: stringValue(source.workspaceId) || event.workspaceId,
+    agentSessionId,
+    messageId,
+    id: numberValue(source.id),
+    version: numberValue(source.version) ?? 0,
+    turnId: nullableStringValue(source.turnId),
+    role,
+    kind,
+    status: nullableStringValue(source.status),
+    payload: recordValue2(source.payload) ?? {},
+    occurredAtUnixMs: numberValue(source.occurredAtUnixMs),
+    startedAtUnixMs: numberValue(source.startedAtUnixMs),
+    completedAtUnixMs: numberValue(source.completedAtUnixMs)
+  };
+}
+function sessionFromEvent(workspaceId, event, data) {
+  const source = recordValue2(data.session) ?? data;
+  const agentSessionId = stringValue(source.agentSessionId) || event.agentSessionId;
+  if (!agentSessionId) {
+    return null;
+  }
+  return {
+    workspaceId: stringValue(source.workspaceId) || workspaceId,
+    agentSessionId,
+    provider: stringValue(source.provider),
+    providerSessionId: nullableStringValue(source.providerSessionId),
+    model: nullableStringValue(source.model),
+    cwd: stringValue(source.cwd),
+    title: stringValue(source.title),
+    status: stringValue(source.status) || "unknown",
+    resumable: booleanValue(source.resumable),
+    currentPhase: nullableStringValue(source.currentPhase),
+    lastError: nullableStringValue(source.lastError),
+    messageVersion: numberValue(source.messageVersion),
+    lastEventUnixMs: numberValue(source.lastEventUnixMs),
+    startedAtUnixMs: numberValue(source.startedAtUnixMs),
+    endedAtUnixMs: numberValue(source.endedAtUnixMs),
+    createdAtUnixMs: numberValue(source.createdAtUnixMs),
+    updatedAtUnixMs: numberValue(source.updatedAtUnixMs)
+  };
+}
+function inlineMessagesFromActivityUpdateData(data) {
+  const source = recordValue2(data);
+  const messages = Array.isArray(source?.messages) ? source.messages : [];
+  return messages.flatMap((message) => {
+    const record = recordValue2(message);
+    return record ? [record] : [];
+  });
+}
+function inlineMessageBelongsToSession(message, agentSessionId) {
+  const messageAgentSessionId = stringValue(message.agentSessionId);
+  return !messageAgentSessionId || messageAgentSessionId === agentSessionId;
+}
+function agentActivityMessageFromInlineMessage(input) {
+  return {
+    workspaceId: stringValue(input.message.workspaceId) || input.workspaceId,
+    agentSessionId: stringValue(input.message.agentSessionId) || input.agentSessionId,
+    messageId: stringValue(input.message.messageId),
+    id: numberValue(input.message.id),
+    version: numberValue(input.message.version) ?? 0,
+    turnId: nullableStringValue(input.message.turnId),
+    role: stringValue(input.message.role),
+    kind: stringValue(input.message.kind),
+    status: nullableStringValue(input.message.status),
+    payload: recordValue2(input.message.payload) ?? {},
+    occurredAtUnixMs: numberValue(input.message.occurredAtUnixMs),
+    startedAtUnixMs: numberValue(input.message.startedAtUnixMs),
+    completedAtUnixMs: numberValue(input.message.completedAtUnixMs)
+  };
+}
+function inlineStatePatchFromActivityUpdateData(data) {
+  const source = recordValue2(data);
+  const agentSessionId = stringValue(source?.agentSessionId);
+  if (!source || !agentSessionId) {
+    return null;
+  }
+  const turn = recordValue2(source.turn);
+  return {
+    agentSessionId,
+    currentPhase: stringValue(source.currentPhase) || void 0,
+    cwd: stringValue(source.cwd) || void 0,
+    lastError: stringValue(source.lastError) || void 0,
+    lastEventUnixMs: numberValue(source.lastEventUnixMs),
+    lifecycleStatus: stringValue(source.lifecycleStatus) || void 0,
+    model: stringValue(source.model) || void 0,
+    occurredAtUnixMs: numberValue(source.occurredAtUnixMs),
+    provider: stringValue(source.provider) || void 0,
+    providerSessionId: stringValue(source.providerSessionId) || void 0,
+    startedAtUnixMs: numberValue(source.startedAtUnixMs),
+    endedAtUnixMs: numberValue(source.endedAtUnixMs),
+    title: stringValue(source.title) || void 0,
+    turn: turn ? {
+      completedAtUnixMs: numberValue(turn.completedAtUnixMs),
+      fileChanges: turn.fileChanges,
+      outcome: stringValue(turn.outcome) || void 0,
+      phase: stringValue(turn.phase) || void 0,
+      startedAtUnixMs: numberValue(turn.startedAtUnixMs),
+      turnId: stringValue(turn.turnId)
+    } : void 0,
+    workspaceId: stringValue(source.workspaceId) || void 0
+  };
+}
+function isStaleStatePatch(session, patch) {
+  const nextTime = patch.lastEventUnixMs ?? patch.occurredAtUnixMs;
+  const currentTime = session.lastEventUnixMs ?? session.updatedAtUnixMs;
+  return typeof nextTime === "number" && typeof currentTime === "number" && nextTime < currentTime;
+}
+function agentActivitySessionFromInlineStatePatch(input) {
+  return {
+    ...input.existingSession,
+    workspaceId: input.patch.workspaceId ?? input.workspaceId,
+    agentSessionId: input.patch.agentSessionId,
+    provider: input.patch.provider ?? input.existingSession.provider,
+    providerSessionId: input.patch.providerSessionId ?? input.existingSession.providerSessionId,
+    model: input.patch.model ?? input.existingSession.model,
+    cwd: input.patch.cwd ?? input.existingSession.cwd,
+    title: input.patch.title ?? input.existingSession.title,
+    status: input.patch.lifecycleStatus ?? input.existingSession.status,
+    currentPhase: input.patch.currentPhase ?? input.patch.turn?.phase ?? input.existingSession.currentPhase,
+    lastError: input.patch.lastError ?? input.existingSession.lastError,
+    lastEventUnixMs: input.patch.lastEventUnixMs ?? input.patch.occurredAtUnixMs ?? input.existingSession.lastEventUnixMs,
+    startedAtUnixMs: input.patch.startedAtUnixMs ?? input.existingSession.startedAtUnixMs,
+    endedAtUnixMs: input.patch.endedAtUnixMs ?? input.existingSession.endedAtUnixMs,
+    updatedAtUnixMs: input.patch.occurredAtUnixMs ?? input.patch.lastEventUnixMs ?? input.existingSession.updatedAtUnixMs
+  };
+}
+function cloneAgentActivityStatePatch(statePatch) {
+  return {
+    ...statePatch,
+    turn: statePatch.turn ? { ...statePatch.turn } : void 0
+  };
+}
+function recordValue2(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+function stringValue(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function nullableStringValue(value) {
+  return typeof value === "string" ? value : value === null ? null : void 0;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function booleanValue(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+
+// src/selectors.ts
+var terminalMessageStatuses = /* @__PURE__ */ new Set([
+  "completed",
+  "canceled",
+  "failed",
+  "rejected",
+  "answered",
+  "resolved"
+]);
+function resolveAgentActivityPromptImagesSupported(input) {
+  return promptImagesSupportedFromRuntimeContext(input.sessionRuntimeContext) ?? promptImagesSupportedFromRuntimeContext(
+    input.composerOptions?.runtimeContext
+  );
+}
+function selectNeedsAttentionCount(snapshot) {
+  return selectNeedsAttentionItems(snapshot).length;
+}
+function selectSessionDisplayStatuses(snapshot) {
+  const needsAttentionSessionIds = new Set(
+    selectNeedsAttentionItems(snapshot).map((item) => item.agentSessionId)
+  );
+  return new Map(
+    snapshot.sessions.map((session) => [
+      session.agentSessionId,
+      normalizeAgentActivityDisplayStatus(session.status, {
+        currentPhase: session.currentPhase,
+        needsAttention: needsAttentionSessionIds.has(session.agentSessionId)
+      })
+    ])
+  );
+}
+function normalizeAgentActivityDisplayStatus(status, options = {}) {
+  if (options.needsAttention) {
+    return "waiting";
+  }
+  const normalizedStatus = normalizeStatus(status);
+  const normalizedCurrentPhase = normalizeStatus(options.currentPhase);
+  switch (normalizedStatus) {
+    case "completed":
+    case "done":
+    case "success":
+    case "succeeded":
+      return "completed";
+    case "canceled":
+    case "cancelled":
+      return "canceled";
+    case "error":
+    case "failed":
+      return "failed";
+    default:
+      break;
+  }
+  switch (normalizedCurrentPhase) {
+    case "completed":
+    case "done":
+    case "success":
+    case "succeeded":
+      return "completed";
+    case "canceled":
+    case "cancelled":
+      return "canceled";
+    case "error":
+    case "failed":
+      return "failed";
+    case "awaiting_approval":
+    case "waiting":
+    case "waiting_approval":
+    case "waiting_input":
+      return "waiting";
+    case "running":
+    case "streaming":
+    case "working":
+      return "working";
+    default:
+      break;
+  }
+  switch (normalizedStatus) {
+    case "running":
+    case "streaming":
+    case "working":
+      return "working";
+    case "awaiting_approval":
+    case "waiting":
+    case "waiting_approval":
+    case "waiting_input":
+      return "waiting";
+    case "idle":
+    case "ready":
+    default:
+      return "idle";
+  }
+}
+function selectNeedsAttentionItems(snapshot) {
+  const sessionsById = new Map(
+    snapshot.sessions.map((session) => [session.agentSessionId, session])
+  );
+  const items = [];
+  for (const [agentSessionId, messages] of Object.entries(
+    snapshot.sessionMessagesById
+  )) {
+    const session = sessionsById.get(agentSessionId);
+    for (const message of messages) {
+      const kind = needsAttentionKindForMessage(message);
+      if (!kind) {
+        continue;
+      }
+      items.push(
+        needsAttentionItemFromMessage(snapshot, message, kind, session)
+      );
+    }
+  }
+  return items.sort(
+    (left, right) => right.occurredAtUnixMs - left.occurredAtUnixMs || left.id.localeCompare(right.id)
+  );
+}
+function needsAttentionKindForMessage(message) {
+  if (isTerminalMessageStatus(message.status)) {
+    return null;
+  }
+  const kind = normalizeKind(message.kind);
+  const payloadType = normalizeMetadataValue(message.payload.type);
+  const action = normalizeMetadataValue(message.payload.action);
+  const requestType = normalizeMetadataValue(message.payload.requestType);
+  const callType = normalizeMetadataValue(message.payload.callType);
+  const toolName = normalizeMetadataValue(message.payload.toolName);
+  const name = normalizeMetadataValue(message.payload.name);
+  const status = normalizeStatus(message.status);
+  const payloadStatus = normalizeMetadataValue(message.payload.status);
+  if (includesAny(
+    [
+      kind,
+      payloadType,
+      requestType,
+      callType,
+      toolName,
+      name,
+      status,
+      payloadStatus
+    ].join(" "),
+    ["permission", "approval"]
+  )) {
+    return "permission";
+  }
+  if (includesAny(
+    [
+      kind,
+      payloadType,
+      action,
+      callType,
+      toolName,
+      name,
+      status,
+      payloadStatus
+    ].join(" "),
+    ["ask_user", "ask-user", "askuserquestion", "question"]
+  )) {
+    return "question";
+  }
+  if (includesAny([kind, payloadType, action, toolName, name].join(" "), [
+    "constraint"
+  ])) {
+    return "constraint";
+  }
+  if (isWaitingStatus(status, payloadStatus) && (message.role === "assistant" || message.role === "system")) {
+    return "other";
+  }
+  return null;
+}
+function needsAttentionItemFromMessage(snapshot, message, kind, session) {
+  return {
+    id: `${message.agentSessionId}:${message.messageId}`,
+    workspaceId: message.workspaceId || snapshot.workspaceId,
+    agentSessionId: message.agentSessionId,
+    provider: session?.provider ?? "",
+    title: session?.title ?? "",
+    cwd: session?.cwd ?? "",
+    kind,
+    summary: messageSummary(message),
+    occurredAtUnixMs: message.occurredAtUnixMs ?? message.startedAtUnixMs ?? message.completedAtUnixMs ?? session?.updatedAtUnixMs ?? session?.lastEventUnixMs ?? 0
+  };
+}
+function messageSummary(message) {
+  return stringValue2(message.payload.summary) || stringValue2(message.payload.title) || stringValue2(message.payload.content) || stringValue2(message.payload.text) || message.kind;
+}
+function isTerminalMessageStatus(status) {
+  return terminalMessageStatuses.has(normalizeStatus(status));
+}
+function normalizeStatus(status) {
+  return status?.trim().toLowerCase() ?? "";
+}
+function isWaitingStatus(...values) {
+  return values.some((value) => {
+    const normalized = value.trim().toLowerCase();
+    return normalized === "waiting" || normalized.startsWith("waiting_");
+  });
+}
+function normalizeKind(kind) {
+  return kind.trim().toLowerCase();
+}
+function normalizeMetadataValue(value) {
+  return stringValue2(value).toLowerCase();
+}
+function includesAny(value, needles) {
+  return needles.some((needle) => value.includes(needle));
+}
+function stringValue2(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function promptImagesSupportedFromRuntimeContext(runtimeContext) {
+  const promptCapabilities = recordValue3(runtimeContext?.promptCapabilities);
+  const value = promptCapabilities?.image;
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true") {
+      return true;
+    }
+    if (normalized === "false") {
+      return false;
+    }
+  }
+  return null;
+}
+function recordValue3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+export {
+  cloneAgentActivityMessage,
+  cloneAgentActivitySnapshot,
+  compareAgentActivityMessages,
+  createAgentActivityController,
+  createEmptyAgentActivitySnapshot,
+  latestAgentActivityMessageVersion,
+  mergeAgentActivityMessages,
+  normalizeAgentActivityDisplayStatus,
+  resolveAgentActivityPromptImagesSupported,
+  selectNeedsAttentionCount,
+  selectNeedsAttentionItems,
+  selectSessionDisplayStatuses
+};
+//# sourceMappingURL=index.js.map