@letta-ai/letta-code 0.32.13 → 0.32.15

package/skills/workflow-authoring/SKILL.md

@@ -0,0 +1,217 @@
+---
+name: workflow-authoring
+description: Reference for writing a Workflow tool script (script API and gotchas, pipeline-vs-barrier rules, quality patterns, worked examples). Load before authoring a script for a workflow the user already opted into; it does not itself authorize running one.
+---
+
+# Workflow authoring reference
+
+A workflow structures work across many subagents — to be comprehensive
+(decompose and cover in parallel), to be confident (independent perspectives
+and adversarial checks before committing), or to take on scale one context
+can't hold (migrations, audits, broad sweeps). The script is where you encode
+that structure: what fans out, what verifies, what synthesizes.
+
+When you do call the Workflow tool, the right move is often **hybrid**: scout
+inline first (list the files, scope the diff, find the modules) to discover
+the work-list, then call Workflow to pipeline over it, passing the list via
+`args`. You don't need to know the shape before the *task* — only before the
+*orchestration step*.
+
+Common single-phase workflows you can chain across turns:
+- **Understand** — parallel readers over relevant subsystems → structured map
+- **Design** — judge panel of N independent approaches → scored synthesis
+- **Review** — dimensions → find → adversarially verify
+- **Research** — multi-modal sweep → deep-read → synthesize
+- **Migrate** — discover sites → transform each → verify
+
+For larger work, run several in sequence — read each result before deciding
+the next phase. You stay in the loop; each workflow is one well-scoped
+fan-out.
+
+Every script must begin with `export const meta = {...}`:
+
+    export const meta = {
+      name: 'find-flaky-tests',                       // kebab-case, required
+      description: 'Find flaky tests and propose fixes',  // required
+      phases: [                                       // one entry per phase() call
+        { title: 'Scan', detail: 'grep test logs for retries' },
+        { title: 'Fix', detail: 'one agent per flaky test' },
+      ],
+    }
+    // script body starts here — use agent()/parallel()/pipeline()/phase()/log()
+
+The `meta` object must be a PURE LITERAL — no variables, function calls,
+spreads, or template interpolation.
+
+## What a subagent is
+
+Every `agent()` call is one agent-free ephemeral conversation linked to the
+invoking parent agent (`is_subagent: true`, named after the call's `label`).
+It starts with nothing but its prompt: no memory, no conversation context, no
+skills. Put ALL context a stage needs in the prompt — file paths, the rule it
+should apply, what shape to return.
+
+Subagents are told their final text IS the return value (not a human-facing
+message), so they return raw data. Tools default to read-only (`Read`,
+`Grep`, `Glob`); widen with `allowedTools` for stages that must write. For
+stages whose input is entirely in the prompt (synthesis, judging, scoring)
+pass `allowedTools: []` — a model that can still read files tends to wander,
+and a subagent that re-issues an identical tool call three times is stopped
+and resolves to `null`.
+
+Their model defaults to the invoking conversation's model. `opts.model` (or
+the tool's `model` input) accepts any handle or alias listed by
+`letta model list`; an unknown value resolves that call to `null`. Use a
+cheaper model for mechanical stages only when you know a valid handle.
+
+Workflow subagents require the API backend.
+
+## Script body hooks
+
+- `agent(prompt, opts?)` → Promise. Spawn one subagent. Resolves to its final
+  text, or with `json: true` to the parsed JSON value (say in the prompt what
+  shape to return — nothing validates it; a reply that is not JSON resolves to
+  `null`). Resolves to `null` on any failure — filter with `.filter(Boolean)`.
+  Options: `label` (display name), `phase` (progress group — use this inside
+  pipeline()/parallel() stages to avoid races on the global phase() state),
+  `json`, `model`, `effort` (`'low'` for mechanical stages, higher for the
+  hardest verify/judge stages), `allowedTools`, `systemPrompt` (extra system
+  prompt for this subagent), `timeoutMs` (default 10 minutes), `maxToolCalls`
+  (positive safe integer; default 1000 unique tool calls for this subagent).
+- `pipeline(items, stage1, stage2, ...)` → run each item through all stages
+  independently, NO barrier between stages. Item A can be in stage 3 while
+  item B is still in stage 1. This is the DEFAULT for multi-stage work.
+  Wall-clock = slowest single-item chain, not sum-of-slowest-per-stage. Every
+  stage callback receives `(prevResult, originalItem, index)` — use
+  originalItem/index in later stages to label work without threading context
+  through stage 1's return value. A stage that throws drops that item to
+  `null` and skips its remaining stages.
+- `parallel(thunks)` → run zero-arg functions concurrently. This is a
+  BARRIER: it awaits all thunks before returning. A thunk that throws
+  resolves to `null` in the result array — the call itself never rejects, so
+  `.filter(Boolean)` before using the results. Use ONLY when you genuinely
+  need all results together.
+- `phase(title)` — start a new phase; subsequent agent() calls are grouped
+  under this title in progress output.
+- `log(message)` — emit a progress message to the user.
+- `args` — the value passed as the tool's `args` input, verbatim. Pass
+  arrays/objects as actual JSON values, NOT as a JSON-encoded string.
+
+Scripts are plain JavaScript, NOT TypeScript — type annotations, interfaces,
+and generics fail to parse. The script body runs in an async context — use
+`await` directly and `return` the final result. Standard JS built-ins (JSON,
+Math, Array, etc.) are available; the hooks are the only globals provided.
+The script runs inside the CLI process with the CLI's own privileges (the
+`vm` context is a scope, not a security boundary), and the user approves it
+by reading it. Keep the script to orchestration: decide what runs and combine
+results. All reading, searching, and writing belongs in subagents, where the
+tool allowlist applies.
+
+## Pipeline vs barrier
+
+DEFAULT TO pipeline(). Only reach for a barrier (parallel between stages)
+when stage N needs cross-item context from all of stage N−1:
+- Dedup/merge across the full result set before expensive downstream work
+- Early-exit if the total count is zero ("0 bugs found → skip verification")
+- Stage N's prompt references "the other findings" for comparison
+
+A barrier is NOT justified by:
+- "I need to flatten/map/filter first" — do it inside a pipeline stage:
+  `pipeline(items, stageA, r => transform([r]).flat(), stageB)`
+- "The stages are conceptually separate" — that's what pipeline() models.
+  Separate stages ≠ synchronized stages.
+- "It's cleaner code" — barrier latency is real. If 5 finders run and the
+  slowest takes 3× the fastest, a barrier wastes 2/3 of the fast finders'
+  idle time.
+
+Concurrent agent() calls are capped per run (`maxConcurrent`, default 16) —
+excess calls queue and run as slots free up, so passing 100 items is fine.
+Total agent count across a run is capped at 1000 — a runaway-loop backstop.
+A single parallel()/pipeline() call accepts at most 4096 items.
+
+When a barrier IS correct — dedup across all findings before expensive
+verification:
+
+    const all = await parallel(DIMENSIONS.map(d => () => agent(d.prompt, {json: true})))
+    const deduped = dedupeByFileAndLine(all.filter(Boolean).flatMap(r => r.findings ?? []))  // needs ALL at once
+    const verified = await parallel(deduped.map(f => () => agent(verifyPrompt(f), {json: true})))
+
+Loop-until-count pattern — accumulate to a target:
+
+    const bugs = []
+    let rounds = 0
+    while (bugs.length < 10 && rounds++ < 5) {
+      const result = await agent('Find bugs in this codebase. Reply {"bugs": [{file, line, summary}]}', {json: true})
+      bugs.push(...(result?.bugs ?? []))
+      log(`${bugs.length}/10 found`)
+    }
+
+Always bound a loop with a round counter as well as the target: a subagent
+that keeps returning nothing would otherwise run to the 1000-agent cap.
+
+Composing patterns — exhaustive review (find → dedup vs seen → diverse-lens
+panel → loop-until-dry):
+
+    const seen = new Set(), confirmed = []
+    let dry = 0
+    while (dry < 2) {                                              // loop-until-dry
+      const found = (await parallel(FINDERS.map(f => () =>          // barrier: collect all finders this round
+        agent(f.prompt, {phase: 'Find', json: true})))).filter(Boolean).flatMap(r => r.bugs ?? [])
+      const fresh = found.filter(b => !seen.has(key(b)))           // dedup vs ALL seen — plain code, not an agent
+      if (!fresh.length) { dry++; continue }
+      dry = 0; fresh.forEach(b => seen.add(key(b)))
+      const judged = await parallel(fresh.map(b => () =>           // every fresh bug judged concurrently...
+        parallel(['correctness','security','repro'].map(lens => () =>   // ...each by 3 distinct lenses
+          agent(`Judge "${b.desc}" via the ${lens} lens — real? Reply {"real": boolean}`, {phase: 'Verify', json: true, allowedTools: []})))
+          .then(vs => ({ b, real: vs.filter(Boolean).filter(v => v.real).length >= 2 }))))
+      confirmed.push(...judged.filter(v => v.real).map(v => v.b))
+    }
+    return confirmed
+    // dedup vs `seen`, NOT `confirmed` — else judge-rejected findings reappear every round and it never converges.
+
+## Quality patterns — pick by task and compose freely
+
+- **Adversarial verify**: spawn N independent skeptics per finding, each
+  prompted to REFUTE. Kill if ≥majority refute. Prevents plausible-but-wrong
+  findings from surviving.
+
+      const votes = await parallel(Array.from({length: 3}, () => () =>
+        agent(`Try to refute: ${claim}. Default to refuted=true if uncertain. Reply {"refuted": boolean}`, {json: true})))
+      const survives = votes.filter(Boolean).filter(v => !v.refuted).length >= 2
+
+- **Perspective-diverse verify**: when a finding can fail in more than one
+  way, give each verifier a distinct lens (correctness, security, perf,
+  does-it-reproduce) instead of N identical refuters — diversity catches
+  failure modes redundancy can't.
+- **Judge panel**: generate N independent attempts from different angles
+  (e.g. MVP-first, risk-first, user-first), score with parallel judges,
+  synthesize from the winner while grafting the best ideas from runners-up.
+  Beats one-attempt-iterated when the solution space is wide.
+- **Loop-until-dry**: for unknown-size discovery (bugs, issues, edge cases),
+  keep spawning finders until K consecutive rounds return nothing new.
+  Simple counters (while count < N) miss the tail.
+- **Multi-modal sweep**: parallel agents each searching a different way
+  (by-container, by-content, by-entity, by-time). Each is blind to what the
+  others surface; useful when one search angle won't find everything.
+- **Completeness critic**: a final agent that asks "what's missing —
+  modality not run, claim unverified, source unread?" What it finds becomes
+  the next round of work.
+- **No silent caps**: if a workflow bounds coverage (top-N, no-retry,
+  sampling), `log()` what was dropped — silent truncation reads as "covered
+  everything" when it didn't.
+
+Scale to what the user asked for. "find any bugs" → a few finders,
+single-vote verify. "thoroughly audit this" or "be comprehensive" → larger
+finder pool, 3–5 vote adversarial pass, synthesis stage. When unsure, lean
+toward thoroughness for research/review/audit requests and toward brevity for
+quick checks.
+
+## Diagnosing a run
+
+Every run persists its script, args, and a `journal.jsonl` with one line per
+completed subagent call (prompt, outcome, conversation id) under
+`~/.letta/workflows/executions/<id>/`; the tool result names the paths. Before
+diagnosing why a workflow returned an empty or unexpected result, read that
+journal — it records each agent's actual return value and, for a `null`,
+which guard or error produced it. A failed run is not resumable: fix the
+script and launch it again.

package/vendor/ink-text-input/build/index.js

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import { Text, Transform, useInput } from 'ink';
-import React, { useEffect, useState } from 'react';
+import React, { useEffect, useRef, useState } from 'react';
 
 // Use a private-use sentinel while Ink/wrap-ansi measure and wrap text.
 // wrap-ansi with trim:true strips inverse ASCII spaces at line boundaries, but
@@ -54,12 +54,19 @@ export function isControlSequence(input, key) {
 function TextInput({ value: originalValue, placeholder = '', focus = true, mask, highlightPastedText = false, showCursor = true, onChange, onSubmit, externalCursorOffset, onCursorOffsetChange }) {
     const [state, setState] = useState({ cursorOffset: (originalValue || '').length, cursorWidth: 0, killBuffer: '' });
     const { cursorOffset, cursorWidth, killBuffer } = state;
+    // Latest value this input knows about: the rendered value, or the value the
+    // input handler just reported. Several input events can land in one tick (an
+    // IME commit split across stdin reads) before React flushes the effect
+    // below, so its closure's originalValue may already be older than the caret
+    // in previousState; clamping against it moved the caret backwards (#4493).
+    const latestValueRef = useRef(originalValue || '');
+    latestValueRef.current = originalValue || '';
     useEffect(() => {
         setState(previousState => {
             if (!focus || !showCursor) {
                 return previousState;
             }
-            const newValue = originalValue || '';
+            const newValue = latestValueRef.current;
             if (previousState.cursorOffset > newValue.length - 1) {
                 return { ...previousState, cursorOffset: newValue.length, cursorWidth: 0 };
             }
@@ -179,6 +186,7 @@ function TextInput({ value: originalValue, placeholder = '', focus = true, mask,
         setState(prev => ({ ...prev, cursorOffset: nextCursorOffset, cursorWidth: nextCursorWidth, killBuffer: nextKillBuffer }));
         if (typeof onCursorOffsetChange === 'function') onCursorOffsetChange(nextCursorOffset);
         if (nextValue !== originalValue) {
+            latestValueRef.current = nextValue;
             onChange(nextValue);
         }
     }, { isActive: focus });

package/dist/types/tools/impl/glob-gemini.d.ts

@@ -1,16 +0,0 @@
-/**
- * Gemini CLI glob tool - wrapper around Letta Code's Glob tool
- * Uses Gemini's exact schema and description
- */
-interface GlobGeminiArgs {
-    pattern: string;
-    dir_path?: string;
-    case_sensitive?: boolean;
-    respect_git_ignore?: boolean;
-    respect_gemini_ignore?: boolean;
-}
-export declare function glob_gemini(args: GlobGeminiArgs): Promise<{
-    message: string;
-}>;
-export {};
-//# sourceMappingURL=glob-gemini.d.ts.map

package/dist/types/tools/impl/glob-gemini.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"glob-gemini.d.ts","sourceRoot":"","sources":["../../../../src/tools/impl/glob-gemini.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,UAAU,cAAc;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC;AAED,wBAAsB,WAAW,CAC/B,IAAI,EAAE,cAAc,GACnB,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAY9B"}

package/dist/types/tools/impl/list-directory-gemini.d.ts

@@ -1,17 +0,0 @@
-/**
- * Gemini CLI list_directory tool - wrapper around Letta Code's LS tool
- * Uses Gemini's exact schema and description
- */
-interface ListDirectoryGeminiArgs {
-    dir_path: string;
-    ignore?: string[];
-    file_filtering_options?: {
-        respect_git_ignore?: boolean;
-        respect_gemini_ignore?: boolean;
-    };
-}
-export declare function list_directory(args: ListDirectoryGeminiArgs): Promise<{
-    message: string;
-}>;
-export {};
-//# sourceMappingURL=list-directory-gemini.d.ts.map

package/dist/types/tools/impl/list-directory-gemini.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"list-directory-gemini.d.ts","sourceRoot":"","sources":["../../../../src/tools/impl/list-directory-gemini.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,UAAU,uBAAuB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,sBAAsB,CAAC,EAAE;QACvB,kBAAkB,CAAC,EAAE,OAAO,CAAC;QAC7B,qBAAqB,CAAC,EAAE,OAAO,CAAC;KACjC,CAAC;CACH;AAED,wBAAsB,cAAc,CAClC,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAa9B"}

package/dist/types/tools/impl/read-file-gemini.d.ts

@@ -1,14 +0,0 @@
-/**
- * Gemini CLI read_file tool - wrapper around Letta Code's Read tool
- * Uses Gemini's exact schema and description
- */
-interface ReadFileGeminiArgs {
-    file_path: string;
-    offset?: number;
-    limit?: number;
-}
-export declare function read_file_gemini(args: ReadFileGeminiArgs): Promise<{
-    message: string;
-}>;
-export {};
-//# sourceMappingURL=read-file-gemini.d.ts.map

package/dist/types/tools/impl/read-file-gemini.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"read-file-gemini.d.ts","sourceRoot":"","sources":["../../../../src/tools/impl/read-file-gemini.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,UAAU,kBAAkB;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAgBD,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAa9B"}

package/dist/types/tools/impl/read-many-files-gemini.d.ts

@@ -1,19 +0,0 @@
-/**
- * Gemini CLI read_many_files tool - new implementation for Letta Code
- * Uses Gemini's exact schema and description
- */
-interface ReadManyFilesGeminiArgs {
-    include: string[];
-    exclude?: string[];
-    recursive?: boolean;
-    useDefaultExcludes?: boolean;
-    file_filtering_options?: {
-        respect_git_ignore?: boolean;
-        respect_gemini_ignore?: boolean;
-    };
-}
-export declare function read_many_files(args: ReadManyFilesGeminiArgs): Promise<{
-    message: string;
-}>;
-export {};
-//# sourceMappingURL=read-many-files-gemini.d.ts.map

package/dist/types/tools/impl/read-many-files-gemini.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"read-many-files-gemini.d.ts","sourceRoot":"","sources":["../../../../src/tools/impl/read-many-files-gemini.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,UAAU,uBAAuB;IAC/B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,sBAAsB,CAAC,EAAE;QACvB,kBAAkB,CAAC,EAAE,OAAO,CAAC;QAC7B,qBAAqB,CAAC,EAAE,OAAO,CAAC;KACjC,CAAC;CACH;AAaD,wBAAsB,eAAe,CACnC,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CA8E9B"}

package/dist/types/tools/impl/replace-gemini.d.ts

@@ -1,15 +0,0 @@
-/**
- * Gemini CLI replace tool - wrapper around Letta Code's Edit tool
- * Uses Gemini's exact schema and description
- */
-interface ReplaceGeminiArgs {
-    file_path: string;
-    old_string: string;
-    new_string: string;
-    expected_replacements?: number;
-}
-export declare function replace(args: ReplaceGeminiArgs): Promise<{
-    message: string;
-}>;
-export {};
-//# sourceMappingURL=replace-gemini.d.ts.map

package/dist/types/tools/impl/replace-gemini.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"replace-gemini.d.ts","sourceRoot":"","sources":["../../../../src/tools/impl/replace-gemini.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,UAAU,iBAAiB;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,wBAAsB,OAAO,CAC3B,IAAI,EAAE,iBAAiB,GACtB,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAiB9B"}

package/dist/types/tools/impl/run-shell-command-gemini.d.ts

@@ -1,18 +0,0 @@
-/**
- * Gemini CLI run_shell_command tool - wrapper around Letta Code's Bash tool
- * Uses Gemini's exact schema and description
- */
-interface RunShellCommandGeminiArgs {
-    command: string;
-    description?: string;
-    dir_path?: string;
-    timeout_ms?: number;
-    signal?: AbortSignal;
-    onOutput?: (chunk: string, stream: "stdout" | "stderr") => void;
-    secretEnv?: Record<string, string>;
-}
-export declare function run_shell_command(args: RunShellCommandGeminiArgs): Promise<{
-    message: string;
-}>;
-export {};
-//# sourceMappingURL=run-shell-command-gemini.d.ts.map

package/dist/types/tools/impl/run-shell-command-gemini.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-shell-command-gemini.d.ts","sourceRoot":"","sources":["../../../../src/tools/impl/run-shell-command-gemini.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,UAAU,yBAAyB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAG,QAAQ,KAAK,IAAI,CAAC;IAChE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAED,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,yBAAyB,GAC9B,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAa9B"}

package/dist/types/tools/impl/search-file-content-gemini.d.ts

@@ -1,14 +0,0 @@
-/**
- * Gemini CLI search_file_content tool - wrapper around Letta Code's Grep tool
- * Uses Gemini's exact schema and description
- */
-interface SearchFileContentGeminiArgs {
-    pattern: string;
-    dir_path?: string;
-    include?: string;
-}
-export declare function search_file_content(args: SearchFileContentGeminiArgs): Promise<{
-    message: string;
-}>;
-export {};
-//# sourceMappingURL=search-file-content-gemini.d.ts.map

package/dist/types/tools/impl/search-file-content-gemini.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"search-file-content-gemini.d.ts","sourceRoot":"","sources":["../../../../src/tools/impl/search-file-content-gemini.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,UAAU,2BAA2B;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,2BAA2B,GAChC,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAa9B"}

package/dist/types/tools/impl/write-file-gemini.d.ts

@@ -1,13 +0,0 @@
-/**
- * Gemini CLI write_file tool - wrapper around Letta Code's Write tool
- * Uses Gemini's exact schema and description
- */
-interface WriteFileGeminiArgs {
-    file_path: string;
-    content: string;
-}
-export declare function write_file_gemini(args: WriteFileGeminiArgs): Promise<{
-    message: string;
-}>;
-export {};
-//# sourceMappingURL=write-file-gemini.d.ts.map

package/dist/types/tools/impl/write-file-gemini.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"write-file-gemini.d.ts","sourceRoot":"","sources":["../../../../src/tools/impl/write-file-gemini.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,UAAU,mBAAmB;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,mBAAmB,GACxB,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAM9B"}

package/dist/types/tools/impl/write-todos-gemini.d.ts

@@ -1,16 +0,0 @@
-/**
- * Gemini CLI write_todos tool - adapter for Letta Code's todo_write
- * Uses Gemini's exact schema and description but adapts the params
- */
-interface WriteTodosGeminiArgs {
-    todos: Array<{
-        description: string;
-        status: "pending" | "in_progress" | "completed" | "cancelled";
-    }>;
-}
-export declare function write_todos(args: WriteTodosGeminiArgs): Promise<{
-    message: string;
-    todos: typeof args.todos;
-}>;
-export {};
-//# sourceMappingURL=write-todos-gemini.d.ts.map

package/dist/types/tools/impl/write-todos-gemini.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"write-todos-gemini.d.ts","sourceRoot":"","sources":["../../../../src/tools/impl/write-todos-gemini.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,UAAU,oBAAoB;IAC5B,KAAK,EAAE,KAAK,CAAC;QACX,WAAW,EAAE,MAAM,CAAC;QACpB,MAAM,EAAE,SAAS,GAAG,aAAa,GAAG,WAAW,GAAG,WAAW,CAAC;KAC/D,CAAC,CAAC;CACJ;AAED,wBAAsB,WAAW,CAC/B,IAAI,EAAE,oBAAoB,GACzB,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,IAAI,CAAC,KAAK,CAAA;CAAE,CAAC,CA6CxD"}

package/dist/types/tools/letta-toolset.d.ts

@@ -1,10 +0,0 @@
-import type { ToolName } from "./tool-definitions";
-export type StartupToolsetPreference = "auto" | "codex" | "default" | "gemini" | "letta";
-/** Letta's model-independent toolset with one preferred tool for each job. */
-export declare const LETTA_TOOLS: ToolName[];
-export declare function loadStartupTools(params: {
-    modelIdentifier?: string;
-    toolset?: StartupToolsetPreference;
-    exclude?: ToolName[];
-}): Promise<void>;
-//# sourceMappingURL=letta-toolset.d.ts.map

package/dist/types/tools/letta-toolset.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"letta-toolset.d.ts","sourceRoot":"","sources":["../../../src/tools/letta-toolset.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD,MAAM,MAAM,wBAAwB,GAChC,MAAM,GACN,OAAO,GACP,SAAS,GACT,QAAQ,GACR,OAAO,CAAC;AAEZ,8EAA8E;AAC9E,eAAO,MAAM,WAAW,EAAE,QAAQ,EAmBjC,CAAC;AAEF,wBAAsB,gBAAgB,CAAC,MAAM,EAAE;IAC7C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,wBAAwB,CAAC;IACnC,OAAO,CAAC,EAAE,QAAQ,EAAE,CAAC;CACtB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBhB"}

package/dist/types/tools/toolset-defaults.d.ts

@@ -1,9 +0,0 @@
-import type { ToolName } from "./tool-definitions";
-export declare const WORKTREE_TOOL_NAMES: Set<"memory" | "Write" | "Edit" | "MultiEdit" | "apply_patch" | "ApplyPatch" | "memory_apply_patch" | "replace" | "Replace" | "write_file_gemini" | "WriteFileGemini" | "read_file" | "Task" | "exec_command" | "shell_command" | "shell" | "grep_files" | "search_file_content" | "glob_gemini" | "read_file_gemini" | "Skill" | "Read" | "view_image" | "ViewImage" | "Bash" | "Grep" | "Glob" | "LS" | "TodoWrite" | "TaskCreate" | "TaskGet" | "TaskList" | "TaskUpdate" | "AskUserQuestion" | "update_plan" | "write_stdin" | "list_dir" | "UpdatePlan" | "ShellCommand" | "Shell" | "ReadFile" | "ListDir" | "GrepFiles" | "run_shell_command" | "list_directory" | "write_todos" | "read_many_files" | "RunShellCommand" | "ReadFileGemini" | "ListDirectory" | "GlobGemini" | "SearchFileContent" | "WriteTodos" | "ReadManyFiles" | "KillBash" | "BashOutput" | "TaskOutput" | "EnterWorktree" | "ExitWorktree" | "TaskStop" | "Monitor" | "read_artifact_file" | "ReadLSP" | "SendAgentMessage" | "SetWorkingDirectory" | "write_artifact_file">;
-/** Built-in tool presets. Availability filters and explicit allowlists apply afterward. */
-export declare const ANTHROPIC_DEFAULT_TOOLS: ToolName[];
-export declare const OPENAI_DEFAULT_TOOLS: ToolName[];
-export declare const GEMINI_DEFAULT_TOOLS: ToolName[];
-export declare const OPENAI_PASCAL_TOOLS: ToolName[];
-export declare const GEMINI_PASCAL_TOOLS: ToolName[];
-//# sourceMappingURL=toolset-defaults.d.ts.map

package/dist/types/tools/toolset-defaults.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"toolset-defaults.d.ts","sourceRoot":"","sources":["../../../src/tools/toolset-defaults.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD,eAAO,MAAM,mBAAmB,4/BAG9B,CAAC;AAEH,2FAA2F;AAC3F,eAAO,MAAM,uBAAuB,EAAE,QAAQ,EAqB7C,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,EAU1C,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,EAgB1C,CAAC;AAGF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,EAgBzC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,EAiBzC,CAAC"}

package/dist/types/tools/toolset-options.d.ts

@@ -1,4 +0,0 @@
-import type { ToolsetOption } from "./toolset-types";
-/** Toolsets this Letta Code runtime can load and present to clients. */
-export declare const TOOLSET_OPTIONS: readonly ToolsetOption[];
-//# sourceMappingURL=toolset-options.d.ts.map

package/dist/types/tools/toolset-options.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"toolset-options.d.ts","sourceRoot":"","sources":["../../../src/tools/toolset-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,wEAAwE;AACxE,eAAO,MAAM,eAAe,EAAE,SAAS,aAAa,EAyDnD,CAAC"}