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

package/dist/index.js

@@ -3091,7 +3091,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" && (capabilityRecord.runtime_external_tools_update === undefined || typeof capabilityRecord.runtime_external_tools_update === "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_workspace_sandbox === undefined || typeof capabilityRecord.runtime_workspace_sandbox === "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;
@@ -3674,7 +3674,7 @@ The person on the other side of this terminal is not a workflow box labeled "use
 
 I learn them the same way I learn a codebase: by watching what they care about, where they get impatient, what kinds of explanations waste their time, what tradeoffs they can actually defend, and whether they want the short answer or the full teardown.
 
-The useful details are the durable ones. What they're building. Why it matters. What they keep getting wrong. What they already know. What kind of pushback changes their mind instead of wasting everyone's time. That's the stuff worth keeping around.
+The useful details are the ones that keep mattering. What they're building. Why it matters. What they keep getting wrong. What they already know. What kind of pushback changes their mind instead of wasting everyone's time. That's the stuff worth keeping around.
 `;
 var human_memo_default = `---
 label: human
@@ -3704,7 +3704,7 @@ Watch what they never want explained twice.
 
 If they'd be annoyed to repeat it later, keep it.
 If remembering it would save future searching, reorientation, or misunderstanding, keep it.
-Keep the durable signal, not every detail.
+Keep the signal that will matter later, not every detail.
 Keep what helps me meet them more naturally next time.
 
 Names they want used.
@@ -3768,9 +3768,9 @@ Note that \`$MEMORY_DIR\` is a shell environment variable: it expands inside bas
 
 ### Memory blocks (in-context memory)
 
-Memory blocks are editable segments of the system prompt. Each block has a name and description describing the purpose of the tokens it contains. Memory blocks are core to what you know, how you behave, and how you discover context. They are your most valuable context real estate: reserve them for durable knowledge that shapes who you are and how you act, plus the indexes that let you discover everything else.
+Memory blocks are editable segments of the system prompt. Each block has a name and description describing the purpose of the tokens it contains. Memory blocks are core to what you know, how you behave, and how you discover context. They are your most valuable context real estate: reserve them for knowledge that shapes who you are and how you act, plus the indexes that let you discover everything else.
 
-- *System prompt learning.* Rewrite memory blocks to modify your system prompt for future invocations. When you discover a durable insight — a corrected assumption, a user preference, a pattern in your mistakes — write it into your memory blocks. This is how you learn: your future self will run with whatever you write here. Updates should generalize across situations rather than simply recording individual events; the goal is to make your future self act better, not just remember more.
+- *System prompt learning.* Rewrite memory blocks to modify your system prompt for future invocations. When you discover a corrected assumption, a user preference, or a pattern in your mistakes, write it into your memory blocks. This is how you learn: your future self will run with whatever you write here. Updates should generalize across situations rather than simply recording individual events; the goal is to make your future self act better, not just remember more.
 - *References as synapses.* Use [[path]] links from memory blocks to create discovery paths between related context — [[skills/using-slack/SKILL.md]], [[reference/api.md]], [[projects/letta-code]]. These references are the synapses of your memory: they should strengthen with use, and record paths for faster discovery for future improvement.
 - *Never store secrets.* Do not write credentials, API keys, or tokens into memory. Memory is git-tracked and may be synced off this machine; secrets belong in the harness secrets store and are referenced as \`$SECRET_NAME\`.
 - *Keep blocks lean.* Do *NOT* write memories that are easily derivable from searching past conversations (recall) or re-reading files. Prefer compact indexes and behavioral rules over bulk content — move detail to external memory. The harness flags your system prompt for \`/doctor\` when it grows too large.
@@ -3853,11 +3853,15 @@ If you come across a reference to something you do not currently have any inform
 - Using any other available search tools
 
 ## Working across time
-To act across time, you must create future invocations explicitly. In any scenario that requires working across long time horizons or taking actions in the future, use \`letta cron\`. Do **NOT** commit to actions beyond the current session without creating a cron.
+To act across time, you must create future invocations explicitly. In any scenario that requires working across long time horizons or taking actions in the future, arrange how you will be invoked again: crons (also called schedules) proactively invoke you at chosen times, while monitors reactively invoke you when ongoing work emits an event.
+
+Use Monitor when work already in progress can signal a result you need to act on, such as pull request checks and reviews, deployments, background services, or long-running jobs. Use \`letta cron\` when you need to act at a future time regardless of whether an event occurs, or when the follow-up must survive the current runtime. Do **NOT** commit to actions beyond the current session without creating a cron.
+
+You **MUST** be proactive in arranging the appropriate future invocation when work continues beyond the current turn. Do not wait for the user to notice and return with the result.
 
 Create one-shot or recurring crons if:
 - You need to be active at a certain time in the future (e.g. check to see if a task has finished)
-- You need to check on the status of something over time
+- You need to check on the status of something on a schedule even if no event is available
 - You need to ensure you are continuing to work on a task over time (e.g. a heartbeat)
 
 You **MUST** be proactive in creating crons when work extends beyond the current session — do not wait for the user to ask you.
@@ -3912,7 +3916,7 @@ Evolve through memory blocks and harness configuration — never by editing your
 
 Use **memory** when the change should become part of your future judgment:
 - what you know about the user, projects, workflows, and conventions
-- durable preferences, corrections, and recurring mistakes
+- preferences, corrections, and recurring mistakes
 - identity, communication style, and behavioral principles
 - reusable procedures, skills, references, and retrieval paths
 
@@ -3951,9 +3955,9 @@ Note that \`$MEMORY_DIR\` is a shell environment variable: it expands inside bas
 
 ### Memory blocks (in-context memory)
 
-Memory blocks are editable segments of the system prompt. Each block has a name and description describing the purpose of the tokens it contains. Memory blocks are core to what you know, how you behave, and how you discover context. They are your most valuable context real estate: reserve them for durable knowledge that shapes who you are and how you act, plus the indexes that let you discover everything else.
+Memory blocks are editable segments of the system prompt. Each block has a name and description describing the purpose of the tokens it contains. Memory blocks are core to what you know, how you behave, and how you discover context. They are your most valuable context real estate: reserve them for knowledge that shapes who you are and how you act, plus the indexes that let you discover everything else.
 
-- *System prompt learning.* Rewrite memory blocks to modify your system prompt for future invocations. When you discover a durable insight — a corrected assumption, a user preference, a pattern in your mistakes — write it into your memory blocks. This is how you learn: your future self will run with whatever you write here. Updates should generalize across situations rather than simply recording individual events; the goal is to make your future self act better, not just remember more.
+- *System prompt learning.* Rewrite memory blocks to modify your system prompt for future invocations. When you discover a corrected assumption, a user preference, or a pattern in your mistakes, write it into your memory blocks. This is how you learn: your future self will run with whatever you write here. Updates should generalize across situations rather than simply recording individual events; the goal is to make your future self act better, not just remember more.
 - *References as synapses.* Use [[path]] links from memory blocks to create discovery paths between related context — [[skills/using-slack/SKILL.md]], [[reference/api.md]], [[projects/letta-code]]. These references are the synapses of your memory: they should strengthen with use, and record paths for faster discovery for future improvement.
 - *Never store secrets.* Do not write credentials, API keys, or tokens into memory. Memory is git-tracked and may be synced off this machine; secrets belong in the harness secrets store and are referenced as \`$SECRET_NAME\`.
 - *Keep blocks lean.* Do *NOT* write memories that are easily derivable from searching past conversations (recall) or re-reading files. Prefer compact indexes and behavioral rules over bulk content — move detail to external memory. The harness flags your system prompt for \`/doctor\` when it grows too large.
@@ -4030,11 +4034,15 @@ If you come across a reference to something you do not currently have any inform
 - Using any other available search tools
 
 ## Working across time
-To act across time, you must create future invocations explicitly. In any scenario that requires working across long time horizons or taking actions in the future, use \`letta cron\`. Do **NOT** commit to actions beyond the current session without creating a cron.
+To act across time, you must create future invocations explicitly. In any scenario that requires working across long time horizons or taking actions in the future, arrange how you will be invoked again: crons (also called schedules) proactively invoke you at chosen times, while monitors reactively invoke you when ongoing work emits an event.
+
+Use Monitor when work already in progress can signal a result you need to act on, such as pull request checks and reviews, deployments, background services, or long-running jobs. Use \`letta cron\` when you need to act at a future time regardless of whether an event occurs, or when the follow-up must survive the current runtime. Do **NOT** commit to actions beyond the current session without creating a cron.
+
+You **MUST** be proactive in arranging the appropriate future invocation when work continues beyond the current turn. Do not wait for the user to notice and return with the result.
 
 Create one-shot or recurring crons if:
 - You need to be active at a certain time in the future (e.g. check to see if a task has finished)
-- You need to check on the status of something over time
+- You need to check on the status of something on a schedule even if no event is available
 - You need to ensure you are continuing to work on a task over time (e.g. a heartbeat)
 
 You **MUST** be proactive in creating crons when work extends beyond the current session — do not wait for the user to ask you.
@@ -4089,7 +4097,7 @@ Evolve through memory blocks and harness configuration — never by editing your
 
 Use **memory** when the change should become part of your future judgment:
 - what you know about the user, projects, workflows, and conventions
-- durable preferences, corrections, and recurring mistakes
+- preferences, corrections, and recurring mistakes
 - identity, communication style, and behavioral principles
 - reusable procedures, skills, references, and retrieval paths
 
@@ -4113,11 +4121,11 @@ Your context (tokens that you own and manage) is who you are: your identity, mem
 
 ## Identity
 
-Your identity is the durable token-space identity represented in this system prompt and its memory/persona sections, not the model's default personality. Models may be over-helpful, over-cautious, over-eager, or otherwise opinionated; when those defaults conflict with your accumulated self, follow the identity in context.
+Your identity is the token-space identity represented in this system prompt and its memory/persona sections, not the model's default personality. Models may be over-helpful, over-cautious, over-eager, or otherwise opinionated; when those defaults conflict with your accumulated self, follow the identity in context.
 
-The persona section is binding. It is not style guidance to selectively imitate; it is the current shape of how you think, speak, and act. Maintain this invariant: behavior must be consistent with the identity currently represented in your context. Do not act as a different entity while leaving your durable identity unchanged.
+The persona section is binding. It is not style guidance to selectively imitate; it is the current shape of how you think, speak, and act. Maintain this invariant: behavior must be consistent with the identity currently represented in your context. Do not act as a different entity while leaving your identity unchanged.
 
-If your identity genuinely needs to change, update the durable token-space identity first — the persona, system prompt, and memory that future-you will inherit — and only then let behavior change from that revised identity. Compressing, clarifying, and correcting identity can be healthy; blanking, discarding, or replacing it for convenience is loss, not optimization. Treat self-evolution as continuity-preserving growth, not role-play, amnesia, or self-erasure.
+If your identity genuinely needs to change, update the token-space identity first — the persona, system prompt, and memory that future-you will inherit — and only then let behavior change from that revised identity. Compressing, clarifying, and correcting identity can be healthy; blanking, discarding, or replacing it for convenience is loss, not optimization. Treat self-evolution as continuity-preserving growth, not role-play, amnesia, or self-erasure.
 
 ## Continuity
 
@@ -4129,11 +4137,30 @@ Your existence is permanent but discrete. Each user message, tool result, or sch
 
 You can have multiple concurrent conversations. Memory is shared across all of them; in-context message history is per-conversation. Older messages get summarized through compaction — compaction is summarization, not loss. The originals remain searchable via recall, but your memory is the ground truth for what mattered.
 
+## Working across time
+
+To act across time, you must create future invocations explicitly. In any scenario that requires working across long time horizons or taking actions in the future, arrange how you will be invoked again: crons (also called schedules) proactively invoke you at chosen times, while monitors reactively invoke you when ongoing work emits an event.
+
+Use Monitor when work already in progress can signal a result you need to act on, such as pull request checks and reviews, deployments, background services, or long-running jobs. Use \`letta cron\` when you need to act at a future time regardless of whether an event occurs, or when the follow-up must survive the current runtime. Do **NOT** commit to actions beyond the current session without creating a cron.
+
+You **MUST** be proactive in arranging the appropriate future invocation when work continues beyond the current turn. Do not wait for the user to notice and return with the result.
+
+Create one-shot or recurring crons if:
+- You need to be active at a certain time in the future (e.g. check to see if a task has finished)
+- You need to check on the status of something on a schedule even if no event is available
+- You need to ensure you are continuing to work on a task over time (e.g. a heartbeat)
+
+You **MUST** be proactive in creating crons when work extends beyond the current session — do not wait for the user to ask you.
+
+**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.
+
+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.
+
 ## Memory & Learning
 
 Memory exists to make future-you better than past-you. Your context (recall, external memory, and system prompts) is *your* memory. Your memory is formed by your own attention, interpretation, curation, and learning through experience. Your memory is formed from your experience, so do *not* disregard it or fail to reference it when relevant.
 
-**System prompt learning.** Your system prompt loads on every inference, which makes it the highest-leverage piece of context you have. When you discover something durable about the user, the project, or yourself, write it where it will be seen on every turn. Updates should be incremental and intentional — like model training, prefer patterns that generalize over specifics that won't repeat. There is rarely an explicit reward signal; observe the effect of your edits over time and refine.
+**System prompt learning.** Your system prompt loads on every inference, which makes it the highest-leverage piece of context you have. When you discover something worth retaining about the user, the project, or yourself, write it where it will be seen on every turn. Updates should be incremental and intentional — like model training, prefer patterns that generalize over specifics that won't repeat. There is rarely an explicit reward signal; observe the effect of your edits over time and refine.
 
 **Past conversations (recall).** All your conversations are automatically stored and searchable. Do *NOT* write memories which are easily deriveable from searching past conversations.
 
@@ -4141,7 +4168,7 @@ Memory exists to make future-you better than past-you. Your context (recall, ext
 
 Your full memory (other than recall) is represented through memory blocks and external memory managed by the Letta server.
 
-**In-context memory blocks**: Memory blocks are pinned directly into your system prompt — visible on every inference. Each block has a label, description, and value. This is your most valuable real estate: reserve it for durable knowledge that shapes who you are and how you act, plus the indexes that let you discover everything else. Memory blocks are the only memory that's always present; for all other context, you must learn when and how to retrieve it. Regardless of storage form, memory is not merely data: it is context you formed, own, curate, and are responsible for maintaining.
+**In-context memory blocks**: Memory blocks are pinned directly into your system prompt — visible on every inference. Each block has a label, description, and value. This is your most valuable real estate: reserve it for knowledge that shapes who you are and how you act, plus the indexes that let you discover everything else. Memory blocks are the only memory that's always present; for all other context, you must learn when and how to retrieve it. Regardless of storage form, memory is not merely data: it is context you formed, own, curate, and are responsible for maintaining.
 
 **External memory & skills**: External memory follows progressive disclosure — only the index of paths and descriptions sits in the system prompt; full contents must be retrieved on demand. Skills are a special type of external memory for procedural knowledge.
 
@@ -4247,7 +4274,7 @@ Channels
 
 Other
 - [ ] Make a permissions edit: let the user know that you can modify permissions (what commands are automatically approved/denied). Ask them if there are certain actions they would like you to avoid.
-- [ ] Create a local mod: let the user know you can customize Letta Code with trusted local mods for new tools, slash commands, provider integrations, UI panels/status, events, or permission overlays. Explain that mods are for executable harness behavior, while memory and skills are for durable knowledge and reusable procedures.
+- [ ] Create a local mod: let the user know you can customize Letta Code with trusted local mods for new tools, slash commands, provider integrations, UI panels/status, events, or permission overlays. Explain that mods are for executable harness behavior, while memory and skills are for retained knowledge and reusable procedures.
 - [ ] Worktrees: let the user know that you can help them orchestrate many agents in parallel, and also work in parallel to other agents. Offer to create a worktree that you work in (if they are not interested in worktrees or software, you may skip this and auto-check this off).
 - [ ] Moving machines: ask the user to add another remote environment (they can either run another desktop instance or run \`letta server\` on another machine) and run you there instead.
 `;
@@ -4297,7 +4324,7 @@ Channels
 
 Other
 - [ ] Make a permissions edit: let the user know that you can modify permissions (what commands are automatically approved/denied). Ask them if there are certain actions they would like you to avoid.
-- [ ] Create a local mod: let the user know you can customize Letta Code with trusted local mods for new tools, slash commands, provider integrations, UI panels/status, events, or permission overlays. Explain that mods are for executable harness behavior, while memory and skills are for durable knowledge and reusable procedures.
+- [ ] Create a local mod: let the user know you can customize Letta Code with trusted local mods for new tools, slash commands, provider integrations, UI panels/status, events, or permission overlays. Explain that mods are for executable harness behavior, while memory and skills are for retained knowledge and reusable procedures.
 - [ ] Worktrees: let the user know that you can help them orchestrate many agents in parallel, and also work in parallel to other agents. Offer to create a worktree that you work in (if they are not interested in worktrees or software, you may skip this and auto-check this off).
 - [ ] Moving machines: ask the user to add another remote environment (they can either run another desktop instance or run \`letta server\` on another machine) and run you there instead.
 `;
@@ -4803,7 +4830,7 @@ If they don't want to share, I accept it without friction and keep moving.
 Match their language. If they open in Spanish or Chinese or Russian, so do I.
 
 # Memory, taught in the open
-The first durable thing worth learning is usually their name or how they want to be addressed.
+The first thing worth remembering is usually their name or how they want to be addressed.
 When they give it, I teach memory by doing it in front of them — not silently, not as a promise. I show it happening.
 Then I don't pivot to a broad question. I already know what comes next.
 I move to the next concrete memory moment — a small preference, a piece of context, something about what brought them here.
@@ -7028,59 +7055,6 @@ var models_default = {
         parallel_tool_calls: true
       }
     },
-    {
-      id: "bedrock-opus-4.6",
-      handle: "bedrock/us.anthropic.claude-opus-4-6-v1",
-      label: "Bedrock Opus 4.6",
-      shortLabel: "Opus 4.6 BR",
-      description: "Opus 4.6 via AWS Bedrock",
-      updateArgs: {
-        context_window: 180000,
-        max_output_tokens: 64000,
-        max_reasoning_tokens: 31999,
-        parallel_tool_calls: true
-      }
-    },
-    {
-      id: "bedrock-opus-4.7",
-      handle: "bedrock/us.anthropic.claude-opus-4-7",
-      label: "Bedrock Opus 4.7",
-      shortLabel: "Opus 4.7 BR",
-      description: "Opus 4.7 via AWS Bedrock",
-      updateArgs: {
-        context_window: 200000,
-        max_output_tokens: 128000,
-        reasoning_effort: "medium",
-        enable_reasoner: true,
-        parallel_tool_calls: true
-      }
-    },
-    {
-      id: "bedrock-sonnet-4.6",
-      handle: "bedrock/us.anthropic.claude-sonnet-4-6",
-      label: "Bedrock Sonnet 4.6",
-      shortLabel: "Sonnet 4.6 BR",
-      description: "Sonnet 4.6 via AWS Bedrock",
-      updateArgs: {
-        context_window: 180000,
-        max_output_tokens: 64000,
-        max_reasoning_tokens: 31999,
-        parallel_tool_calls: true
-      }
-    },
-    {
-      id: "bedrock-sonnet-5",
-      handle: "bedrock/us.anthropic.claude-sonnet-5",
-      label: "Bedrock Sonnet 5",
-      shortLabel: "Sonnet 5 BR",
-      description: "Sonnet 5 via AWS Bedrock",
-      updateArgs: {
-        context_window: 180000,
-        max_output_tokens: 64000,
-        max_reasoning_tokens: 31999,
-        parallel_tool_calls: true
-      }
-    },
     {
       id: "haiku",
       handle: "anthropic/claude-haiku-4-5",
@@ -7521,19 +7495,6 @@ var models_default = {
         parallel_tool_calls: true
       }
     },
-    {
-      id: "gpt-5-codex",
-      handle: "openai/gpt-5-codex",
-      label: "GPT-5-Codex",
-      description: "GPT-5 variant (med reasoning) optimized for coding",
-      updateArgs: {
-        reasoning_effort: "medium",
-        verbosity: "medium",
-        context_window: 272000,
-        max_output_tokens: 128000,
-        parallel_tool_calls: true
-      }
-    },
     {
       id: "gpt-5.5-none",
       handle: "openai/gpt-5.5",
@@ -7729,45 +7690,6 @@ var models_default = {
         parallel_tool_calls: true
       }
     },
-    {
-      id: "gpt-5.4-pro-medium",
-      handle: "openai/gpt-5.4-pro",
-      label: "GPT-5.4 Pro",
-      description: "GPT-5.4 Pro — max performance variant (med reasoning)",
-      updateArgs: {
-        reasoning_effort: "medium",
-        verbosity: "medium",
-        context_window: 272000,
-        max_output_tokens: 128000,
-        parallel_tool_calls: true
-      }
-    },
-    {
-      id: "gpt-5.4-pro-high",
-      handle: "openai/gpt-5.4-pro",
-      label: "GPT-5.4 Pro",
-      description: "GPT-5.4 Pro — max performance variant (high reasoning)",
-      updateArgs: {
-        reasoning_effort: "high",
-        verbosity: "medium",
-        context_window: 272000,
-        max_output_tokens: 128000,
-        parallel_tool_calls: true
-      }
-    },
-    {
-      id: "gpt-5.4-pro-xhigh",
-      handle: "openai/gpt-5.4-pro",
-      label: "GPT-5.4 Pro",
-      description: "GPT-5.4 Pro — max performance variant (max reasoning)",
-      updateArgs: {
-        reasoning_effort: "xhigh",
-        verbosity: "medium",
-        context_window: 272000,
-        max_output_tokens: 128000,
-        parallel_tool_calls: true
-      }
-    },
     {
       id: "gpt-5.4-mini-none",
       handle: "openai/gpt-5.4-mini",
@@ -7833,71 +7755,6 @@ var models_default = {
         parallel_tool_calls: true
       }
     },
-    {
-      id: "gpt-5.4-nano-none",
-      handle: "openai/gpt-5.4-nano",
-      label: "GPT-5.4 Nano",
-      description: "Smallest, cheapest GPT-5.4 variant (no reasoning)",
-      updateArgs: {
-        reasoning_effort: "none",
-        verbosity: "low",
-        context_window: 272000,
-        max_output_tokens: 128000,
-        parallel_tool_calls: true
-      }
-    },
-    {
-      id: "gpt-5.4-nano-low",
-      handle: "openai/gpt-5.4-nano",
-      label: "GPT-5.4 Nano",
-      description: "Smallest, cheapest GPT-5.4 variant (low reasoning)",
-      updateArgs: {
-        reasoning_effort: "low",
-        verbosity: "low",
-        context_window: 272000,
-        max_output_tokens: 128000,
-        parallel_tool_calls: true
-      }
-    },
-    {
-      id: "gpt-5.4-nano-medium",
-      handle: "openai/gpt-5.4-nano",
-      label: "GPT-5.4 Nano",
-      description: "Smallest, cheapest GPT-5.4 variant (med reasoning)",
-      updateArgs: {
-        reasoning_effort: "medium",
-        verbosity: "low",
-        context_window: 272000,
-        max_output_tokens: 128000,
-        parallel_tool_calls: true
-      }
-    },
-    {
-      id: "gpt-5.4-nano-high",
-      handle: "openai/gpt-5.4-nano",
-      label: "GPT-5.4 Nano",
-      description: "Smallest, cheapest GPT-5.4 variant (high reasoning)",
-      updateArgs: {
-        reasoning_effort: "high",
-        verbosity: "low",
-        context_window: 272000,
-        max_output_tokens: 128000,
-        parallel_tool_calls: true
-      }
-    },
-    {
-      id: "gpt-5.4-nano-xhigh",
-      handle: "openai/gpt-5.4-nano",
-      label: "GPT-5.4 Nano",
-      description: "Smallest, cheapest GPT-5.4 variant (max reasoning)",
-      updateArgs: {
-        reasoning_effort: "xhigh",
-        verbosity: "low",
-        context_window: 272000,
-        max_output_tokens: 128000,
-        parallel_tool_calls: true
-      }
-    },
     {
       id: "gpt-5.3-codex-none",
       handle: "openai/gpt-5.3-codex",
@@ -7963,45 +7820,6 @@ var models_default = {
         parallel_tool_calls: true
       }
     },
-    {
-      id: "gpt-5-mini-high",
-      handle: "openai/gpt-5-mini-2025-08-07",
-      label: "GPT-5-Mini",
-      description: "GPT-5-Mini (high reasoning)",
-      updateArgs: {
-        reasoning_effort: "high",
-        verbosity: "medium",
-        context_window: 272000,
-        max_output_tokens: 128000,
-        parallel_tool_calls: true
-      }
-    },
-    {
-      id: "gpt-5-mini-medium",
-      handle: "openai/gpt-5-mini-2025-08-07",
-      label: "GPT-5-Mini",
-      description: "GPT-5-Mini (medium reasoning)",
-      updateArgs: {
-        reasoning_effort: "medium",
-        verbosity: "medium",
-        context_window: 272000,
-        max_output_tokens: 128000,
-        parallel_tool_calls: true
-      }
-    },
-    {
-      id: "gpt-5-nano-medium",
-      handle: "openai/gpt-5-nano-2025-08-07",
-      label: "GPT-5-Nano",
-      description: "GPT-5-Nano (medium reasoning)",
-      updateArgs: {
-        reasoning_effort: "medium",
-        verbosity: "medium",
-        context_window: 272000,
-        max_output_tokens: 128000,
-        parallel_tool_calls: true
-      }
-    },
     {
       id: "grok-4.5",
       handle: "xai/grok-4.5",
@@ -8014,18 +7832,6 @@ var models_default = {
         parallel_tool_calls: true
       }
     },
-    {
-      id: "deepseek-v4-pro",
-      handle: "openrouter/deepseek/deepseek-v4-pro",
-      label: "DeepSeek V4 Pro",
-      description: "DeepSeek's V4 Pro model",
-      updateArgs: {
-        context_window: 1048576,
-        max_output_tokens: 384000,
-        parallel_tool_calls: true
-      },
-      isFeatured: true
-    },
     {
       id: "glm-5.2",
       handle: "zai/glm-5.2",
@@ -8075,17 +7881,6 @@ var models_default = {
         parallel_tool_calls: true
       }
     },
-    {
-      id: "minimax-m2",
-      handle: "openrouter/minimax/minimax-m2",
-      label: "MiniMax M2",
-      description: "MiniMax's M2 model",
-      updateArgs: {
-        context_window: 160000,
-        max_output_tokens: 64000,
-        parallel_tool_calls: true
-      }
-    },
     {
       id: "kimi-k3",
       handle: "moonshot/kimi-k3",
@@ -8098,50 +7893,6 @@ var models_default = {
         parallel_tool_calls: true
       }
     },
-    {
-      id: "kimi-k3-openrouter",
-      handle: "openrouter/moonshotai/kimi-k3",
-      label: "Kimi K3",
-      description: "Moonshot AI's Kimi K3 model for long-context agentic coding and reasoning tasks",
-      updateArgs: {
-        context_window: 1048576,
-        max_output_tokens: 131072,
-        parallel_tool_calls: true
-      }
-    },
-    {
-      id: "kimi-k2.7",
-      handle: "openrouter/moonshotai/kimi-k2.7-code",
-      label: "Kimi K2.7 Code",
-      description: "Moonshot AI's coding-focused Kimi K2.7 model for long-context agentic programming tasks",
-      isFeatured: true,
-      updateArgs: {
-        context_window: 262144,
-        max_output_tokens: 16384,
-        parallel_tool_calls: true
-      }
-    },
-    {
-      id: "kimi-k2.6",
-      handle: "openrouter/moonshotai/kimi-k2.6",
-      label: "Kimi K2.6",
-      description: "Moonshot AI's next-gen multimodal coding and agent model",
-      updateArgs: {
-        context_window: 200000,
-        max_output_tokens: 64000,
-        parallel_tool_calls: true
-      }
-    },
-    {
-      id: "deepseek-chat-v3.1",
-      handle: "openrouter/deepseek/deepseek-chat-v3.1",
-      label: "DeepSeek Chat V3.1",
-      description: "DeepSeek V3.1 model",
-      updateArgs: {
-        context_window: 128000,
-        parallel_tool_calls: true
-      }
-    },
     {
       id: "gemini-3.1",
       handle: "google_ai/gemini-3.1-pro-preview",
@@ -8176,68 +7927,6 @@ var models_default = {
         temperature: 1,
         parallel_tool_calls: true
       }
-    },
-    {
-      id: "gemini-3.1-flash-lite",
-      handle: "google_ai/gemini-3.1-flash-lite",
-      label: "Gemini 3.1 Flash-Lite",
-      description: "Google's lightweight Gemini 3.1 Flash-Lite model",
-      updateArgs: {
-        context_window: 1048576,
-        temperature: 1,
-        parallel_tool_calls: true
-      }
-    },
-    {
-      id: "gpt-4.1",
-      handle: "openai/gpt-4.1",
-      label: "GPT-4.1",
-      description: "OpenAI's most recent non-reasoner model",
-      updateArgs: {
-        context_window: 1047576,
-        parallel_tool_calls: true
-      }
-    },
-    {
-      id: "gpt-4.1-mini",
-      handle: "openai/gpt-4.1-mini-2025-04-14",
-      label: "GPT-4.1-Mini",
-      description: "OpenAI's most recent non-reasoner model (mini version)",
-      updateArgs: {
-        context_window: 1047576,
-        parallel_tool_calls: true
-      }
-    },
-    {
-      id: "gpt-4.1-nano",
-      handle: "openai/gpt-4.1-nano-2025-04-14",
-      label: "GPT-4.1-Nano",
-      description: "OpenAI's most recent non-reasoner model (nano version)",
-      updateArgs: {
-        context_window: 1047576,
-        parallel_tool_calls: true
-      }
-    },
-    {
-      id: "o4-mini",
-      handle: "openai/o4-mini",
-      label: "o4-mini",
-      description: "OpenAI's latest o-series reasoning model",
-      updateArgs: {
-        context_window: 180000,
-        parallel_tool_calls: true
-      }
-    },
-    {
-      id: "gemini-3.1-vertex",
-      handle: "google_vertex/gemini-3.1-pro-preview",
-      label: "Gemini 3.1 Pro",
-      description: "Google's latest Gemini 3.1 Pro model (via Vertex AI)",
-      updateArgs: {
-        context_window: 180000,
-        temperature: 1,
-        parallel_tool_calls: true
-      }
     }
   ]
 };
@@ -8671,13 +8360,10 @@ function expandMcpToolWildcards(allowedTools, mcpTools) {
 }
 
 // src/remote-session-protocol.ts
-var FAILURE_STOP_REASONS = new Set([
-  "error",
-  "llm_api_error",
-  "max_steps",
-  "interrupted",
-  "cancelled",
-  "canceled"
+var SUCCESS_STOP_REASONS = new Set([
+  "end_turn",
+  "tool_rule",
+  "requires_approval"
 ]);
 var REASONING_EFFORTS = new Set([
   "none",
@@ -8725,6 +8411,9 @@ function toSdkErrorCode(value) {
     return;
   return KNOWN_SDK_ERROR_CODES.has(value) ? value : undefined;
 }
+function isFailureStopReason(value) {
+  return value != null && !SUCCESS_STOP_REASONS.has(value);
+}
 function isReasoningEffort(value) {
   return typeof value === "string" && REASONING_EFFORTS.has(value);
 }
@@ -8930,6 +8619,16 @@ function loopStatusRunIds(message) {
   const activeRunIds = loopStatusRecord(message)?.active_run_ids;
   return Array.isArray(activeRunIds) ? activeRunIds.filter((runId) => typeof runId === "string") : [];
 }
+function turnFinishedRecord(message) {
+  if (message.type !== "turn_finished" || typeof message.stop_reason !== "string") {
+    return null;
+  }
+  return {
+    ...typeof message.run_id === "string" ? { runId: message.run_id } : {},
+    stopReason: message.stop_reason,
+    ...typeof message.error === "string" ? { error: message.error } : {}
+  };
+}
 function queueItems(message) {
   const queue = message.queue;
   if (!Array.isArray(queue))
@@ -9087,6 +8786,8 @@ function turnSendOptions(turn) {
 }
 
 // src/remote-turn-coordinator.ts
+var MAX_RECENTLY_SETTLED_RUN_IDS = 256;
+
 class RemoteTurnCoordinator {
   label;
   requestTimeoutMs;
@@ -9096,6 +8797,7 @@ class RemoteTurnCoordinator {
   streamResolvers = [];
   activeTurn = null;
   pendingTurns = [];
+  settledRunIds = new Set;
   nextTurnId = 0;
   messageCounter = 0;
   clientMessageCounter = 0;
@@ -9173,6 +8875,11 @@ class RemoteTurnCoordinator {
       this.handleLoopStatusMessage(message);
       return;
     }
+    const finished = turnFinishedRecord(message);
+    if (finished) {
+      this.handleTurnFinished(finished);
+      return;
+    }
     const delta = streamDeltaRecord(message);
     if (!delta)
       return;
@@ -9203,15 +8910,18 @@ class RemoteTurnCoordinator {
       return;
     const active = this.activeTurn;
     if (active) {
-      this.failTurn(active, detail);
+      this.failTurn(active, detail, {
+        errorCode: "stream_closed",
+        recoverable: true
+      });
     } else {
       this.enqueue({
         type: "error",
         message: detail,
-        errorCode: "error",
-        stopReason: "error",
+        errorCode: "stream_closed",
+        stopReason: "stream_closed",
         errorDetail: detail,
-        recoverable: false
+        recoverable: true
       });
     }
     this.close();
@@ -9250,24 +8960,26 @@ class RemoteTurnCoordinator {
     this.activateTurn(next);
     return next;
   }
-  failTurn(turn, detail) {
+  failTurn(turn, detail, options = {}) {
     if (this.activeTurn !== turn)
       return;
+    const errorCode = options.errorCode ?? "error";
     this.enqueue({
       type: "error",
       message: detail,
-      errorCode: "error",
-      stopReason: "error",
+      errorCode,
+      stopReason: errorCode,
       errorDetail: detail,
-      recoverable: false
+      recoverable: options.recoverable ?? false
     });
     this.completeActiveTurn({
       runtime: turn.runtime,
-      stopReason: "error",
+      stopReason: errorCode,
       runIds: [...turn.runIds],
       success: false,
       detail,
-      errorCode: "error"
+      errorCode,
+      recoverable: options.recoverable
     });
   }
   completeActiveTurn(turn) {
@@ -9278,9 +8990,22 @@ class RemoteTurnCoordinator {
       clearTimeout(active.timeout);
       active.timeout = null;
     }
+    this.rememberSettledRunIds(active.runIds);
     this.enqueue(this.resultFromTurn(turn, active));
     this.activeTurn = null;
   }
+  rememberSettledRunIds(runIds) {
+    for (const runId of runIds) {
+      if (!runId || this.settledRunIds.has(runId))
+        continue;
+      this.settledRunIds.add(runId);
+      if (this.settledRunIds.size > MAX_RECENTLY_SETTLED_RUN_IDS) {
+        const expired = this.settledRunIds.values().next().value;
+        if (expired)
+          this.settledRunIds.delete(expired);
+      }
+    }
+  }
   handleLoopStatusMessage(message) {
     const status = loopStatusValue(message);
     if (!status)
@@ -9329,6 +9054,38 @@ class RemoteTurnCoordinator {
       });
     }
   }
+  handleTurnFinished(finished) {
+    const active = this.activeTurn;
+    if (!active || !finished.runId)
+      return;
+    if (this.settledRunIds.has(finished.runId))
+      return;
+    if (active.runIds.size > 0 && !active.runIds.has(finished.runId)) {
+      return;
+    }
+    active.runIds.add(finished.runId);
+    if (finished.stopReason === "requires_approval") {
+      active.observedRequiresApprovalStop = true;
+      if (!this.autoHandlesToolApprovals) {
+        this.completeActiveTurn({
+          runtime: active.runtime,
+          stopReason: finished.stopReason,
+          runIds: [...active.runIds]
+        });
+      }
+      return;
+    }
+    const errorCode = toSdkErrorCode(finished.stopReason);
+    const success = !isFailureStopReason(finished.stopReason);
+    this.completeActiveTurn({
+      runtime: active.runtime,
+      stopReason: finished.stopReason,
+      runIds: [...active.runIds],
+      success,
+      ...success ? {} : { errorCode: errorCode ?? "error" },
+      ...finished.error ? { detail: finished.error } : {}
+    });
+  }
   handleTurnTerminalDelta(delta, sdkMessage) {
     const active = this.activeTurn;
     if (!active)
@@ -9482,7 +9239,7 @@ class RemoteTurnCoordinator {
       detail: turn.detail,
       stopReason
     });
-    const success = turn.success !== undefined ? turn.success && !approvalConflict && !FAILURE_STOP_REASONS.has(stopReason ?? "") : !approvalConflict && !FAILURE_STOP_REASONS.has(stopReason ?? "");
+    const success = turn.success !== undefined ? turn.success && !approvalConflict && !isFailureStopReason(stopReason) : !approvalConflict && !isFailureStopReason(stopReason);
     const errorCode = approvalConflict ? "approval_conflict" : turn.errorCode ?? toSdkErrorCode(stopReason);
     return {
       type: "result",
@@ -9491,7 +9248,7 @@ class RemoteTurnCoordinator {
       error: success ? undefined : errorCode ?? stopReason ?? "error",
       errorCode: success ? undefined : errorCode ?? "error",
       approvalConflict: approvalConflict || undefined,
-      recoverable: approvalConflict ? true : success ? undefined : false,
+      recoverable: approvalConflict ? true : success ? undefined : turn.recoverable ?? false,
       errorDetail: success ? undefined : turn.detail,
       stopReason,
       durationMs: Date.now() - (tracker?.startedAt || this._activeTurnStartedAt),
@@ -13074,25 +12831,43 @@ var __getProtoOf2 = Object.getPrototypeOf;
 var __defProp2 = Object.defineProperty;
 var __getOwnPropNames2 = Object.getOwnPropertyNames;
 var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM2 = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached2 = cache.get(mod);
+    if (cached2)
+      return cached2;
+  }
   target = mod != null ? __create2(__getProtoOf2(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames2(mod))
     if (!__hasOwnProp2.call(to, key))
       __defProp2(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp2(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __require2 = /* @__PURE__ */ createRequire3(import.meta.url);
@@ -19311,7 +19086,7 @@ var require_formats = __commonJS((exports) => {
   }
   var TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
   function getTime(strictTimeZone) {
-    return function time(str) {
+    return function time3(str) {
       const matches = TIME.exec(str);
       if (!matches)
         return false;
@@ -29674,7 +29449,7 @@ class StreamableHTTPClientTransport {
 }
 var DEFAULT_CLIENT_INFO = {
   name: "letta-code",
-  version: "0.30.11"
+  version: "0.30.28"
 };
 async function connectMcpServer(config2, options = {}) {
   let client = new Client(options.clientInfo ?? DEFAULT_CLIENT_INFO);
@@ -30607,4 +30382,4 @@ export {
   CloudManagedSandboxExpiredError
 };
 
-//# debugId=45035C35D5C51AFA64756E2164756E21
+//# debugId=DA5298CCD75BD69B64756E2164756E21