lampson 0.1.0

package/lib/provider.syn

@@ -0,0 +1,522 @@
+-- lib/provider.syn — transporte HTTP hacia LLMs (OpenAI-compatible y Anthropic-compatible)
+--
+-- Filosofía: NO usamos SDKs ni el provider built-in de
+-- Synsema (`llm_step`), hablamos HTTP crudo. Ventajas: historial multi-turno real, tool calling
+-- nativo de cada wire protocol, cualquier endpoint compatible (DeepSeek, Kimi, Groq, Ollama,
+-- MiniMax, Anthropic, OpenRouter...) solo cambiando LAMPSON_BASE_URL.
+--
+-- Formato CANÓNICO de mensajes (interno, estilo OpenAI):
+--   {role: "system"|"user"|"assistant"|"tool", content: text,
+--    tool_calls?: [{id, name, args(map)}],      -- solo assistant
+--    tool_call_id?: text, name?: text}          -- solo tool
+--
+-- chat(cfg, messages, catalog) → {text, tool_calls: [{id,name,args}], usage: {input, output}, stop, error}
+--
+-- MIGAS del runtime (verificadas en v0.6.7):
+--   * http_post con un MAP como body lo serializa con text() (NO JSON): siempre json_encode(body)
+--     + header Content-Type: application/json.
+--   * `json of r` NO existe en la respuesta; usar json_decode(body of r). Claves: status, ok, body, headers.
+--   * En error de red: status 0 y clave `error`; en éxito no hay clave `error` → contains(r, "error").
+--   * `localhost` resuelve a IPv6 en Windows; usar 127.0.0.1 para servers locales.
+--   * secret() como valor de header llega materializado al socket y redactado en logs.
+--   * Bajo `serve`, secret() debe resolverse DENTRO del handler (los globals cruzan redactados).
+--   * number("4096") es FLOAT → json_encode emite 4096.0 y las APIs lo rechazan ("invalid params"): floor() para enteros.
+
+use "./settings.syn" as settings
+
+let ANTHROPIC_VERSION be "2023-06-01"
+
+-- Tabla base URL por proveedor
+export let PRESETS be {
+    "openai":     {"wire": "openai",    "base_url": "https://api.openai.com/v1",         "model": "gpt-4o"},
+    "deepseek":   {"wire": "openai",    "base_url": "https://api.deepseek.com/v1",       "model": "deepseek-v4-flash"},
+    "kimi":       {"wire": "openai",    "base_url": "https://api.moonshot.ai/v1",        "model": "kimi-k2-0711-preview"},
+    "groq":       {"wire": "openai",    "base_url": "https://api.groq.com/openai/v1",    "model": "llama-3.3-70b-versatile"},
+    "grok":       {"wire": "openai",    "base_url": "https://api.x.ai/v1",               "model": "grok-3"},
+    "openrouter": {"wire": "openai",    "base_url": "https://openrouter.ai/api/v1",      "model": "deepseek/deepseek-chat"},
+    "ollama":     {"wire": "openai",    "base_url": "http://127.0.0.1:11434/v1",         "model": "qwen2.5-coder"},
+    "anthropic":  {"wire": "anthropic", "base_url": "https://api.anthropic.com/v1",      "model": "claude-sonnet-4-6"},
+    "minimax":    {"wire": "anthropic", "base_url": "https://api.minimax.io/anthropic/v1", "model": "MiniMax-M3"}
+}
+
+-- Keys: una por proveedor en .env como LAMPSON_API_KEY_<PROVIDER> (LAMPSON_API_KEY_DEEPSEEK, _ANTHROPIC…);
+-- LAMPSON_API_KEY es la del proveedor por defecto (LAMPSON_PROVIDER). Así se cambia de proveedor en caliente
+-- (/provider en terminal, selector en la web) sin tocar .env. Solo se comprueba SI hay key, nunca se muestra.
+task key_var(name)
+    give "LAMPSON_API_KEY_" + upper(name)
+
+-- proveedor por defecto: config.json (onboarding / UI) > LAMPSON_PROVIDER en .env > deepseek
+task env_default()
+    give lower(env("LAMPSON_PROVIDER", "deepseek"))
+
+export task default_provider()
+    require env("LAMPSON_*")
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    let s be settings.load()
+    when s["provider"] != ""
+        when contains(PRESETS, lower(s["provider"]))
+            give lower(s["provider"])
+    give env_default()
+
+export task has_key(name)
+    require env("LAMPSON_*")
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    when name == "ollama"
+        give true
+    when settings.raw_key(name) != ""
+        give true
+    when env(key_var(name), "") != ""
+        give true
+    give name == env_default() and env("LAMPSON_API_KEY", "") != ""
+
+-- ¿hay algún proveedor usable? (si no, la UI/terminal muestran el onboarding)
+export task configured()
+    require env("LAMPSON_*")
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    each n in keys(PRESETS)
+        when n != "ollama" and has_key(n)
+            give true
+    give false
+
+-- [{name, model, wire, has_key, current}] para selectores
+export task providers()
+    require env("LAMPSON_*")
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    let cur be default_provider()
+    let out be []
+    each n in sort_by(keys(PRESETS), (x) => x)
+        set out to append(out, {"name": n, "model": PRESETS[n]["model"], "wire": PRESETS[n]["wire"], "has_key": has_key(n), "current": n == cur})
+    give out
+
+-- Nombres de modelo: DeepSeek, OpenAI, Anthropic, Groq, Kimi, Grok y OpenRouter publican ids en minúsculas
+-- y la API rechaza otra capitalización ("deepseek-v4-pro" sí, "DeepSeek-V4-Pro" → 400 invalid_request_error,
+-- visto 2026-08-27 con un nombre tipeado en /setup). MiniMax ("MiniMax-M3") y Ollama (tags) se dejan tal cual.
+let LOWERCASE_MODELS be ["deepseek", "openai", "anthropic", "groq", "kimi", "grok", "openrouter"]
+
+export task normalize_model(name, model)
+    let m be trim(text(model))
+    when contains(LOWERCASE_MODELS, name)
+        give lower(m)
+    give m
+
+-- Modelos que la API declara disponibles (GET {base_url}/models, ambos wires) → [ids] o error legible.
+-- Se usa en `/model` sin argumentos y en la ventana de modelo de la web, para no tipear nombres a ciegas.
+export task list_models(cfg)
+    require net
+    require time
+    let headers be {"Authorization": bearer(cfg["key"])}
+    when cfg["wire"] == "anthropic"
+        set headers to {"x-api-key": cfg["key"], "anthropic-version": ANTHROPIC_VERSION}
+    let r be http_get(strip_slash(cfg["base_url"]) + "/models", headers)
+    when r["status"] != 200
+        give {"models": [], "error": "http " + text(r["status"]) + ": " + slice(text(r["body"]), 0, 200)}
+    let doc be json_decode(r["body"])
+    let ids be []
+    when contains(doc, "data")
+        each m in doc["data"]
+            when contains(m, "id")
+                set ids to append(ids, text(m["id"]))
+    give {"models": sort_by(ids, (x) => x), "error": nothing}
+
+-- Tokens de entrada servidos desde caché de prompt (cuestan ~10%): DeepSeek `prompt_cache_hit_tokens`,
+-- OpenAI `prompt_tokens_details.cached_tokens`. El presupuesto por turno (loop.syn) los pondera al 10%.
+export task cached_of(u)
+    when contains(u, "prompt_cache_hit_tokens")
+        give floor(number(u["prompt_cache_hit_tokens"]))
+    when contains(u, "prompt_tokens_details")
+        when u["prompt_tokens_details"] != nothing and contains(u["prompt_tokens_details"], "cached_tokens")
+            give floor(number(u["prompt_tokens_details"]["cached_tokens"]))
+    give 0
+
+-- costo ponderado de una llamada: cache al 10%, resto al 100%
+export task cost_tokens(u)
+    let cached be when contains(u, "cached") then u["cached"] otherwise 0
+    give floor((u["input"] - cached) + cached * 0.1 + u["output"])
+
+-- Configuración para un proveedor concreto (name "" = el por defecto; model "" = el guardado/preset).
+-- Llamar DENTRO del handler bajo serve.
+export task config_for(name, model)
+    require env("LAMPSON_*")
+    require secret("LAMPSON_*")
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    let s be settings.load()
+    let default_name be default_provider()
+    let n be when name == nothing or name == "" then default_name otherwise lower(name)
+    let preset be when contains(PRESETS, n) then PRESETS[n] otherwise PRESETS["openai"]
+    let is_env_default be n == env_default()
+    -- overrides de .env (WIRE/BASE_URL/MODEL) solo aplican al proveedor de .env
+    let wire be when is_env_default then env("LAMPSON_WIRE", preset["wire"]) otherwise preset["wire"]
+    let base be when is_env_default then env("LAMPSON_BASE_URL", preset["base_url"]) otherwise preset["base_url"]
+    let m be preset["model"]
+    when is_env_default
+        set m to env("LAMPSON_MODEL", m)
+    when n == default_name
+        when s["model"] != ""
+            set m to s["model"]
+    when model != nothing and model != ""
+        set m to model
+    set m to normalize_model(n, m)
+    -- key: guardada en config.json > LAMPSON_API_KEY_<P> > LAMPSON_API_KEY (solo para el proveedor de .env)
+    let key be secret("LAMPSON_API_KEY", "ollama")
+    when env(key_var(n), "") != ""
+        set key to secret(key_var(n), "ollama")
+    when settings.raw_key(n) != ""
+        set key to as_secret(settings.raw_key(n), "api_key_" + n)
+    give {
+        "provider": n,
+        "wire": wire,
+        "base_url": base,
+        "model": m,
+        -- 8192 (antes 4096): a un modelo razonador 4096 se le pueden ir enteros en pensar y la
+        -- respuesta llega vacía (finish_reason=length). Override: LAMPSON_MAX_TOKENS.
+        "max_tokens": floor(number(env("LAMPSON_MAX_TOKENS", "8192"))),
+        "timeout": number(env("LAMPSON_TIMEOUT", "180")),
+        "key": key,
+        "has_key": has_key(n)
+    }
+
+export task config()
+    require env("LAMPSON_*")
+    require secret("LAMPSON_*")
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    give config_for("", "")
+
+task strip_slash(url)
+    when length(url) > 0
+        when slice(url, length(url) - 1, length(url)) == "/"
+            give slice(url, 0, length(url) - 1)
+    give url
+
+task err_result(msg)
+    give {"text": "", "tool_calls": [], "usage": {"input": 0, "output": 0}, "stop": "error", "error": msg}
+
+-- ---------- OpenAI wire (chat/completions) ----------
+
+task to_openai_messages(messages)
+    let out be []
+    each m in messages
+        when m["role"] == "assistant"
+            let entry be {"role": "assistant", "content": m["content"]}
+            when contains(m, "tool_calls")
+                when length(m["tool_calls"]) > 0
+                    let tcs be []
+                    each tc in m["tool_calls"]
+                        set tcs to append(tcs, {"id": tc["id"], "type": "function", "function": {"name": tc["name"], "arguments": json_encode(tc["args"])}})
+                    set entry to {"role": "assistant", "content": m["content"], "tool_calls": tcs}
+            set out to append(out, entry)
+        otherwise when m["role"] == "tool"
+            set out to append(out, {"role": "tool", "tool_call_id": m["tool_call_id"], "content": m["content"]})
+        otherwise when has_images(m)
+            -- multimodal: partes texto + image_url con data URL (OpenAI, DeepSeek, OpenRouter, Groq…)
+            let parts be [{"type": "text", "text": image_handle(m)}]
+            each im in m["images"]
+                set parts to append(parts, {"type": "image_url", "image_url": {"url": "data:" + im["media_type"] + ";base64," + im["data"]}})
+            set out to append(out, {"role": "user", "content": parts})
+        otherwise
+            set out to append(out, {"role": m["role"], "content": m["content"]})
+    give out
+
+-- ¿mensaje de usuario con imágenes adjuntas? ({images: [{media_type, data(base64), w?, h?}]} en el formato canónico)
+task has_images(m)
+    when m["role"] != "user"
+        give false
+    when not contains(m, "images")
+        give false
+    give length(m["images"]) > 0
+
+-- ¿El modelo acepta imágenes? Declarado, no adivinado: desconocido = no (así el usuario ve un aviso
+-- claro en vez de un 400). Overrides: "vision": true|false en .lampson/config.json.
+-- Verificado 2026-08-27: MiniMax-M3 (wire anthropic) describe imágenes; deepseek-chat y kimi-k2 no las aceptan.
+export task supports_vision(cfg)
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    let s be settings.load()
+    when contains(s, "vision")
+        give s["vision"] == true
+    let p be cfg["provider"]
+    let m be lower(cfg["model"])
+    when p == "anthropic" or p == "minimax"
+        give true
+    when p == "groq"
+        give contains(m, "llama-4") or contains(m, "vision")
+    when p == "deepseek"
+        give contains(m, "vision")
+    when p == "openai"
+        give starts_with(m, "gpt-4o") or starts_with(m, "gpt-4.1") or starts_with(m, "gpt-5") or starts_with(m, "o1") or starts_with(m, "o3") or starts_with(m, "o4")
+    when p == "openrouter" or p == "ollama"
+        give contains(m, "vision") or contains(m, "vl") or contains(m, "gpt-4o") or contains(m, "gpt-5") or contains(m, "claude") or contains(m, "gemini") or contains(m, "llava") or contains(m, "pixtral") or contains(m, "qwen2.5vl") or contains(m, "qwen3-vl")
+    when p == "grok"
+        give contains(m, "vision") or starts_with(m, "grok-4")
+    when p == "kimi"
+        give contains(m, "vision") or contains(m, "vl")
+    give false
+
+-- Modelo sin visión: la imagen se reemplaza por una nota que el modelo puede explicarle al usuario
+-- (patrón de opencode), en vez de reventar en el proveedor. El texto conserva el handle con dimensiones.
+task image_note(m)
+    let notes be []
+    each e in enumerate(m["images"])
+        let im be e["item"]
+        let dims be when contains(im, "w") then " " + text(floor(im["w"])) + "x" + text(floor(im["h"])) + "px" otherwise ""
+        set notes to append(notes, "[Image " + text(e["index"] + 1) + dims + " attached, but this model does not accept image input — tell the user to switch to a vision model (e.g. anthropic or gpt-4o) if they need it read]")
+    give m["content"] + "\n" + join(notes, "\n")
+
+-- Handle textual junto a cada imagen (patrón de hermes/deepseek): el modelo sabe cuántas hay y de qué tamaño.
+task image_handle(m)
+    let parts be []
+    each e in enumerate(m["images"])
+        let im be e["item"]
+        let dims be when contains(im, "w") then " " + text(floor(im["w"])) + "x" + text(floor(im["h"])) + "px" otherwise ""
+        set parts to append(parts, "[Image " + text(e["index"] + 1) + dims + "]")
+    give m["content"] + "\n" + join(parts, " ")
+
+-- Mensajes listos para el wire: imágenes fuera si el modelo no las acepta
+task prepare(cfg, messages)
+    when supports_vision(cfg)
+        give messages
+    let out be []
+    each m in messages
+        when has_images(m)
+            set out to append(out, {"role": "user", "content": image_note(m)})
+        otherwise
+            set out to append(out, m)
+    give out
+
+task to_openai_tools(catalog)
+    let out be []
+    each t in catalog
+        set out to append(out, {"type": "function", "function": {"name": t["name"], "description": t["description"], "parameters": t["parameters"]}})
+    give out
+
+task parse_args(raw)
+    when raw == nothing
+        give {}
+    when raw == ""
+        give {}
+    try
+        let v be json_decode(raw)
+        give v
+    recover err
+        give {"_raw": raw, "_parse_error": err}
+
+task chat_openai(cfg, messages, catalog)
+    let body be {"model": cfg["model"], "messages": to_openai_messages(messages), "max_tokens": cfg["max_tokens"]}
+    when length(catalog) > 0
+        set body to {"model": cfg["model"], "messages": to_openai_messages(messages), "max_tokens": cfg["max_tokens"], "tools": to_openai_tools(catalog)}
+    let headers be {"Authorization": bearer(cfg["key"]), "Content-Type": "application/json"}
+    let r be http_post(strip_slash(cfg["base_url"]) + "/chat/completions", json_encode(body), headers, cfg["timeout"])
+    when contains(r, "error")
+        give err_result("network: " + text(error of r))
+    when status of r != 200
+        give err_result("http " + text(status of r) + ": " + slice(body of r, 0, 800))
+    let j be json_decode(body of r)
+    let msg be j["choices"][0]["message"]
+    let txt be ""
+    when contains(msg, "content")
+        when msg["content"] != nothing
+            set txt to msg["content"]
+    let calls be []
+    when contains(msg, "tool_calls")
+        when msg["tool_calls"] != nothing
+            each tc in msg["tool_calls"]
+                set calls to append(calls, {"id": tc["id"], "name": tc["function"]["name"], "args": parse_args(tc["function"]["arguments"])})
+    let usage be {"input": 0, "output": 0, "cached": 0}
+    when contains(j, "usage")
+        when j["usage"] != nothing
+            set usage to {"input": j["usage"]["prompt_tokens"], "output": j["usage"]["completion_tokens"], "cached": cached_of(j["usage"])}
+    -- finish_reason=length: se agotó max_tokens ANTES de terminar. Con un modelo razonador (deepseek-v4-pro)
+    -- puede irse TODO el presupuesto en pensar y llegar acá sin texto ni tool calls (visto 2026-08-28:
+    -- out=4096 exacto, respuesta vacía, y el turno moría en silencio como "done"). Vacío → error visible;
+    -- parcial → marcador para que el usuario sepa que faltó el final.
+    let fr be ""
+    when contains(j["choices"][0], "finish_reason")
+        when j["choices"][0]["finish_reason"] != nothing
+            set fr to text(j["choices"][0]["finish_reason"])
+    when fr == "length" and length(calls) == 0
+        when trim(txt) == ""
+            give {"text": "", "tool_calls": [], "usage": usage, "stop": "end", "error": "empty response: the model used its whole output budget (max_tokens=" + text(cfg["max_tokens"]) + ") without emitting text or tool calls — a reasoning model can spend it all thinking. Raise LAMPSON_MAX_TOKENS (or simplify the request) and say «seguí»."}
+        set txt to txt + "\n\n[respuesta cortada: se alcanzó max_tokens=" + text(cfg["max_tokens"]) + " — decí «seguí» para que continúe]"
+    let finish be when length(calls) > 0 then "tool_calls" otherwise "end"
+    give {"text": txt, "tool_calls": calls, "usage": usage, "stop": finish, "error": nothing}
+
+-- ---------- Anthropic wire (messages) ----------
+
+-- Anthropic exige: system aparte, roles alternados user/assistant, tool results como bloques
+-- tool_result dentro de un mensaje user (varios resultados consecutivos → UN mensaje user).
+task to_anthropic(messages)
+    let system be ""
+    let out be []
+    let pending_results be []
+    each m in messages
+        when m["role"] == "system"
+            set system to system + m["content"]
+        otherwise when m["role"] == "tool"
+            set pending_results to append(pending_results, {"type": "tool_result", "tool_use_id": m["tool_call_id"], "content": m["content"]})
+        otherwise
+            when length(pending_results) > 0
+                set out to append(out, {"role": "user", "content": pending_results})
+                set pending_results to []
+            when m["role"] == "assistant"
+                let blocks be []
+                when m["content"] != ""
+                    set blocks to append(blocks, {"type": "text", "text": m["content"]})
+                when contains(m, "tool_calls")
+                    each tc in m["tool_calls"]
+                        set blocks to append(blocks, {"type": "tool_use", "id": tc["id"], "name": tc["name"], "input": tc["args"]})
+                when length(blocks) == 0
+                    set blocks to append(blocks, {"type": "text", "text": "(sin contenido)"})
+                set out to append(out, {"role": "assistant", "content": blocks})
+            otherwise when has_images(m)
+                -- bloques image (base64) + texto; si el anterior era user de texto, se funde en bloques (roles alternados)
+                let blocks be []
+                each im in m["images"]
+                    set blocks to append(blocks, {"type": "image", "source": {"type": "base64", "media_type": im["media_type"], "data": im["data"]}})
+                set blocks to append(blocks, {"type": "text", "text": image_handle(m)})
+                let n be length(out)
+                let fused be false
+                when n > 0
+                    when out[n - 1]["role"] == "user"
+                        when text(out[n - 1]["content"]) == out[n - 1]["content"]
+                            set out to slice(out, 0, n - 1) + [{"role": "user", "content": [{"type": "text", "text": out[n - 1]["content"]}] + blocks}]
+                            set fused to true
+                when not fused
+                    set out to append(out, {"role": "user", "content": blocks})
+            otherwise
+                -- dos `user` seguidos (p.ej. el pedido + la salida de un `!comando`) → uno solo
+                let n be length(out)
+                let merged be false
+                when n > 0
+                    when out[n - 1]["role"] == "user"
+                        when text(out[n - 1]["content"]) == out[n - 1]["content"]
+                            set out to slice(out, 0, n - 1) + [{"role": "user", "content": out[n - 1]["content"] + "\n\n" + m["content"]}]
+                            set merged to true
+                when not merged
+                    set out to append(out, {"role": "user", "content": m["content"]})
+    when length(pending_results) > 0
+        set out to append(out, {"role": "user", "content": pending_results})
+    give {"system": system, "messages": out}
+
+task to_anthropic_tools(catalog)
+    let out be []
+    each t in catalog
+        set out to append(out, {"name": t["name"], "description": t["description"], "input_schema": t["parameters"]})
+    give out
+
+-- Prompt caching Anthropic: es OPT-IN (sin marcadores no cachea NADA). Los mismos 3 breakpoints a los
+-- que convergen opencode (cache-policy.ts) y hermes (prompt_caching.py): el último tool del catálogo,
+-- el system, y el último mensaje user — así cada llamada intra-turno pega en el prefijo (lectura 10%
+-- del precio). OpenAI/DeepSeek cachean solas por prefijo: su wire no lleva marcadores.
+let CACHE_HINT be {"type": "ephemeral"}
+
+task mark_last_block(m)
+    -- copia del mensaje con cache_control en su último bloque (content texto → un bloque text)
+    when text(m["content"]) == m["content"]
+        give {"role": m["role"], "content": [{"type": "text", "text": m["content"], "cache_control": CACHE_HINT}]}
+    let blocks be m["content"]
+    let n be length(blocks)
+    let last be {}
+    each k in keys(blocks[n - 1])
+        set last[k] to blocks[n - 1][k]
+    set last["cache_control"] to CACHE_HINT
+    give {"role": m["role"], "content": slice(blocks, 0, n - 1) + [last]}
+
+task cache_marked_messages(msgs)
+    let i be length(msgs) - 1
+    while i >= 0
+        when msgs[i]["role"] == "user"
+            give slice(msgs, 0, i) + [mark_last_block(msgs[i])] + slice(msgs, i + 1, length(msgs))
+        set i to i - 1
+    give msgs
+
+task cache_marked_tools(tools)
+    let n be length(tools)
+    when n == 0
+        give tools
+    let last be {}
+    each k in keys(tools[n - 1])
+        set last[k] to tools[n - 1][k]
+    set last["cache_control"] to CACHE_HINT
+    give slice(tools, 0, n - 1) + [last]
+
+task chat_anthropic(cfg, messages, catalog)
+    let conv be to_anthropic(messages)
+    let sys be when conv["system"] == "" then "" otherwise [{"type": "text", "text": conv["system"], "cache_control": CACHE_HINT}]
+    let msgs be cache_marked_messages(conv["messages"])
+    let body be {"model": cfg["model"], "max_tokens": cfg["max_tokens"], "system": sys, "messages": msgs}
+    when length(catalog) > 0
+        set body to {"model": cfg["model"], "max_tokens": cfg["max_tokens"], "system": sys, "messages": msgs, "tools": cache_marked_tools(to_anthropic_tools(catalog))}
+    let headers be {"x-api-key": cfg["key"], "anthropic-version": ANTHROPIC_VERSION, "Content-Type": "application/json"}
+    let r be http_post(strip_slash(cfg["base_url"]) + "/messages", json_encode(body), headers, cfg["timeout"])
+    when contains(r, "error")
+        give err_result("network: " + text(error of r))
+    when status of r != 200
+        give err_result("http " + text(status of r) + ": " + slice(body of r, 0, 800))
+    let j be json_decode(body of r)
+    let txt be ""
+    let calls be []
+    each b in j["content"]
+        when b["type"] == "text"
+            set txt to txt + b["text"]
+        otherwise when b["type"] == "tool_use"
+            set calls to append(calls, {"id": b["id"], "name": b["name"], "args": b["input"]})
+    let usage be {"input": 0, "output": 0, "cached": 0}
+    when contains(j, "usage")
+        -- input_tokens de Anthropic EXCLUYE lo cacheado: input = no-cache + escritura de caché + lectura de caché
+        -- (la escritura se cobra 1.25x pero se cuenta 1x acá; la lectura pondera 10% en cost_tokens)
+        let cr be when contains(j["usage"], "cache_read_input_tokens") then j["usage"]["cache_read_input_tokens"] otherwise 0
+        let cw be when contains(j["usage"], "cache_creation_input_tokens") then j["usage"]["cache_creation_input_tokens"] otherwise 0
+        set usage to {"input": j["usage"]["input_tokens"] + cr + cw, "output": j["usage"]["output_tokens"], "cached": cr}
+    -- stop_reason=max_tokens: mismo tratamiento que finish_reason=length en el wire openai (ver arriba)
+    let sr be when contains(j, "stop_reason") then text(j["stop_reason"]) otherwise ""
+    when sr == "max_tokens" and length(calls) == 0
+        when trim(txt) == ""
+            give {"text": "", "tool_calls": [], "usage": usage, "stop": "end", "error": "empty response: the model used its whole output budget (max_tokens=" + text(cfg["max_tokens"]) + ") without emitting text or tool calls. Raise LAMPSON_MAX_TOKENS and say «seguí»."}
+        set txt to txt + "\n\n[respuesta cortada: se alcanzó max_tokens=" + text(cfg["max_tokens"]) + " — decí «seguí» para que continúe]"
+    let finish be when length(calls) > 0 then "tool_calls" otherwise "end"
+    give {"text": txt, "tool_calls": calls, "usage": usage, "stop": finish, "error": nothing}
+
+-- ---------- Punto de entrada ----------
+
+export task chat(cfg, messages, catalog)
+    require net
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    let ready be prepare(cfg, messages)
+    when cfg["wire"] == "anthropic"
+        give chat_anthropic(cfg, ready, catalog)
+    give chat_openai(cfg, ready, catalog)
+
+-- Reintento simple con backoff para 429/5xx/red. Además: "empty response" (el razonador gastó TODO
+-- max_tokens pensando, sin emitir nada) reintenta con el DOBLE de max_tokens (hasta 65536) — así un
+-- LAMPSON_MAX_TOKENS modesto no mata un turno que necesitaba pensar largo.
+export task chat_retry(cfg, messages, catalog, attempts)
+    require net
+    require time
+    let n be 0
+    let last be nothing
+    let cur be cfg
+    while n < attempts
+        set n to n + 1
+        set last to chat(cur, messages, catalog)
+        when last["error"] == nothing
+            give last
+        let e be last["error"]
+        let retryable be starts_with(e, "network") or starts_with(e, "http 429") or starts_with(e, "http 5")
+        when starts_with(e, "empty response") and cur["max_tokens"] < 65536
+            let bigger be {}
+            each k in keys(cur)
+                set bigger[k] to cur[k]
+            set bigger["max_tokens"] to cur["max_tokens"] * 2
+            set cur to bigger
+            set retryable to true
+        when not retryable
+            give last
+        when n < attempts
+            sleep(n * 2)
+    give last

package/lib/session.syn

@@ -0,0 +1,111 @@
+-- lib/session.syn — persistencia de sesiones (historial canónico como JSON en .lampson/sessions/)
+--
+-- Aquí: un JSON por sesión, reescrito atómicamente en cada turno (write_file es atómico).
+-- Suficiente para v1 y trivialmente inspeccionable. Migrar a `db("./.lampson/sessions.db")` si crece.
+--
+-- MIGA: no existe append_file → releer + reescribir. write_file crea los directorios padres.
+
+use "./tools/memo.syn" as memo
+
+let DIR be ".lampson/sessions"
+
+export task new_id()
+    require time
+    give format_time(now(), "%Y%m%d-%H%M%S")
+
+task path_of(id)
+    give DIR + "/" + id + ".json"
+
+export task save(id, messages, meta)
+    require file(".lampson")
+    require file(".lampson/*")
+    require time
+    require env("LAMPSON_*")
+    -- cada sesión queda marcada con el proyecto (slug del workspace) para que list() no mezcle proyectos
+    set meta["project"] to memo.slug()
+    -- y con la corrida de lampson que la guardó (blackboard "lampson:run", lo comparte el entry al arrancar):
+    -- reanudar una sesión de OTRA corrida dispara la nota de procesos muertos (proc.resume_note)
+    observe "lampson:run" as run_info
+    when run_info != nothing
+        set meta["run"] to run_info["id"]
+    let doc be {"id": id, "updated": format_time(now()), "meta": meta, "messages": messages}
+    write_file(path_of(id), json_encode(doc))
+    give id
+
+export task load(id)
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    let doc be json_decode(read_file(path_of(id)))
+    give doc
+
+-- ¿el doc cargado fue guardado por OTRA corrida de lampson? (sin marca = sesión vieja → sí)
+export task from_other_run(doc)
+    observe "lampson:run" as run_info
+    when run_info == nothing
+        give false
+    when not contains(doc["meta"], "run")
+        give true
+    give doc["meta"]["run"] != run_info["id"]
+
+export task exists(id)
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    try
+        read_file(path_of(id), 1, 1)
+        give true
+    recover err
+        give false
+
+-- [{id, updated, title}] del proyecto ACTUAL, ordenado por id descendente (los ids son timestamps).
+-- Sesiones viejas sin marca de proyecto se listan igual (anteriores a esta marca).
+export task list()
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    require env("LAMPSON_*")
+    let mine be memo.slug()
+    let out be []
+    try
+        let entries be list_dir(DIR)
+        each e in entries
+            when not e["is_dir"]
+                let id be replace_text(e["name"], ".json", "")
+                try
+                    let d be load(id)
+                    let title be when contains(d["meta"], "title") then d["meta"]["title"] otherwise ""
+                    let project be when contains(d["meta"], "project") then d["meta"]["project"] otherwise mine
+                    when project == mine
+                        set out to append(out, {"id": id, "updated": d["updated"], "title": title})
+                recover err
+                    set out to out
+    recover err
+        give []
+    give sort_by(out, (s) => 0 - number(replace_text(replace_text(s["id"], "-", ""), "test", "")))
+
+-- Borrar una sesión (no hay delete_file en el runtime: se usa el shell del sistema sobre la ruta fija).
+export task delete(id)
+    require exec
+    require env("OS")
+    require file.read(".lampson")
+    require file.read(".lampson/*")
+    when not matches(id, "[a-zA-Z0-9_-]{1,40}")
+        raise("invalid session id")
+    when not exists(id)
+        give "no existe " + id
+    -- la sesión y su traza (.lampson/trace/<id>.log + .last) se van juntas
+    let files be [path_of(id), ".lampson/trace/" + id + ".log", ".lampson/trace/" + id + ".last"]
+    each f in files
+        when env("OS", "") == "Windows_NT"
+            run("cmd", ["/c", "del", "/q", replace_text(f, "/", "\\")], 10)
+        otherwise
+            run("rm", ["-f", f], 10)
+    give "borrada " + id
+
+-- Título = primer mensaje de usuario recortado.
+export task title_of(messages)
+    each m in messages
+        when m["role"] == "user"
+            let t be replace_text(m["content"], "\n", " ")
+            when length(t) > 60
+                give slice(t, 0, 60) + "…"
+            give t
+    give "(sin título)"