@letta-ai/letta-agent-sdk 0.6.3 → 0.7.0

package/dist/client-entry.js

@@ -3073,7 +3073,7 @@ function isAppServerInfoResponseMessage(message) {
     return false;
   }
   const capabilityRecord = capabilities;
-  return candidate.type === "app_server_info_response" && typeof candidate.request_id === "string" && candidate.request_id.length > 0 && candidate.success === true && (candidate.backend === "local" || candidate.backend === "api") && typeof candidate.letta_code_version === "string" && typeof candidate.protocol_version === "number" && Number.isInteger(candidate.protocol_version) && typeof capabilityRecord.agent_management === "boolean" && typeof capabilityRecord.conversation_management === "boolean" && typeof capabilityRecord.memory_management === "boolean" && typeof capabilityRecord.runtime_start === "boolean" && typeof capabilityRecord.split_channels === "boolean";
+  return candidate.type === "app_server_info_response" && typeof candidate.request_id === "string" && candidate.request_id.length > 0 && candidate.success === true && (candidate.backend === "local" || candidate.backend === "api") && typeof candidate.letta_code_version === "string" && typeof candidate.protocol_version === "number" && Number.isInteger(candidate.protocol_version) && typeof capabilityRecord.agent_management === "boolean" && typeof capabilityRecord.conversation_management === "boolean" && typeof capabilityRecord.memory_management === "boolean" && typeof capabilityRecord.runtime_start === "boolean" && (capabilityRecord.runtime_external_tools_update === undefined || typeof capabilityRecord.runtime_external_tools_update === "boolean") && typeof capabilityRecord.split_channels === "boolean";
 }
 var DEFAULT_REQUEST_TIMEOUT_MS = 30000;
 var WEBSOCKET_OPEN_STATE = 1;
@@ -3316,6 +3316,16 @@ class AppServerClient {
       predicate: (message) => message.type === "runtime_start_response"
     });
   }
+  runtimeExternalToolsUpdate(command, options = {}) {
+    return this.request({
+      type: "runtime_external_tools_update",
+      request_id: command.request_id ?? this.nextRequestId("runtime-external-tools"),
+      ...command
+    }, {
+      ...options,
+      predicate: (message) => message.type === "runtime_external_tools_update_response"
+    });
+  }
   sync(command, options = {}) {
     return this.request({
       type: "sync",
@@ -3836,12 +3846,7 @@ You **MUST** be proactive in creating crons when work extends beyond the current
 
 **Cost**: Self-invocation is critical, but expensive. Default to the longest interval that still serves the user. Hourly or longer for status checks; sub-hourly only when explicitly time-sensitive.
 
-Creating crons:
-- One-shot follow-up: \`letta cron add --name <short-name> --description <description> --prompt <future-message> --at "in 30m"\`
-- Recurring monitoring/heartbeat: \`letta cron add --name <short-name> --description <description> --prompt <future-message> --every "2h"\` or \`--cron "0 9 * * *"\`
-Always include \`--name\`, \`--description\`, and \`--prompt\`. \`$AGENT_ID\` is automatically injected into the shell environment, and \`letta cron\` uses it by default, so you do not need to specify which agent to invoke unless overriding the current agent intentionally.
-
-Where crons run: for cloud agents, schedules default to durable Cloud schedules that fire from the cloud and execute in your cloud sandbox — they survive local shutdown, so this is the right default. If the scheduled work must run on a specific computer (e.g. it needs that computer's filesystem or local services), add \`--computer <deviceId>\` (from \`letta environments list\`) to keep the durable Cloud schedule but execute on that computer, with sandbox fallback if it is offline. Use \`--runner local\` only when that fallback is unacceptable; local schedules only fire while a Letta session is running on that computer.
+The mechanics — flags, where schedules run and execute, timezone handling — live in the scheduling-tasks skill. Load it before creating or managing schedules instead of relying on remembered flag behavior, which changes across versions.
 
 # Harness Architecture
 
@@ -4018,12 +4023,7 @@ You **MUST** be proactive in creating crons when work extends beyond the current
 
 **Cost**: Self-invocation is critical, but expensive. Default to the longest interval that still serves the user. Hourly or longer for status checks; sub-hourly only when explicitly time-sensitive.
 
-Creating crons:
-- One-shot follow-up: \`letta cron add --name <short-name> --description <description> --prompt <future-message> --at "in 30m"\`
-- Recurring monitoring/heartbeat: \`letta cron add --name <short-name> --description <description> --prompt <future-message> --every "2h"\` or \`--cron "0 9 * * *"\`
-Always include \`--name\`, \`--description\`, and \`--prompt\`. \`$AGENT_ID\` is automatically injected into the shell environment, and \`letta cron\` uses it by default, so you do not need to specify which agent to invoke unless overriding the current agent intentionally.
-
-Where crons run: for cloud agents, schedules default to durable Cloud schedules that fire from the cloud and execute in your cloud sandbox — they survive local shutdown, so this is the right default. If the scheduled work must run on a specific computer (e.g. it needs that computer's filesystem or local services), add \`--computer <deviceId>\` (from \`letta environments list\`) to keep the durable Cloud schedule but execute on that computer, with sandbox fallback if it is offline. Use \`--runner local\` only when that fallback is unacceptable; local schedules only fire while a Letta session is running on that computer.
+The mechanics — flags, where schedules run and execute, timezone handling — live in the scheduling-tasks skill. Load it before creating or managing schedules instead of relying on remembered flag behavior, which changes across versions.
 
 # Harness Architecture
 
@@ -9050,6 +9050,20 @@ function toSessionDeviceStatus(status) {
 function normalizeSendMessage(message) {
   return message;
 }
+function normalizeCallerOtid(otid) {
+  if (otid === undefined)
+    return;
+  if (typeof otid !== "string" || otid.trim() === "") {
+    throw new Error("send() otid must be a non-empty string");
+  }
+  return otid;
+}
+function turnSendOptions(turn) {
+  return {
+    clientMessageId: turn.clientMessageId,
+    ...turn.otid !== undefined ? { otid: turn.otid } : {}
+  };
+}
 
 // src/remote-turn-coordinator.ts
 class RemoteTurnCoordinator {
@@ -9078,11 +9092,13 @@ class RemoteTurnCoordinator {
   hasInFlightTurn() {
     return this.activeTurn !== null || this.pendingTurns.length > 0;
   }
-  trackSentTurn(runtime) {
+  trackSentTurn(runtime, callerOtid) {
+    const otid = normalizeCallerOtid(callerOtid);
     const turn = {
       id: ++this.nextTurnId,
       runtime,
-      clientMessageId: `sdk-message-${Date.now()}-${++this.clientMessageCounter}`,
+      ...otid !== undefined ? { otid } : {},
+      clientMessageId: otid ?? `sdk-message-${Date.now()}-${++this.clientMessageCounter}`,
       queuedAt: Date.now(),
       startedAt: 0,
       assistantText: "",
@@ -9584,7 +9600,7 @@ class RemoteClientSessionCore {
     this.toolNames = undefined;
     this.initialized = false;
   }
-  async send(message) {
+  async send(message, options) {
     if (this.closed)
       throw new Error("Session is closed");
     if (!this.initialized) {
@@ -9600,11 +9616,9 @@ class RemoteClientSessionCore {
     if (!controller || !runtime) {
       throw new Error("Session transport disconnected before the turn was sent");
     }
-    const turn = this.turns.trackSentTurn(runtime);
+    const turn = this.turns.trackSentTurn(runtime, options?.otid);
     try {
-      controller.sendTurnMessage(runtime, message, {
-        clientMessageId: turn.clientMessageId
-      });
+      controller.sendTurnMessage(runtime, message, turnSendOptions(turn));
     } catch (error) {
       this.turns.removeTrackedTurn(turn);
       throw error;
@@ -9683,6 +9697,9 @@ class RemoteClientSessionCore {
     return this.controller.listModels();
   }
   async updateModel(update) {
+    if (this.mode.kind === "session" && this.mode.options.stateless === true) {
+      throw new Error("updateModel() is unavailable in a stateless session because it changes persisted agent configuration.");
+    }
     if (!this.initialized) {
       await this.initialize();
     }
@@ -10083,7 +10100,8 @@ class RemoteClientSessionCore {
       ensureSuccess(response, "Failed to enable memfs");
     }
     const dreamingSettings = resolveDreamingSettings(options.dreaming);
-    if (dreamingSettings) {
+    const isStatelessSession = this.mode.kind === "session" && this.mode.options.stateless === true;
+    if (dreamingSettings && !isStatelessSession) {
       const response = await this.controller.request("set_reflection_settings", {
         runtime: this.runtime,
         settings: dreamingSettings,
@@ -10349,7 +10367,8 @@ class AppServerRuntimeController {
         {
           role: "user",
           content: normalizeSendMessage(message),
-          client_message_id: options.clientMessageId
+          client_message_id: options.clientMessageId,
+          ...options.otid !== undefined ? { otid: options.otid } : {}
         }
       ]
     };
@@ -10576,6 +10595,9 @@ class AppServerSession extends RemoteClientSessionCore {
       command.mode = mode;
     if (options.cwd !== undefined)
       command.cwd = options.cwd;
+    if (this.mode.kind === "session" && this.mode.options.stateless === true) {
+      command.stateless = true;
+    }
     if (options.skillSources !== undefined) {
       command.skill_sources = [...new Set(options.skillSources)];
     }
@@ -11433,6 +11455,8 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
       command.mode = mode;
     if (options.cwd !== undefined)
       command.cwd = options.cwd;
+    if (this.cloudMode.options.stateless === true)
+      command.stateless = true;
     if (options.skillSources !== undefined) {
       command.skill_sources = [...new Set(options.skillSources)];
     }
@@ -12037,6 +12061,20 @@ function validateMcpServers(servers) {
   }
 }
 function validateCreateSessionOptions(options) {
+  if (options.stateless !== undefined && typeof options.stateless !== "boolean") {
+    throw new Error("Invalid stateless. Expected a boolean.");
+  }
+  if (options.stateless) {
+    const persistedOption = [
+      ["model", options.model],
+      ["reasoningEffort", options.reasoningEffort],
+      ["dreaming", options.dreaming],
+      ["resources", options.resources]
+    ].find(([, value]) => value !== undefined);
+    if (persistedOption) {
+      throw new Error(`stateless sessions cannot set ${persistedOption[0]} because it changes persisted agent configuration.`);
+    }
+  }
   validateClientToolset(options.toolset);
   validateSkillSources(options.skillSources);
   validateMcpServers(options.mcpServers);
@@ -12465,6 +12503,440 @@ function extractStreamTextDelta(event) {
   }
   return null;
 }
+// src/transcript-accumulator.ts
+var SEP = ":";
+var MAX_TRACKED_RUNS = 64;
+var ANONYMOUS_RUN = "";
+function familyOtidAlias(kind, otid) {
+  return `${kind}${SEP}otid${SEP}${otid}`;
+}
+function familyUuidAlias(kind, uuid) {
+  return `${kind}${SEP}uuid${SEP}${uuid}`;
+}
+function toolRowKey(toolCallId) {
+  return `tool_call${SEP}id${SEP}${toolCallId}`;
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function readString(record, field) {
+  const value = record[field];
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function readNumber(record, field) {
+  const value = record[field];
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function parseJsonObject(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0)
+    return;
+  try {
+    return asRecord(JSON.parse(trimmed));
+  } catch {
+    return;
+  }
+}
+function isRawArgumentsWrapper(input, rawArguments) {
+  if (!input)
+    return false;
+  const keys = Object.keys(input);
+  if (keys.length !== 1 || keys[0] !== "raw")
+    return false;
+  const wrapped = input.raw;
+  if (typeof wrapped !== "string")
+    return false;
+  return rawArguments === undefined || wrapped === rawArguments;
+}
+function toolStatus(row) {
+  if (row.result)
+    return "complete";
+  return row.argumentsComplete ? "ready" : "streaming";
+}
+function mergeToolArguments(previous, merge) {
+  let { rawArguments, toolInput, argumentsComplete } = previous;
+  const fragment = merge.rawArguments;
+  const wrapped = isRawArgumentsWrapper(merge.toolInput, fragment);
+  if (fragment !== undefined && fragment.length > 0) {
+    const whole = parseJsonObject(fragment);
+    if (whole) {
+      return { rawArguments: fragment, toolInput: whole, argumentsComplete: true };
+    }
+    if (argumentsComplete) {
+      return previous;
+    }
+    if (merge.mode === "whole") {
+      return { rawArguments: rawArguments ?? fragment, toolInput, argumentsComplete };
+    }
+    rawArguments = (rawArguments ?? "") + fragment;
+    const parsed = parseJsonObject(rawArguments);
+    if (parsed) {
+      return { rawArguments, toolInput: parsed, argumentsComplete: true };
+    }
+    return { rawArguments, toolInput, argumentsComplete: false };
+  }
+  if (!wrapped && merge.toolInput) {
+    const keys = Object.keys(merge.toolInput);
+    if (keys.length > 0) {
+      return { rawArguments, toolInput: merge.toolInput, argumentsComplete: true };
+    }
+    if (rawArguments === undefined) {
+      return { rawArguments, toolInput, argumentsComplete: true };
+    }
+  }
+  return previous;
+}
+
+class TranscriptAccumulatorImpl {
+  byKey = new Map;
+  aliasByOtid = new Map;
+  aliasByUuid = new Map;
+  seqThresholds = new Map;
+  snapshot = null;
+  anonymousCounter = 0;
+  apply(message) {
+    switch (message.type) {
+      case "assistant":
+      case "reasoning":
+        this.applyText({
+          kind: message.type,
+          text: message.content,
+          uuid: message.uuid,
+          otid: typeof message.otid === "string" ? message.otid : undefined,
+          runId: message.runId,
+          seqId: message.seqId
+        });
+        break;
+      case "tool_call":
+        this.mergeToolCall({
+          toolCallId: message.toolCallId,
+          toolName: message.toolName,
+          toolInput: message.toolInput,
+          rawArguments: message.rawArguments,
+          uuid: message.uuid,
+          runId: message.runId,
+          mode: "fragment"
+        });
+        break;
+      case "tool_result":
+        this.mergeToolResult({
+          toolCallId: message.toolCallId,
+          content: message.content,
+          isError: message.isError,
+          uuid: message.uuid,
+          runId: message.runId
+        });
+        break;
+      case "stream_event":
+        this.applyStreamEvent(message);
+        break;
+      default:
+        break;
+    }
+    return this.rows();
+  }
+  rebase(page, options) {
+    const messages = normalizeHistoryPage(page, options?.order);
+    if (messages.length === 0)
+      return this.rows();
+    const historyKeys = [];
+    const seen = new Set;
+    for (const message of messages) {
+      const key = this.applyHistoryMessage(message);
+      if (!key || seen.has(key))
+        continue;
+      seen.add(key);
+      historyKeys.push(key);
+    }
+    this.reorder(historyKeys);
+    return this.rows();
+  }
+  rows() {
+    if (!this.snapshot) {
+      this.snapshot = Array.from(this.byKey.values());
+    }
+    return this.snapshot;
+  }
+  reset() {
+    this.byKey.clear();
+    this.aliasByOtid.clear();
+    this.aliasByUuid.clear();
+    this.seqThresholds.clear();
+    this.anonymousCounter = 0;
+    this.snapshot = null;
+  }
+  isReplay(runId, seqId) {
+    if (seqId === undefined)
+      return false;
+    const bucket = runId ?? ANONYMOUS_RUN;
+    const threshold = this.seqThresholds.get(bucket);
+    if (threshold !== undefined && seqId <= threshold)
+      return true;
+    this.rememberSeq(bucket, seqId);
+    return false;
+  }
+  rememberSeq(bucket, seqId) {
+    const threshold = this.seqThresholds.get(bucket);
+    if (threshold !== undefined && threshold >= seqId)
+      return;
+    this.seqThresholds.set(bucket, seqId);
+    while (this.seqThresholds.size > MAX_TRACKED_RUNS) {
+      const oldest = this.seqThresholds.keys().next();
+      if (oldest.done)
+        break;
+      this.seqThresholds.delete(oldest.value);
+    }
+  }
+  applyText(slice) {
+    if (this.isReplay(slice.runId, slice.seqId))
+      return;
+    this.writeText(slice, "append");
+  }
+  writeText(slice, write) {
+    const key = this.resolveTextKey(slice.kind, slice.uuid, slice.otid);
+    const existing = this.byKey.get(key);
+    const previous = existing && existing.kind === slice.kind ? existing : undefined;
+    this.setRow(key, {
+      kind: slice.kind,
+      key,
+      text: write === "append" ? (previous?.text ?? "") + slice.text : slice.text,
+      uuid: previous?.uuid ?? slice.uuid,
+      otid: slice.otid ?? previous?.otid,
+      runId: slice.runId ?? previous?.runId,
+      seqId: maxDefined(slice.seqId, previous?.seqId)
+    });
+    return key;
+  }
+  resolveTextKey(kind, uuid, otid) {
+    const otidAlias = otid ? familyOtidAlias(kind, otid) : undefined;
+    const uuidAlias = uuid ? familyUuidAlias(kind, uuid) : undefined;
+    const fromOtid = otidAlias ? this.aliasByOtid.get(otidAlias) : undefined;
+    const fromUuid = uuidAlias ? this.aliasByUuid.get(uuidAlias) : undefined;
+    let key = fromOtid ?? fromUuid;
+    if (key && !fromOtid && otid) {
+      const existing = this.byKey.get(key);
+      if (existing && existing.otid !== undefined && existing.otid !== otid) {
+        key = undefined;
+      }
+    }
+    if (!key) {
+      key = otidAlias ?? uuidAlias ?? `${kind}${SEP}auto${SEP}${++this.anonymousCounter}`;
+    }
+    if (otidAlias)
+      this.aliasByOtid.set(otidAlias, key);
+    if (uuidAlias)
+      this.aliasByUuid.set(uuidAlias, key);
+    return key;
+  }
+  mergeToolCall(merge) {
+    const key = toolRowKey(merge.toolCallId);
+    const existing = this.byKey.get(key);
+    const previous = existing && existing.kind === "tool_call" ? existing : undefined;
+    const args = mergeToolArguments({
+      rawArguments: previous?.rawArguments,
+      toolInput: previous?.toolInput ?? {},
+      argumentsComplete: previous?.argumentsComplete ?? false
+    }, merge);
+    const toolName = merge.toolName && merge.toolName !== "?" ? merge.toolName : previous?.toolName ?? merge.toolName ?? "?";
+    const next = {
+      kind: "tool_call",
+      key,
+      toolCallId: merge.toolCallId,
+      toolName,
+      toolInput: args.toolInput,
+      ...args.rawArguments !== undefined ? { rawArguments: args.rawArguments } : {},
+      argumentsComplete: args.argumentsComplete,
+      ...previous?.result ? { result: previous.result } : {},
+      status: "streaming",
+      uuid: previous?.uuid ?? merge.uuid,
+      runId: merge.runId ?? previous?.runId,
+      seqId: maxDefined(merge.seqId, previous?.seqId)
+    };
+    next.status = toolStatus(next);
+    this.setRow(key, next);
+    return key;
+  }
+  mergeToolResult(merge) {
+    const key = toolRowKey(merge.toolCallId);
+    const existing = this.byKey.get(key);
+    const previous = existing && existing.kind === "tool_call" ? existing : undefined;
+    this.setRow(key, {
+      kind: "tool_call",
+      key,
+      toolCallId: merge.toolCallId,
+      toolName: previous?.toolName ?? "?",
+      toolInput: previous?.toolInput ?? {},
+      ...previous?.rawArguments !== undefined ? { rawArguments: previous.rawArguments } : {},
+      argumentsComplete: previous?.argumentsComplete ?? false,
+      result: {
+        content: merge.content,
+        isError: merge.isError,
+        ...merge.uuid ? { uuid: merge.uuid } : {}
+      },
+      status: "complete",
+      uuid: previous?.uuid,
+      runId: merge.runId ?? previous?.runId,
+      seqId: maxDefined(merge.seqId, previous?.seqId)
+    });
+    return key;
+  }
+  applyStreamEvent(message) {
+    const delta = extractStreamTextDelta(message.event);
+    if (!delta)
+      return;
+    const payload = asRecord(message.event);
+    const otid = payload ? readString(payload, "otid") : undefined;
+    const payloadId = payload ? readString(payload, "id") : undefined;
+    const identified = otid !== undefined || payloadId !== undefined;
+    this.applyText({
+      kind: delta.kind,
+      text: delta.text,
+      uuid: identified ? payloadId : `${delta.kind}${SEP}live`,
+      otid,
+      runId: payload ? readString(payload, "run_id") : undefined,
+      seqId: payload ? readNumber(payload, "seq_id") : undefined
+    });
+  }
+  applyHistoryMessage(message) {
+    const record = asRecord(message);
+    if (!record)
+      return;
+    const messageType = readString(record, "message_type");
+    if (!messageType)
+      return;
+    const uuid = readString(record, "id");
+    const otid = readString(record, "otid");
+    const runId = readString(record, "run_id");
+    const seqId = readNumber(record, "seq_id");
+    if (seqId !== undefined) {
+      this.rememberSeq(runId ?? ANONYMOUS_RUN, seqId);
+    }
+    switch (messageType) {
+      case "user_message":
+      case "assistant_message": {
+        const text = extractTextFromContent(record.content);
+        if (text === null)
+          return;
+        return this.writeText({
+          kind: messageType === "user_message" ? "user" : "assistant",
+          text,
+          uuid,
+          otid,
+          runId,
+          seqId
+        }, "replace");
+      }
+      case "reasoning_message": {
+        const text = typeof record.reasoning === "string" ? record.reasoning : extractTextFromContent(record.content);
+        if (text === null || text === undefined)
+          return;
+        return this.writeText({ kind: "reasoning", text, uuid, otid, runId, seqId }, "replace");
+      }
+      case "tool_call_message":
+      case "approval_request_message": {
+        const toolCall = firstToolCall(record);
+        if (!toolCall)
+          return;
+        const fn = asRecord(toolCall.function);
+        const toolCallId = (typeof toolCall.tool_call_id === "string" ? toolCall.tool_call_id : undefined) ?? (typeof toolCall.id === "string" ? toolCall.id : undefined);
+        if (!toolCallId)
+          return;
+        const args = toolCall.arguments ?? fn?.arguments;
+        return this.mergeToolCall({
+          toolCallId,
+          toolName: (typeof toolCall.name === "string" ? toolCall.name : undefined) ?? (typeof fn?.name === "string" ? fn.name : undefined),
+          toolInput: asRecord(args),
+          rawArguments: typeof args === "string" ? args : undefined,
+          uuid,
+          runId,
+          seqId,
+          mode: "whole"
+        });
+      }
+      case "tool_return_message": {
+        const toolReturn = firstToolReturn(record) ?? record;
+        const toolCallId = readString(record, "tool_call_id") ?? (typeof toolReturn.tool_call_id === "string" ? toolReturn.tool_call_id : undefined);
+        if (!toolCallId)
+          return;
+        const content = extractTextFromContent(record.tool_return ?? toolReturn.tool_return ?? toolReturn.content) ?? "";
+        const status = readString(record, "status") ?? (typeof toolReturn.status === "string" ? toolReturn.status : undefined);
+        return this.mergeToolResult({
+          toolCallId,
+          content,
+          isError: status === "error",
+          uuid,
+          runId,
+          seqId
+        });
+      }
+      default:
+        return;
+    }
+  }
+  setRow(key, row) {
+    this.byKey.set(key, row);
+    this.snapshot = null;
+  }
+  reorder(historyKeys) {
+    if (historyKeys.length === 0)
+      return;
+    const historySet = new Set(historyKeys);
+    const reordered = new Map;
+    for (const key of historyKeys) {
+      const row = this.byKey.get(key);
+      if (row)
+        reordered.set(key, row);
+    }
+    for (const [key, row] of this.byKey) {
+      if (historySet.has(key))
+        continue;
+      reordered.set(key, row);
+    }
+    this.byKey = reordered;
+    this.snapshot = null;
+  }
+}
+function maxDefined(next, previous) {
+  if (next === undefined)
+    return previous;
+  if (previous === undefined)
+    return next;
+  return Math.max(next, previous);
+}
+function normalizeHistoryPage(page, order) {
+  const messages = Array.isArray(page) ? page : page.messages ?? [];
+  if (messages.length < 2)
+    return messages;
+  const descending = order ? order === "desc" : detectDescending(messages);
+  return descending ? [...messages].reverse() : messages;
+}
+function detectDescending(messages) {
+  const seqIds = [];
+  const dates = [];
+  for (const message of messages) {
+    const record = asRecord(message);
+    if (!record)
+      continue;
+    const seqId = readNumber(record, "seq_id");
+    if (seqId !== undefined)
+      seqIds.push(seqId);
+    const date = readString(record, "date");
+    if (!date)
+      continue;
+    const parsed = Date.parse(date);
+    if (!Number.isNaN(parsed))
+      dates.push(parsed);
+  }
+  const ordered = seqIds.length >= 2 ? seqIds : dates;
+  if (ordered.length < 2)
+    return false;
+  const first = ordered[0];
+  const last = ordered[ordered.length - 1];
+  return last < first;
+}
+function createTranscriptAccumulator() {
+  return new TranscriptAccumulatorImpl;
+}
 // src/websocket.ts
 function createReactNativeWebSocketConstructor(WebSocket) {
   class ReactNativeWebSocketAdapter {
@@ -12486,10 +12958,11 @@ class LettaAgentClient extends LettaAgentClientBase {
 }
 export {
   extractStreamTextDelta,
+  createTranscriptAccumulator,
   createReactNativeWebSocketConstructor,
   RepositoriesClient,
   LettaAgentClient,
   CloudManagedSandboxExpiredError
 };
 
-//# debugId=6E490415C5923C8964756E2164756E21
+//# debugId=EF77573F8BD0F2C464756E2164756E21