@columenlabs/lumen-ai 0.1.187 → 0.1.188

package/README.md

@@ -98,10 +98,10 @@ app.all('/api/assistant/*', (c) => routes(c.req.raw));
 - **Keys.** Each provider has its own keys (`?provider=anthropic|openai` on the key routes). An admin pastes the shared key everyone uses (`PUT /key`); it is tested with one free call before it is kept, then sealed, and no route returns it. A person may add their own (`PUT /my-key`), with one monthly cap on their own keys (`PUT /my-key/cap`).
 - **ChatGPT sign-in.** In place of their own OpenAI key a person may sign in with their ChatGPT plan (`POST /my-signin`, then `POST /my-signin/finish {url}`): the sign-in opens in a new tab and ends on `http://127.0.0.1:1455/auth/callback`, a page that does not load, whose address the person pastes back. The tokens are sealed as their own key and refreshed before they run out; answers on the plan count tokens and no dollars.
 - **Who pays.** The person's pick (the shared keys by default) while it has a key for the tier's provider and money left this month under its cap (an admin sets the shared keys' cap per person, `PUT /app`), else the other; with neither the panel says why.
-- **Tools.** Each group is Off, Read, Read + draft or Read + write per person. A tool is a read when its MCP `readOnlyHint` is set. On Read + draft a write only drafts a card, and runs as the person when they press Save, after access is checked again. A group with `readOnly: true` (read tools only) is offered Off or Read alone. Read + write is offered only for a group with `writes: true`: its writes run at once, and with `undo` set each one's line in the chat has Undo, which calls `undo(caller, { tool, args, result })` (`POST /chats/:id/writes/:step/undo`); the model is told what was undone. Cards drafted one after another show as one stack with Save all. Use `mcpServerTools` (an SDK `McpServer`), `mcpFetchTools` (a server served as a fetch handler, any SDK), `remoteMcpTools` or `plainTools`.
+- **Tools.** Each group is Off, Read, Read + draft or Read + write per person. A tool is a read when its MCP `readOnlyHint` is set. On Read + draft a write only drafts a card, and runs as the person when they press Save, after access is checked again. A group with `readOnly: true` (read tools only) is offered Off or Read alone. Read + write is offered only for a group with `writes: true`: its writes run at once, and with `undo` set each one's line in the chat has Undo, which calls `undo(caller, { tool, args, result })`; the model is told what was undone. Cards drafted one after another show as one stack with Save all. Use `mcpServerTools` (an SDK `McpServer`), `mcpFetchTools` (a server served as a fetch handler, any SDK), `remoteMcpTools` or `plainTools`.
 - **Web.** `fetch` is a plain GET from the Worker (10 s, 2 MB, never the app's own hosts or private addresses). ScrapeQL's own tools join over its MCP API once an admin pastes a Cloudflare Access service token (`PUT /web/scrapeql`). A Worker on ScrapeQL's own Cloudflare account passes its service binding instead, `scrapeql: { url: 'https://scrapeql/mcp', fetch: env.SCRAPEQL.fetch.bind(env.SCRAPEQL) }`: no token is stored, the tools are always on and Settings shows the link with a Test.
 - **Hand off and advice.** The `escalate` tool hands one task to a higher tier (the person sets next, any or only when asked); Anthropic's advisor tool lets a higher tier send a plan, at most two an answer.
-- **Chats** stream as server-sent events (`POST /chat`); closing the request stops the answer and keeps what was said. Past 150k tokens, or on `/compact`, the history sent to the model becomes a summary. Run `assistant.purge()` once a day to drop chats 30 days after their last message.
+- **Chats** run on the agent (`./agent`, `LumenAgent`, below): the app routes `POST /chat` and each chat's reads, cards and Undo to its own agent, and `assistantRoutes` answers `POST /chat` with 410 `moved`. Chats saved by the old turn loop stay readable (`GET /chats`, `GET|DELETE /chats/:id`) until `assistant.purge()` drops them 30 days after their last message.
 - **Background work** an app runs for a person (a score, a summary) is `assistant.complete(caller, { task, system, prompt, images?, maxTokens })`: one answer on the task's tier (`tasks`, so the person picks its model in Settings ▸ Models), no chat and no tools (`images`, base64 with their media type, are read with the prompt: a scanned page, a screenshot), billed to their payer and counted in their spend and allowance like a chat turn. It throws `AssistantError` `not_connected`, `app_cap` or `own_cap` when nobody can pay, so the caller waits and tries later.
 
 ### Commands, `@` and `#`

package/dist/assistant/engine.d.ts

@@ -1,4 +1,4 @@
-import type { AllowanceRequest, AllowanceState, AllowanceUnit, AssistantAccess, AssistantChat, AssistantChatRow, AssistantMessage, AssistantOwnWay, AssistantProvider, AssistantStatus, DraftItem, StepItem } from '@columenlabs/lumen-ui-types/assistant';
+import type { AllowanceRequest, AllowanceState, AllowanceUnit, AssistantAccess, AssistantChat, AssistantChatRow, AssistantMessage, AssistantOwnWay, AssistantProvider, AssistantStatus } from '@columenlabs/lumen-ui-types/assistant';
 import type { AgentTurnEnd, AgentTurnPlan } from '../agent/agent.js';
 import { type BearingsExtra, type BearingsNow } from './bearings.js';
 import { type ModelDef, type TaskDef, type TierDef } from './models.js';
@@ -173,7 +173,6 @@ export declare class AssistantError extends Error {
     readonly status: number;
     constructor(message: string, code: string, status?: number);
 }
-type Emit = (event: string, data: unknown) => void;
 /** What a Think turn calls this turn: what one turn asks besides the message itself. */
 export interface AgentTurnInput {
     message: string;
@@ -262,37 +261,17 @@ export declare class Assistant {
     removeChat(caller: Caller, id: string): Promise<void>;
     /** Deletes chats past `keepDays` since their last message; run it once a day. */
     purge(): Promise<number>;
-    private writeChat;
     /** Opens the tools the person allows: each group's, then the web's. */
     /** The tool groups (and the web) at the person's access, not opened yet. */
     private sourcesOf;
-    private openTools;
-    private toolsFor;
-    /** `batch`: any of the reads, up to BATCH_MAX at once, as one step. Null with no reads. */
-    private batchTool;
-    /** One answer as server-sent events. Abort `signal` to stop it. */
-    turnStream(caller: Caller, req: AssistantMessage, signal?: AbortSignal): ReadableStream<Uint8Array>;
-    turn(caller: Caller, req: AssistantMessage, emit: Emit, signal?: AbortSignal): Promise<void>;
     /** What the kit adds to the app's instructions: tools, drafts, hand off, advice, limits. */
     private rules;
     /** The advisor for this answer, or null when off. Never weaker than the model it advises. */
     private advisorFor;
-    private escalateTool;
     /** What the model is asked: an app command's prompt, else the message as typed. */
     private expand;
     /** The tiers the person's message asks for by name ("go deeper" is the next one up). */
     private askedFor;
-    private handOff;
-    /** One tool call: a draft card for a write, else the call itself, timed. */
-    private runTool;
-    /** A batch of reads: each runs as its own call (the same read twice runs once), in parallel, shown as one step. */
-    private runBatch;
-    /** Model calls and tool rounds until the model answers; returns its words. */
-    private loop;
-    /** The loop on OpenAI's Responses API: the same tools, Stop, caps and rounds as Claude's. */
-    private loopOpenAI;
-    /** The loop on Anthropic's Messages API, with the advisor and prompt caching. */
-    private loopClaude;
     /** Swaps the history for a short summary. False with nothing to compact. */
     /**
      * One plain answer from OpenAI, metered on `s`: no tools, no chat. Streamed and read from the raw
@@ -300,7 +279,6 @@ export declare class Assistant {
      * output cap and may send its words only as deltas.
      */
     private openaiOnce;
-    private compact;
     /**
      * One prompt answered on a task's tier as the person: no chat, no tools. It is for background
      * work an app runs for someone (a job's fit score, a summary), billed to their payer and capped
@@ -320,8 +298,6 @@ export declare class Assistant {
         usd: number;
         model: string;
     }>;
-    /** How the person's cards ended since the last answer, once each. */
-    private cardNews;
     /** Starts a person's ChatGPT plan sign-in: the address to open in a new tab. */
     startSignin(caller: Caller, provider: AssistantProvider): Promise<{
         url: string;
@@ -353,10 +329,5 @@ export declare class Assistant {
         detail: string;
         at: number;
     }>;
-    /** Saves (runs, as the person) or dismisses a drafted card. Access is checked again first. */
-    settleDraft(caller: Caller, chatId: string, draftId: string, action: 'save' | 'dismiss'): Promise<DraftItem>;
-    /** Takes back one change a write made at once, through its group's `undo`. */
-    undoWrite(caller: Caller, chatId: string, stepId: string): Promise<StepItem>;
 }
 export declare function createAssistant(o: AssistantOptions): Assistant;
-export {};