@letta-ai/letta-code 0.30.2 → 0.30.4

package/dist/types/agent/approval-execution.d.ts

@@ -0,0 +1,92 @@
+import type { ApprovalReturn, ToolReturn } from "@letta-ai/letta-client/resources/agents/messages";
+import type { ToolReturnMessage } from "@letta-ai/letta-client/resources/tools";
+import type { ChannelTurnSource } from "../channels/types";
+import type { ApprovalRequest } from "../cli/helpers/stream";
+import { type ToolExecutionResult, type ToolReturnContent } from "../tools/manager";
+/**
+ * Extract displayable text from tool return content (for UI display).
+ * Multimodal content returns the text parts concatenated.
+ */
+export declare function getDisplayableToolReturn(content: ToolReturnContent): string;
+/**
+ * Extract the resource key for a tool execution.
+ * Tools with the same resource key must be serialized to avoid race conditions.
+ *
+ * Note: Only call this for non-parallel-safe tools. Use isParallelSafe() first.
+ *
+ * @param toolName - The name of the tool being executed
+ * @param toolArgs - The arguments passed to the tool
+ * @returns Resource key string for grouping
+ */
+export declare function getResourceKey(toolName: string, toolArgs: Record<string, unknown>, workingDirectory?: string): string;
+/** Result format expected by App.tsx for auto-allowed tools */
+export type AutoAllowedResult = {
+    toolCallId: string;
+    result: ToolExecutionResult;
+};
+export type ApprovalDecision = {
+    type: "approve";
+    approval: ApprovalRequest;
+    reason?: string;
+    precomputedResult?: ToolExecutionResult;
+} | {
+    type: "deny";
+    approval: ApprovalRequest;
+    reason: string;
+};
+export type ApprovalToolResult = ToolReturn & {
+    reason?: string;
+};
+export type ApprovalResult = ApprovalToolResult | ApprovalReturn;
+/**
+ * Execute a batch of approval decisions and format results for the backend.
+ *
+ * This function handles:
+ * - Executing approved tools (with error handling)
+ * - Formatting denials
+ * - Combining all results into a single batch
+ *
+ * Execution strategy for performance:
+ * - Parallel-safe tools (read-only + Task) are executed in parallel
+ * - Write tools are grouped by resource (file path) and executed with per-resource queuing:
+ *   - Different resources → parallel execution
+ *   - Same resource → sequential execution to avoid race conditions
+ *
+ * Used by both interactive (App.tsx) and headless (headless.ts) modes.
+ *
+ * @param decisions - Array of approve/deny decisions for each tool
+ * @param onChunk - Optional callback to update UI with tool results (for interactive mode)
+ * @returns Array of formatted results ready to send to backend (maintains original order)
+ */
+export declare function executeApprovalBatch(decisions: ApprovalDecision[], onChunk?: (chunk: ToolReturnMessage) => void, options?: {
+    abortSignal?: AbortSignal;
+    onStreamingOutput?: (toolCallId: string, chunk: string, isStderr?: boolean) => void;
+    toolContextId?: string;
+    workingDirectory?: string;
+    parentScope?: {
+        agentId: string;
+        conversationId: string;
+    };
+    channelTurnSources?: ChannelTurnSource[];
+    onFileWrite?: (filePath: string, content: string) => void;
+}): Promise<ApprovalResult[]>;
+/**
+ * Helper to execute auto-allowed tools and map results to the format expected by App.tsx.
+ * Consolidates the common pattern of converting approvals to decisions, executing them,
+ * and mapping the results back.
+ *
+ * @param autoAllowed - Array of auto-allowed approval contexts (must have .approval property)
+ * @param onChunk - Callback to update UI with tool results
+ * @param options - Optional abort signal for cancellation
+ * @returns Array of results with toolCallId and ToolExecutionResult
+ */
+export declare function executeAutoAllowedTools(autoAllowed: Array<{
+    approval: ApprovalRequest;
+}>, onChunk: (chunk: ToolReturnMessage) => void, options?: {
+    abortSignal?: AbortSignal;
+    onStreamingOutput?: (toolCallId: string, chunk: string, isStderr?: boolean) => void;
+    toolContextId?: string;
+    workingDirectory?: string;
+    onFileWrite?: (filePath: string, content: string) => void;
+}): Promise<AutoAllowedResult[]>;
+//# sourceMappingURL=approval-execution.d.ts.map

package/dist/types/agent/approval-execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval-execution.d.ts","sourceRoot":"","sources":["../../../src/agent/approval-execution.ts"],"names":[],"mappings":"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"}

package/dist/types/agent/approval-result-normalization.d.ts

@@ -0,0 +1,20 @@
+import type { MessageCreate } from "@letta-ai/letta-client/resources/agents/agents";
+import type { ApprovalCreate } from "@letta-ai/letta-client/resources/agents/messages";
+import type { ApprovalResult } from "./approval-execution";
+type OutgoingMessage = MessageCreate | ApprovalCreate;
+export type ApprovalNormalizationOptions = {
+    /**
+     * Structured interrupt provenance: tool_call_ids known to have been interrupted.
+     * When provided, these IDs are forced to persist as status=error.
+     */
+    interruptedToolCallIds?: Iterable<string>;
+    /**
+     * Temporary fallback guard for legacy drift where tool_return text is the only
+     * interrupt signal. Keep false by default for strict structured behavior.
+     */
+    allowInterruptTextFallback?: boolean;
+};
+export declare function normalizeApprovalResultsForPersistence(approvals: ApprovalResult[] | null | undefined, options?: ApprovalNormalizationOptions): ApprovalResult[];
+export declare function normalizeOutgoingApprovalMessages(messages: OutgoingMessage[], options?: ApprovalNormalizationOptions): OutgoingMessage[];
+export {};
+//# sourceMappingURL=approval-result-normalization.d.ts.map

package/dist/types/agent/approval-result-normalization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval-result-normalization.d.ts","sourceRoot":"","sources":["../../../src/agent/approval-result-normalization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gDAAgD,CAAC;AACpF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kDAAkD,CAAC;AAGvF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,KAAK,eAAe,GAAG,aAAa,GAAG,cAAc,CAAC;AAKtD,MAAM,MAAM,4BAA4B,GAAG;IACzC;;;OAGG;IACH,sBAAsB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC1C;;;OAGG;IACH,0BAA0B,CAAC,EAAE,OAAO,CAAC;CACtC,CAAC;AAoFF,wBAAgB,sCAAsC,CACpD,SAAS,EAAE,cAAc,EAAE,GAAG,IAAI,GAAG,SAAS,EAC9C,OAAO,GAAE,4BAAiC,GACzC,cAAc,EAAE,CAuFlB;AAED,wBAAgB,iCAAiC,CAC/C,QAAQ,EAAE,eAAe,EAAE,EAC3B,OAAO,GAAE,4BAAiC,GACzC,eAAe,EAAE,CAwBnB"}

package/dist/types/agent/available-models.d.ts

@@ -0,0 +1,65 @@
+import type { ModelReasoningEffort } from "./model";
+export type AvailableModel = {
+    handle: string;
+    label: string;
+    maxContextWindow?: number;
+    maxOutputTokens?: number;
+    providerType?: string;
+    providerCategory?: string;
+    modelEndpoint?: string;
+    openAICompatibleProxy?: boolean;
+};
+export type ReasoningCapabilities = {
+    supported_efforts?: ModelReasoningEffort[] | null;
+    mandatory?: boolean;
+};
+export type AvailableModelHandlesResult = {
+    handles: Set<string>;
+    providerTypes: Map<string, string>;
+    openAICompatibleProxyHandles: Set<string>;
+    models: AvailableModel[];
+    source: "cache" | "network";
+    fetchedAt: number;
+};
+export declare function clearAvailableModelsCache(): void;
+export declare function getAvailableModelsCacheInfo(): {
+    hasCache: boolean;
+    isFresh: boolean;
+    fetchedAt: number | null;
+    ageMs: number | null;
+    ttlMs: number;
+};
+/**
+ * Return cached model handles if available.
+ * Used by UI components to bootstrap from cache without showing a loading flash.
+ */
+export declare function getCachedModelHandles(): Set<string> | null;
+/**
+ * Return cached provider_type metadata by handle if available.
+ * Used to carry backend model-catalog provider identity through selection
+ * without re-listing models during model update mutations.
+ */
+export declare function getCachedModelProviderTypes(): Map<string, string> | null;
+export declare function getCachedModelReasoningCapabilities(): Map<string, ReasoningCapabilities> | null;
+export declare function getCachedOpenAICompatibleProxyHandles(): Set<string> | null;
+export declare function getCachedAvailableModels(): AvailableModel[] | null;
+export declare function getAvailableModelHandles(options?: {
+    forceRefresh?: boolean;
+}): Promise<AvailableModelHandlesResult>;
+/**
+ * Best-effort prefetch to warm the cache (no throw).
+ * This is intentionally fire-and-forget.
+ */
+export declare function prefetchAvailableModelHandles(): void;
+/**
+ * Get the max_context_window for a model handle from the API.
+ * Ensures the cache is populated before reading.
+ * Returns undefined if handle not found in the API response.
+ */
+export declare function getModelContextWindow(handle: string): Promise<number | undefined>;
+/**
+ * Get provider_type metadata for a model handle from the cached API model list.
+ * Ensures the shared cache is populated before reading.
+ */
+export declare function getModelProviderType(handle: string): Promise<string | undefined>;
+//# sourceMappingURL=available-models.d.ts.map

package/dist/types/agent/available-models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"available-models.d.ts","sourceRoot":"","sources":["../../../src/agent/available-models.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAIpD,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,iBAAiB,CAAC,EAAE,oBAAoB,EAAE,GAAG,IAAI,CAAC;IAClD,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAuBF,MAAM,MAAM,2BAA2B,GAAG;IACxC,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACrB,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,4BAA4B,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC1C,MAAM,EAAE,cAAc,EAAE,CAAC;IACzB,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,wBAAgB,yBAAyB,SAIxC;AAED,wBAAgB,2BAA2B,IAAI;IAC7C,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;CACf,CASA;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAK1D;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAKxE;AAED,wBAAgB,mCAAmC,IAAI,GAAG,CACxD,MAAM,EACN,qBAAqB,CACtB,GAAG,IAAI,CAKP;AAED,wBAAgB,qCAAqC,IAAI,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAE1E;AAED,wBAAgB,wBAAwB,IAAI,cAAc,EAAE,GAAG,IAAI,CAElE;AAoHD,wBAAsB,wBAAwB,CAAC,OAAO,CAAC,EAAE;IACvD,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,GAAG,OAAO,CAAC,2BAA2B,CAAC,CA8DvC;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,IAAI,IAAI,CAIpD;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAK7B;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAK7B"}

package/dist/types/agent/client-skills.d.ts

@@ -0,0 +1,55 @@
+import type { MessageCreateParams as ConversationMessageCreateParams } from "@letta-ai/letta-client/resources/conversations/messages";
+import { discoverSkills, type SkillDiscoveryError, type SkillDiscoveryResult, type SkillSource } from "./skills";
+/**
+ * Invalidate the entire client skills payload cache.
+ *
+ * Useful when the process-wide skill configuration changes
+ * (e.g. cwd switch, env var change, or global skill source update).
+ */
+export declare function invalidateClientSkillsPayloadCache(): void;
+/**
+ * Invalidate cache entries for a specific agent.
+ *
+ * Useful when an agent's memory skills are updated (e.g. skill
+ * creation/deletion via the Skill tool) and the next
+ * `sendMessageStream` call must re-discover.
+ */
+export declare function invalidateClientSkillsPayloadCacheForAgent(agentId: string): void;
+export type ClientSkill = NonNullable<ConversationMessageCreateParams["client_skills"]>[number];
+export interface BuildClientSkillsPayloadOptions {
+    agentId?: string;
+    skillsDirectory?: string | null;
+    skillSources?: SkillSource[];
+    discoverSkillsFn?: typeof discoverSkills;
+    logger?: (message: string) => void;
+}
+export interface BuildClientSkillsPayloadResult {
+    clientSkills: NonNullable<ConversationMessageCreateParams["client_skills"]>;
+    skillPathById: Record<string, string>;
+    errors: SkillDiscoveryError[];
+}
+export interface DiscoverClientSideSkillsOptions {
+    agentId?: string;
+    skillsDirectory?: string | null;
+    skillSources?: SkillSource[];
+    discoverSkillsFn?: typeof discoverSkills;
+}
+/**
+ * Discover all client-side skills from the same roots used for `client_skills`.
+ * This intentionally returns both model-invocable and manual-only skills; callers
+ * decide whether to filter for model invocation or slash-command invocation.
+ */
+export declare function discoverClientSideSkills(options?: DiscoverClientSideSkillsOptions): Promise<SkillDiscoveryResult>;
+/**
+ * Build `client_skills` payload for conversations.messages.create.
+ *
+ * This discovers client-side skills using the same source selection rules as the
+ * Skill tool and headless startup flow, then converts them into the server-facing
+ * schema expected by the API. Ordering is deterministic by skill id.
+ *
+ * Results are cached in-memory keyed by agent id, skill sources, cwd, and
+ * resolved skill roots so that repeated calls (e.g. during approval
+ * continuations) skip redundant filesystem discovery.
+ */
+export declare function buildClientSkillsPayload(options?: BuildClientSkillsPayloadOptions): Promise<BuildClientSkillsPayloadResult>;
+//# sourceMappingURL=client-skills.d.ts.map

package/dist/types/agent/client-skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-skills.d.ts","sourceRoot":"","sources":["../../../src/agent/client-skills.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,IAAI,+BAA+B,EAAE,MAAM,yDAAyD,CAAC;AAGtI,OAAO,EAEL,cAAc,EAQd,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,WAAW,EACjB,MAAM,UAAU,CAAC;AAoLlB;;;;;GAKG;AACH,wBAAgB,kCAAkC,IAAI,IAAI,CAEzD;AAED;;;;;;GAMG;AACH,wBAAgB,0CAA0C,CACxD,OAAO,EAAE,MAAM,GACd,IAAI,CASN;AAwED,MAAM,MAAM,WAAW,GAAG,WAAW,CACnC,+BAA+B,CAAC,eAAe,CAAC,CACjD,CAAC,MAAM,CAAC,CAAC;AAEV,MAAM,WAAW,+BAA+B;IAC9C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,YAAY,CAAC,EAAE,WAAW,EAAE,CAAC;IAC7B,gBAAgB,CAAC,EAAE,OAAO,cAAc,CAAC;IACzC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACpC;AAED,MAAM,WAAW,8BAA8B;IAC7C,YAAY,EAAE,WAAW,CAAC,+BAA+B,CAAC,eAAe,CAAC,CAAC,CAAC;IAC5E,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,MAAM,EAAE,mBAAmB,EAAE,CAAC;CAC/B;AAgCD,MAAM,WAAW,+BAA+B;IAC9C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,YAAY,CAAC,EAAE,WAAW,EAAE,CAAC;IAC7B,gBAAgB,CAAC,EAAE,OAAO,cAAc,CAAC;CAC1C;AA0FD;;;;GAIG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,GAAE,+BAAoC,GAC5C,OAAO,CAAC,oBAAoB,CAAC,CAS/B;AAMD;;;;;;;;;;GAUG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,GAAE,+BAAoC,GAC5C,OAAO,CAAC,8BAA8B,CAAC,CA0EzC"}

package/dist/types/agent/context.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Agent context module - provides global access to current agent state
+ * This allows tools to access the current agent ID without threading it through params.
+ */
+import type { SkillSource } from "./skills";
+/**
+ * Set the current agent context
+ * @param agentId - The agent ID
+ * @param skillsDirectory - Optional skills directory path
+ * @param skillSources - Enabled skill sources for this session
+ * @param agentName - Optional display name for shell/process identity
+ */
+export declare function setAgentContext(agentId: string, skillsDirectory?: string, skillSources?: SkillSource[], agentName?: string | null): void;
+/**
+ * Set the current agent ID in context (simplified version for compatibility)
+ */
+export declare function setCurrentAgentId(agentId: string | null): void;
+/**
+ * Set the current agent name in context when it is available.
+ */
+export declare function setCurrentAgentName(agentName: string | null): void;
+/**
+ * Get the current agent ID
+ * @throws Error if no agent context is set
+ */
+export declare function getCurrentAgentId(): string;
+/**
+ * Get the current agent name if runtime context has it.
+ */
+export declare function getCurrentAgentName(): string | null;
+/**
+ * Get the skills directory path
+ * @returns The skills directory path or null if not set
+ */
+export declare function getSkillsDirectory(): string | null;
+/**
+ * Get enabled skill sources for discovery/injection.
+ */
+export declare function getSkillSources(): SkillSource[];
+/**
+ * Set the current conversation ID
+ * @param conversationId - The conversation ID, or null to clear
+ */
+export declare function setConversationId(conversationId: string | null): void;
+/**
+ * Get the current conversation ID
+ * @returns The conversation ID or null if not set
+ */
+export declare function getConversationId(): string | null;
+//# sourceMappingURL=context.d.ts.map

package/dist/types/agent/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/agent/context.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAkC5C;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,eAAe,CAAC,EAAE,MAAM,EACxB,YAAY,CAAC,EAAE,WAAW,EAAE,EAC5B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,GACxB,IAAI,CAeN;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAY9D;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAKlE;AASD;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAY1C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,GAAG,IAAI,CAOnD;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,GAAG,IAAI,CAMlD;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,WAAW,EAAE,CAM/C;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAKrE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,GAAG,IAAI,CAMjD"}

package/dist/types/agent/memory-filesystem.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Memory filesystem helpers.
+ *
+ * With git-backed memory, most sync/hash logic is removed.
+ * This module retains: directory helpers, tree rendering, and
+ * the shared memfs initialization logic used by both interactive
+ * and headless code paths.
+ */
+import type { AgentState } from "@letta-ai/letta-client/resources/agents/agents";
+import type { Backend } from "../backend";
+export declare const MEMORY_FS_ROOT = ".letta";
+export declare const MEMORY_FS_AGENTS_DIR = "agents";
+export declare const MEMORY_FS_MEMORY_DIR = "memory";
+export declare const MEMORY_SYSTEM_DIR = "system";
+export declare const MEMORY_TREE_MAX_LINES: 500;
+export declare const MEMORY_TREE_MAX_CHARS: 20000;
+export declare const MEMORY_TREE_MAX_CHILDREN_PER_DIR: 50;
+export interface MemoryTreeRenderOptions {
+    maxLines?: number;
+    maxChars?: number;
+    maxChildrenPerDir?: number;
+}
+export declare function getMemoryFilesystemRoot(agentId: string, homeDir?: string): string;
+export declare function getMemorySystemDir(agentId: string, homeDir?: string): string;
+export declare function getScopedMemoryFilesystemRoot(agentId: string, options?: {
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+    localBackendStorageDir?: string;
+}): string;
+export interface ResolveScopedMemoryDirOptions {
+    agentId?: string | null;
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+}
+/**
+ * Resolve the active memory directory for the current execution scope.
+ *
+ * Precedence is intentionally runtime-first:
+ * 1. Explicit agent ID (caller-provided scope)
+ * 2. In-process runtime/agent context
+ * 3. Explicit MEMORY_DIR env fallback
+ * 4. AGENT_ID env fallback
+ */
+export declare function resolveScopedMemoryDir(options?: ResolveScopedMemoryDirOptions): string | null;
+export declare function ensureMemoryFilesystemDirs(agentId: string, homeDir?: string): void;
+export interface MemfsCreateBodyLike {
+    tags?: string[] | null;
+}
+/**
+ * Stamp the git-memory-enabled tag onto a create-agent body (pure helper).
+ * Returns the body unchanged when the tag is already present.
+ */
+export declare function stampMemfsTagOnCreateBody<T extends MemfsCreateBodyLike>(body: T, gitMemoryEnabledTag: string): T;
+/**
+ * Prepare a raw (protocol-forwarded) create-agent body so the created agent
+ * is memfs-enabled from birth.
+ *
+ * Raw protocol paths (listener `agent_create` / `runtime_start.create_agent`)
+ * forward client-provided bodies directly to the backend. Without this,
+ * agents created on Letta Cloud are born without GIT_MEMORY_ENABLED_TAG and
+ * every downstream tag-based check (isMemfsEnabledOnServer, memfs-sync,
+ * hydrateMemfsSettingFromAgent) treats them as non-memfs — on every machine,
+ * forever. Stamping the tag atomically with creation guarantees lazy sync
+ * paths can finish the setup (clone, tool detach) even if this process dies.
+ *
+ * The local backend stamps the tag itself in LocalBackend.createAgent(), and
+ * non-cloud remote backends don't support memfs sync, so both pass through.
+ */
+export declare function prepareRawCreateAgentBodyForMemfs<T extends MemfsCreateBodyLike>(body: T): Promise<T>;
+export declare function hydrateMemfsSettingFromAgent(agent: Pick<AgentState, "id" | "tags">): Promise<boolean>;
+/**
+ * Returns whether memfs is enabled for the agent on the server.
+ *
+ * This is a read-only check used by desktop/listener surfaces that need to
+ * distinguish "memfs disabled" from "enabled but local checkout missing"
+ * without mutating agent configuration.
+ */
+export declare function isMemfsEnabledOnServer(agentId: string): Promise<boolean>;
+export interface EnsureLocalMemfsCheckoutOptions {
+    pullOnExistingRepo?: boolean;
+}
+/**
+ * Ensures the local memfs checkout exists for an already-enabled agent.
+ *
+ * Unlike applyMemfsFlags(), this helper does not update prompts, tags, tools,
+ * or other agent configuration. It materializes the local git checkout when
+ * missing and can optionally pull an existing remote-backed repo before use.
+ */
+export declare function ensureLocalMemfsCheckout(agentId: string, options?: EnsureLocalMemfsCheckoutOptions): Promise<void>;
+export declare function labelFromRelativePath(relativePath: string): string;
+/**
+ * Render a tree visualization of the memory filesystem.
+ * Takes system labels (under system/) and detached labels (at root).
+ */
+export declare function renderMemoryFilesystemTree(systemLabels: string[], detachedLabels: string[], options?: MemoryTreeRenderOptions): string;
+export interface ApplyMemfsFlagsResult {
+    /** Whether memfs was enabled or unchanged */
+    action: "enabled" | "unchanged";
+    /** Path to the memory directory (when enabled) */
+    memoryDir?: string;
+    /** Summary from git pull (when pullOnExistingRepo is true and repo already existed) */
+    pullSummary?: string;
+}
+export interface ApplyMemfsFlagsOptions {
+    pullOnExistingRepo?: boolean;
+    agentTags?: string[];
+    /** Skip the system prompt update (when the agent was created with the correct mode). */
+    skipPromptUpdate?: boolean;
+}
+/**
+ * Apply the --memfs CLI flag (or /memfs enable) to an agent.
+ *
+ * Shared between interactive (index.ts), headless (headless.ts), and
+ * the /memfs enable command (App.tsx) to avoid duplicating the setup logic.
+ *
+ * MemFS cannot be disabled: agents are memfs-enabled from creation on
+ * memfs-capable backends, and this function only enables or syncs.
+ *
+ * Steps when enabling:
+ *   1. Validate MemFS API endpoint support (for explicit enable)
+ *   2. Reconcile system prompt to the memfs memory mode
+ *   3. Persist memfs setting locally
+ *   4. Detach old API-based memory tools
+ *   5. Add git-memory-enabled tag + clone/pull repo
+ *
+ * @throws {Error} if MemFS endpoint validation fails or git setup fails
+ */
+export declare function applyMemfsFlags(agentId: string, memfsFlag: boolean | undefined, options?: ApplyMemfsFlagsOptions): Promise<ApplyMemfsFlagsResult>;
+/**
+ * Whether the current server is the Letta API (or local memfs testing is enabled).
+ */
+export declare function isLettaCloud(): Promise<boolean>;
+/**
+ * Whether the MemFS sync endpoint is backed by the Letta API.
+ */
+export declare function isLettaMemfsServer(): Promise<boolean>;
+/**
+ * Enable memfs for a newly created agent if on the Letta API.
+ * Non-fatal: logs a warning on failure. Skips on self-hosted.
+ *
+ * Skips the system prompt update since callers are expected to create
+ * the agent with the correct memory mode upfront.
+ */
+export interface EnableMemfsIfCloudOptions {
+    backend?: Backend;
+    agentTags?: string[] | null;
+}
+export declare function enableMemfsIfCloud(agentId: string, options?: EnableMemfsIfCloudOptions): Promise<void>;
+//# sourceMappingURL=memory-filesystem.d.ts.map

package/dist/types/agent/memory-filesystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-filesystem.d.ts","sourceRoot":"","sources":["../../../src/agent/memory-filesystem.ts"],"names":[],"mappings":"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"}

package/dist/types/agent/memory-git-config-lock.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Serialization for `.git/config` mutations on the memory repo.
+ *
+ * `git config` takes an exclusive `.git/config.lock` for its whole
+ * read-modify-write and exits non-zero rather than waiting, so two config
+ * mutations against one repo cannot overlap. Memory-repo bootstrap has several
+ * independent config writers — identity reconciliation, git-ops preparation,
+ * and the credential helper — so contention is ordinary rather than
+ * exceptional, and must not surface as a fatal error.
+ *
+ * Serializing removes the contention this process causes itself; the retry
+ * covers writers it does not control (a second harness on the same agent, a
+ * commit hook, or the operator's own git).
+ */
+/** Returns true when a git error is `.git/config` lock contention. */
+export declare function isGitConfigLockError(error: unknown): boolean;
+/**
+ * Run `mutate` serialized against other config mutations of the same repo,
+ * retrying while the config lock is held.
+ *
+ * `mutate` performs the git invocation; it is supplied by the caller so this
+ * module stays free of the git runner (and of a cycle back to memory-git).
+ * It may be invoked more than once, so it must be idempotent — every current
+ * caller is a plain `git config` set/unset.
+ */
+export declare function withSerializedGitConfigMutation(dir: string, mutate: () => Promise<unknown>): Promise<void>;
+//# sourceMappingURL=memory-git-config-lock.d.ts.map

package/dist/types/agent/memory-git-config-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-git-config-lock.d.ts","sourceRoot":"","sources":["../../../src/agent/memory-git-config-lock.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAcH,sEAAsE;AACtE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAG5D;AASD;;;;;;;;GAQG;AACH,wBAAsB,+BAA+B,CACnD,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAC7B,OAAO,CAAC,IAAI,CAAC,CAkBf"}

package/dist/types/agent/memory-git-hooks.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Git hook scripts installed into memfs memory repos.
+ *
+ * The pre-commit hook validates memory markdown frontmatter; the post-commit
+ * hook mirrors commits to an optional user-configured memory-repository
+ * remote. Both are (re)installed by the CLI harness on clone/pull/init —
+ * see memory-git.ts.
+ */
+/**
+ * Bash pre-commit hook that validates frontmatter in memory .md files.
+ *
+ * Rules:
+ * - Frontmatter is REQUIRED (must start with ---)
+ * - Must be properly closed with ---
+ * - Required fields: description (non-empty string)
+ * - read_only is a PROTECTED field: agent cannot add, remove, or change it.
+ *   Files where HEAD has read_only: true cannot be modified at all.
+ * - Only allowed agent-editable key: description
+ * - Legacy key 'limit' is tolerated for backward compatibility
+ * - read_only may exist (from server) but agent must not change it
+ */
+export declare const PRE_COMMIT_HOOK_SCRIPT = "#!/usr/bin/env bash\n# Validate frontmatter in staged memory .md files\n# Installed by Letta Code CLI\n\nAGENT_EDITABLE_KEYS=\"description\"\nPROTECTED_KEYS=\"read_only\"\nALL_KNOWN_KEYS=\"description read_only limit\"\nerrors=\"\"\n\n# Skills must always be directories: skills/<name>/SKILL.md\n# Reject legacy flat skill files (both current and legacy repo layouts).\nfor file in $(git diff --cached --name-only --diff-filter=ACMR | grep -E '^(memory/)?skills/[^/]+\\.md$' || true); do\n  errors=\"$errors\\n  $file: invalid skill path (skills must be folders). Use skills/<name>/SKILL.md\"\ndone\n\n# Helper: extract a frontmatter value from content\nget_fm_value() {\n  local content=\"$1\" key=\"$2\"\n  local closing_line\n  closing_line=$(echo \"$content\" | tail -n +2 | grep -n '^---$' | head -1 | cut -d: -f1)\n  [ -z \"$closing_line\" ] && return\n  echo \"$content\" | tail -n +2 | head -n $((closing_line - 1)) | grep \"^$key:\" | cut -d: -f2- | sed 's/^ *//;s/ *$//'\n}\n\n# Match .md files under system/ or reference/ (with optional memory/ prefix).\n# Skip skill SKILL.md files \u2014 they use a different frontmatter format.\nfor file in $(git diff --cached --name-only --diff-filter=ACM | grep -E '^(memory/)?(system|reference)/.*\\.md$'); do\n  staged=$(git show \":$file\")\n\n  # Frontmatter is required\n  first_line=$(echo \"$staged\" | head -1)\n  if [ \"$first_line\" != \"---\" ]; then\n    errors=\"$errors\\n  $file: missing frontmatter (must start with ---)\"\n    continue\n  fi\n\n  # Check frontmatter is properly closed\n  closing_line=$(echo \"$staged\" | tail -n +2 | grep -n '^---$' | head -1 | cut -d: -f1)\n  if [ -z \"$closing_line\" ]; then\n    errors=\"$errors\\n  $file: frontmatter opened but never closed (missing closing ---)\"\n    continue\n  fi\n\n  # Check read_only protection against HEAD version\n  head_content=$(git show \"HEAD:$file\" 2>/dev/null || true)\n  if [ -n \"$head_content\" ]; then\n    head_ro=$(get_fm_value \"$head_content\" \"read_only\")\n    if [ \"$head_ro\" = \"true\" ]; then\n      errors=\"$errors\\n  $file: file is read_only and cannot be modified\"\n      continue\n    fi\n  fi\n\n  # Extract frontmatter lines\n  frontmatter=$(echo \"$staged\" | tail -n +2 | head -n $((closing_line - 1)))\n\n  # Track required fields\n  has_description=false\n\n  # Validate each line\n  while IFS= read -r line; do\n    [ -z \"$line\" ] && continue\n    # Skip YAML multiline continuation lines (indented lines that continue a previous value)\n    case \"$line\" in\n      \" \"*|$'\t'*) continue ;;\n    esac\n\n    key=$(echo \"$line\" | cut -d: -f1 | tr -d ' ')\n    value=$(echo \"$line\" | cut -d: -f2- | sed 's/^ *//;s/ *$//')\n\n    # Check key is known\n    known=false\n    for k in $ALL_KNOWN_KEYS; do\n      if [ \"$key\" = \"$k\" ]; then\n        known=true\n        break\n      fi\n    done\n    if [ \"$known\" = \"false\" ]; then\n      errors=\"$errors\\n  $file: unknown frontmatter key '$key' (allowed: $ALL_KNOWN_KEYS)\"\n      continue\n    fi\n\n    # Check if agent is trying to modify a protected key\n    for k in $PROTECTED_KEYS; do\n      if [ \"$key\" = \"$k\" ]; then\n        # Compare against HEAD \u2014 if value changed (or key was added), reject\n        if [ -n \"$head_content\" ]; then\n          head_val=$(get_fm_value \"$head_content\" \"$key\")\n          if [ \"$value\" != \"$head_val\" ]; then\n            errors=\"$errors\\n  $file: '$key' is a protected field and cannot be changed by the agent\"\n          fi\n        else\n          # New file with read_only \u2014 agent shouldn't set this\n          errors=\"$errors\\n  $file: '$key' is a protected field and cannot be set by the agent\"\n        fi\n      fi\n    done\n\n    # Validate value types\n    case \"$key\" in\n      limit)\n        # Legacy field accepted for backward compatibility.\n        ;;\n      description)\n        has_description=true\n        if [ -z \"$value\" ]; then\n          errors=\"$errors\\n  $file: 'description' must not be empty\"\n        fi\n        ;;\n    esac\n  done <<< \"$frontmatter\"\n\n  # Check required fields\n  if [ \"$has_description\" = \"false\" ]; then\n    errors=\"$errors\\n  $file: missing required field 'description'\"\n  fi\n\n  # Check if protected keys were removed (existed in HEAD but not in staged)\n  if [ -n \"$head_content\" ]; then\n    for k in $PROTECTED_KEYS; do\n      head_val=$(get_fm_value \"$head_content\" \"$k\")\n      if [ -n \"$head_val\" ]; then\n        staged_val=$(get_fm_value \"$staged\" \"$k\")\n        if [ -z \"$staged_val\" ]; then\n          errors=\"$errors\\n  $file: '$k' is a protected field and cannot be removed by the agent\"\n        fi\n      fi\n    done\n  fi\ndone\n\nif [ -n \"$errors\" ]; then\n  echo \"Frontmatter validation failed:\"\n  echo -e \"$errors\"\n  exit 1\nfi\n";
+/**
+ * Install the pre-commit hook for frontmatter validation.
+ */
+export declare function installPreCommitHook(dir: string): void;
+/**
+ * Bash post-commit hook that pushes memfs commits to an optional additional
+ * git remote (the "memory repository" endpoint).
+ *
+ * Reads the remote URL from the repo's local git config
+ * (`letta.memoryRepository.url`). No-op when the key is unset. Push runs
+ * asynchronously in the background so commits stay fast, and failures are
+ * logged to `.git/memory-repository-push.log` without blocking the user.
+ *
+ * URL is per-repo by design: each agent's memfs repo has its own `.git/config`,
+ * so the endpoint is scoped to a single agent automatically.
+ */
+export declare const POST_COMMIT_HOOK_SCRIPT = "#!/usr/bin/env bash\n# Letta Code: push memfs commits to the configured memory-repository remote.\n# Installed by Letta Code CLI. Do not edit by hand \u2014 regenerated on startup.\nurl=$(git config --local --get letta.memoryRepository.url 2>/dev/null)\n[ -z \"$url\" ] && exit 0\nbranch=$(git symbolic-ref --quiet --short HEAD 2>/dev/null) || exit 0\n[ -z \"$branch\" ] && exit 0\n# Reflection and other harness worktrees commit on temporary branches; only the\n# main MemFS checkout should push to the optional memory repository remote.\n[ \"$branch\" != \"main\" ] && exit 0\nlog=\"$(git rev-parse --git-dir)/memory-repository-push.log\"\n(\n  {\n    printf '\\n--- %s %s on %s ---\\n' \"$(date '+%Y-%m-%dT%H:%M:%S%z')\" \"$(git rev-parse --short HEAD)\" \"$branch\"\n    git push --quiet \"$url\" \"$branch\":\"$branch\" 2>&1\n    echo \"exit=$?\"\n  } >> \"$log\" 2>&1\n) &\ndisown 2>/dev/null || true\nexit 0\n";
+/**
+ * Install the post-commit hook that pushes to `letta.memoryRepository.url`.
+ * Hook is harmless when the config key is unset (no-ops on every commit).
+ */
+export declare function installPostCommitHook(dir: string): void;
+//# sourceMappingURL=memory-git-hooks.d.ts.map

package/dist/types/agent/memory-git-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-git-hooks.d.ts","sourceRoot":"","sources":["../../../src/agent/memory-git-hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,sBAAsB,+vJAyIlC,CAAC;AAEF;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAWtD;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,uBAAuB,y5BAoBnC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAWvD"}

package/dist/types/agent/memory-git-signing.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Memory-repo commits must never be signed.
+ *
+ * Operators with a global `commit.gpgsign=true` have no signing key for the
+ * harness-managed committer identities (`<agentId>@letta.com`,
+ * `noreply@letta.com`), so any signing attempt fails with
+ * "gpg: signing failed: No secret key" and blocks memory init/commits,
+ * reflection merges, and `pull --rebase` recovery.
+ *
+ * Passed as highest-precedence `-c` config on every harness git invocation
+ * so it also covers commits git creates internally (rebase, merge).
+ */
+export declare const GIT_DISABLE_COMMIT_SIGNING_ARGS: readonly ["-c", "commit.gpgsign=false"];
+//# sourceMappingURL=memory-git-signing.d.ts.map

package/dist/types/agent/memory-git-signing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-git-signing.d.ts","sourceRoot":"","sources":["../../../src/agent/memory-git-signing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,+BAA+B,yCAGlC,CAAC"}