@alisio/core 0.1.0-alpha.8 → 0.1.0

package/dist/sessions/children.js

@@ -87,6 +87,7 @@ export class ChildSessions {
             ...(spec.maxTurns ? { maxTurns: spec.maxTurns } : {}),
             ...(spec.timeoutMs ? { timeoutMs: spec.timeoutMs } : {}),
             ...(spec.maxTokens ? { maxTokens: spec.maxTokens } : {}),
+            ...(spec.maxOutputTokens ? { maxOutputTokens: spec.maxOutputTokens } : {}),
         };
         const child = this.o.store.createChild({
             ...(spec.id ? { id: spec.id } : {}),
@@ -147,6 +148,10 @@ export class ChildSessions {
                     write: caps.write,
                     process: caps.process,
                     external: root.external && !caps.readOnly,
+                    // --allow-analysis carries to children whose process permission is not narrowed.
+                    ...(root.analysis && !caps.readOnly && (spec.permission?.process ?? "allow") === "allow"
+                        ? { analysis: true }
+                        : {}),
                 },
                 approvals: caps.approvals,
                 label: this.label(id),
@@ -154,12 +159,23 @@ export class ChildSessions {
                 context: this.o.contextFor(session.workspace),
                 ...(spec.maxTurns ? { maxTurns: spec.maxTurns } : {}),
                 ...(spec.maxTokens ? { maxTokens: spec.maxTokens } : {}),
+                ...(spec.maxOutputTokens ? { maxOutputTokens: spec.maxOutputTokens } : {}),
                 ...(spec.timeoutMs ? { timeoutMs: spec.timeoutMs } : {}),
             });
             usage.input += result.usage.input;
             usage.output += result.usage.output;
+            // A child that hit its turn limit still produced a usable partial result: it completes
+            // with a turnsExceeded marker instead of failing, so orchestration treats the text as
+            // partial output. state "failed" stays reserved for real errors/aborts.
+            const turnsExceeded = result.status === "turns-exceeded";
             this.o.store.updateSession(id, { status: "completed", usage });
-            return { id, status: "completed", text: result.text, usage };
+            return {
+                id,
+                status: "completed",
+                text: result.text,
+                usage,
+                ...(turnsExceeded ? { turnsExceeded: true } : {}),
+            };
         }
         catch (error) {
             const aborted = this.cancelled.has(id) || signals.some((s) => s.aborted);

package/dist/sessions/side-questions.d.ts

@@ -0,0 +1,57 @@
+/**
+ * `/btw` side questions: a question about a session answered by one separate, tool-less model
+ * call that sees the session's active history, without becoming part of the conversation.
+ *
+ * Guarantees: nothing is written to `messages`, `tool_calls`, `runs`, the durable `events` or the
+ * session usage, and the session lock is never claimed, so a side question may run while a run
+ * is active (it has its own abort signal). The only thing persisted is this service's own
+ * history, in `plugin_state` under the reserved namespace `core:btw` (plugin ids cannot contain
+ * `:`, so no plugin can read or overwrite it), keyed by session id and capped to the newest
+ * `SIDE_QUESTION_HISTORY_LIMIT` entries.
+ */
+import type { Message, SideQuestionEntry } from "@alisio/sdk";
+import type { AgentRunner } from "../core/runner.ts";
+export type { SideQuestionEntry };
+/** `plugin_state.plugin` value of the side-question history (never a valid plugin id). */
+export declare const SIDE_QUESTIONS_NAMESPACE = "core:btw";
+export declare const SIDE_QUESTION_HISTORY_LIMIT = 20;
+export declare const SIDE_QUESTION_MAX_CHARS = 4000;
+/** The line every surface prints for `/btw` without a question and without any history. */
+export declare const SIDE_QUESTION_USAGE = "Usage: /btw <question>";
+export declare const SIDE_QUESTION_DESCRIPTION = "Ask a side question about the current session without adding to the conversation.";
+export declare const SIDE_QUESTION_INSTRUCTIONS: string;
+interface StateStore {
+    getState(plugin: string, key: string): unknown;
+    setState(plugin: string, key: string, value: unknown): void;
+}
+export interface SideQuestionsOptions {
+    runner: Pick<AgentRunner, "sideContext">;
+    /** Where the history lives (the SQLite store's `plugin_state`). */
+    state: StateStore;
+    now?: () => number;
+    id?: () => string;
+}
+/**
+ * The transcript lines for the side call, newest kept first: when the whole history does not fit
+ * `budget` characters, the oldest messages are dropped (and counted in a leading marker). The
+ * newest message alone is clipped from its start if it is still too large.
+ */
+export declare function sideTranscript(messages: Message[], budget: number): string;
+export declare class SideQuestions {
+    private readonly options;
+    private readonly now;
+    private readonly newId;
+    constructor(options: SideQuestionsOptions);
+    /** The session's side questions, oldest first (newest last). */
+    history(sessionId: string): SideQuestionEntry[];
+    /**
+     * Answers `question` about the session with one tool-less call of the session's model and
+     * records it in the history. Throws on an empty or oversized question, on cancellation (the
+     * signal's reason) and on provider failures (nothing is recorded then).
+     */
+    ask(sessionId: string, question: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<SideQuestionEntry>;
+}
+/** Plain Markdown for one entry (`position` is 1-based): readline, API callers and `/btw`. */
+export declare function formatSideQuestion(entry: SideQuestionEntry, position: number, total: number): string;

package/dist/sessions/side-questions.js

@@ -0,0 +1,161 @@
+import { serializeForSummary } from "../core/compaction.js";
+/** `plugin_state.plugin` value of the side-question history (never a valid plugin id). */
+export const SIDE_QUESTIONS_NAMESPACE = "core:btw";
+export const SIDE_QUESTION_HISTORY_LIMIT = 20;
+export const SIDE_QUESTION_MAX_CHARS = 4_000;
+/** The line every surface prints for `/btw` without a question and without any history. */
+export const SIDE_QUESTION_USAGE = "Usage: /btw <question>";
+export const SIDE_QUESTION_DESCRIPTION = "Ask a side question about the current session without adding to the conversation.";
+/** Per-message clip of the transcript the side call sees (as in compaction summaries). */
+const MAX_ITEM_CHARS = 4_000;
+export const SIDE_QUESTION_INSTRUCTIONS = [
+    "The user is asking a quick side question (/btw) about the session transcript below.",
+    "It is NOT part of the conversation: answer it directly and concisely from the transcript and",
+    "your general knowledge. You have no tools in this reply, so do not take or promise any",
+    "action, do not continue the task and do not call tools; if the transcript does not contain",
+    "the answer, say so briefly.",
+].join(" ");
+/**
+ * The transcript lines for the side call, newest kept first: when the whole history does not fit
+ * `budget` characters, the oldest messages are dropped (and counted in a leading marker). The
+ * newest message alone is clipped from its start if it is still too large.
+ */
+export function sideTranscript(messages, budget) {
+    const lines = [];
+    let used = 0;
+    let omitted = 0;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        const text = serializeForSummary([message], MAX_ITEM_CHARS);
+        if (used + text.length + 1 > budget) {
+            if (lines.length)
+                omitted = i + 1;
+            else {
+                // Even the newest message alone is too large: keep its end (the most recent part).
+                lines.push(text.slice(Math.max(0, text.length - budget)));
+                omitted = i;
+            }
+            break;
+        }
+        lines.unshift(text);
+        used += text.length + 1;
+    }
+    if (omitted > 0)
+        lines.unshift(`[${omitted} earlier messages omitted to fit the context budget]`);
+    return lines.join("\n");
+}
+const isEntry = (value) => !!value &&
+    typeof value === "object" &&
+    typeof value.id === "string" &&
+    typeof value.question === "string" &&
+    typeof value.answer === "string";
+export class SideQuestions {
+    options;
+    now;
+    newId;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? Date.now;
+        this.newId = options.id ?? (() => crypto.randomUUID());
+    }
+    /** The session's side questions, oldest first (newest last). */
+    history(sessionId) {
+        let stored;
+        try {
+            stored = this.options.state.getState(SIDE_QUESTIONS_NAMESPACE, sessionId);
+        }
+        catch {
+            return [];
+        }
+        return Array.isArray(stored) ? stored.filter(isEntry) : [];
+    }
+    /**
+     * Answers `question` about the session with one tool-less call of the session's model and
+     * records it in the history. Throws on an empty or oversized question, on cancellation (the
+     * signal's reason) and on provider failures (nothing is recorded then).
+     */
+    async ask(sessionId, question, options = {}) {
+        const text = question.trim();
+        if (!text)
+            throw new Error(SIDE_QUESTION_USAGE);
+        if (text.length > SIDE_QUESTION_MAX_CHARS)
+            throw new Error(`Side questions are limited to ${SIDE_QUESTION_MAX_CHARS} characters`);
+        const side = await this.options.runner.sideContext(sessionId);
+        const signal = AbortSignal.any([
+            AbortSignal.timeout(side.timeoutMs),
+            ...(options.signal ? [options.signal] : []),
+        ]);
+        signal.throwIfAborted();
+        const instructions = `${side.instructions}\n\n${SIDE_QUESTION_INSTRUCTIONS}`;
+        // The request must fit both the char budget and (when known) the model window, leaving room
+        // for the answer; ~3 chars per token keeps a conservative margin over the usual ~4.
+        const windowChars = side.contextWindow
+            ? Math.max(0, side.contextWindow - side.maxOutputTokens) * 3
+            : Number.POSITIVE_INFINITY;
+        const budget = Math.max(2_000, Math.min(side.maxContextChars, windowChars) - instructions.length - text.length - 200);
+        const transcript = sideTranscript(side.messages, budget);
+        const prompt = transcript
+            ? `<transcript>\n${transcript}\n</transcript>\n\nSide question: ${text}`
+            : `(The session has no messages yet.)\n\nSide question: ${text}`;
+        let answer = "";
+        let completed = false;
+        let truncated = false;
+        let usage = { input: 0, output: 0 };
+        try {
+            for await (const event of side.provider.stream({
+                instructions,
+                messages: [{ role: "user", text: prompt }],
+                tools: [],
+                maxOutputTokens: side.maxOutputTokens,
+                signal,
+                model: side.model,
+                sessionId,
+                ...(side.reasoningEffort ? { reasoningEffort: side.reasoningEffort } : {}),
+            })) {
+                signal.throwIfAborted();
+                if (event.type === "text_delta")
+                    answer += event.delta;
+                else if (event.type === "completed") {
+                    completed = true;
+                    truncated = event.message.truncated === true;
+                    answer = event.message.text || answer;
+                    if (event.usage)
+                        usage = { input: event.usage.input, output: event.usage.output };
+                }
+            }
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw signal.reason ?? error;
+            throw new Error(`Side question failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        signal.throwIfAborted();
+        if (!completed)
+            throw new Error("Side question failed: the provider did not complete");
+        answer = answer.trim();
+        if (!answer)
+            throw new Error("Side question failed: the model returned an empty answer");
+        const entry = {
+            id: this.newId(),
+            question: text,
+            answer,
+            model: side.model,
+            usage,
+            createdAt: this.now(),
+            ...(truncated ? { truncated: true } : {}),
+        };
+        const next = [...this.history(sessionId), entry].slice(-SIDE_QUESTION_HISTORY_LIMIT);
+        this.options.state.setState(SIDE_QUESTIONS_NAMESPACE, sessionId, next);
+        return entry;
+    }
+}
+/** Plain Markdown for one entry (`position` is 1-based): readline, API callers and `/btw`. */
+export function formatSideQuestion(entry, position, total) {
+    return [
+        `**btw ${position}/${total}** · ${entry.question.replace(/\s+/g, " ")}`,
+        "",
+        entry.answer,
+        "",
+        `_${entry.model} · ${entry.usage.input} in · ${entry.usage.output} out tokens${entry.truncated ? " · truncated" : ""}_`,
+    ].join("\n");
+}

package/dist/startup/screen.js

@@ -42,6 +42,7 @@ export function welcomeSection(ctx) {
 export function infoSection(ctx, width) {
     const t = ctx.terminal;
     const label = sgr(t.color, "2");
+    const pad = " ".repeat(2);
     const rows = [];
     if (ctx.model)
         rows.push(["model", ctx.model]);
@@ -54,9 +55,9 @@ export function infoSection(ctx, width) {
     rows.push(["plugins", plugins ? `${plugins} loaded` : "none"]);
     const labelWidth = Math.min(12, Math.max(...rows.map(([l]) => l.length)) + 1);
     return rows.map(([l, v]) => {
-        const room = Math.max(1, width - labelWidth - 1);
+        const room = Math.max(1, width - labelWidth - 1 - 4);
         const value = l === "cwd" ? shortenPath(v, room) : truncate(v, room);
-        return `${label(padEnd(l, labelWidth))} ${value}`;
+        return `${pad}${label(padEnd(l, labelWidth))} ${value}${pad}`;
     });
 }
 export function pluginsSection(ctx) {
@@ -72,12 +73,12 @@ export function pluginsSection(ctx) {
             .filter((p) => !p.categories?.includes("model-provider"))
             .map((p) => `${p.id}${p.builtin ? " (builtin)" : ""}`),
     ];
-    return [`${sgr(t.color, "2")("with")} ${names.join(", ")}`];
+    return [`  ${sgr(t.color, "2")("with")} ${names.join(", ")}  `];
 }
 export function tipsSection(ctx) {
     const t = ctx.terminal;
     const bullet = sgr(t.color, "33")(glyph(t, "›", ">"));
-    return ctx.tips.map((tip) => `${bullet} Tip: ${tip}`);
+    return ctx.tips.map((tip) => `  ${bullet} Tip: ${tip}  `);
 }
 export function mascotSection(ctx) {
     return [ctx.mascot.render({ terminal: ctx.terminal, version: ctx.version })].flat();
@@ -110,7 +111,7 @@ export const DefaultStartupScreen = {
             ...pluginsSection(ctx),
         ];
         const body = side ? composeSideBySide(mascot, info, columns) : [...mascot, ...info];
-        const rule = sgr(ctx.terminal.color, "2")(glyph(ctx.terminal, "─", "-").repeat(Math.min(columns, 60)));
+        const rule = sgr(ctx.terminal.color, "2")(glyph(ctx.terminal, "─", "-").repeat(columns - 2));
         return [...body, "", ...tipsSection(ctx), rule].map((line) => truncate(line, columns));
     },
 };

package/dist/tools/analysis.d.ts

@@ -0,0 +1,37 @@
+import type { DatasetService } from "../analysis/data/datasets.ts";
+import type { AnalysisJobs } from "../analysis/jobs.ts";
+import type { OciRuntime } from "../analysis/oci.ts";
+import type { AnalysisRerun } from "../analysis/rerun.ts";
+import { type AnalysisRuntimeManager } from "../analysis/runtime-manager.ts";
+import { type ArtifactStore } from "../artifacts/store.ts";
+import type { ToolRegistry } from "../core/registry.ts";
+export declare const NOT_SANDBOXED = "Managed Python is not a sandbox: the script runs with your user permissions and can read your files and use the network.";
+export interface AnalysisLimits {
+    timeoutMs: number;
+    maxLogBytes: number;
+}
+export interface AnalysisToolDeps {
+    store: ArtifactStore;
+    jobs: AnalysisJobs;
+    /** Discovery (`interpreter`) and, for the optional extras, `hasExtras` / `installExtras`. */
+    runtime: Pick<AnalysisRuntimeManager, "interpreter"> & Partial<Pick<AnalysisRuntimeManager, "hasExtras" | "installExtras">>;
+    /** Container mode (`analysis.runtime: "oci"`), read when each call starts. */
+    oci?: {
+        mode(): "managed" | "oci";
+        runtime(): OciRuntime;
+    };
+    /** Rerun of an earlier execution (`rerunOf`). */
+    rerun?: AnalysisRerun;
+    /** Datasets of the session: `inputs: [{ datasetId }]` copies the dataset's SQLite file. */
+    datasets?: DatasetService;
+    rootOf: (sessionId: string) => string;
+    limits: AnalysisLimits;
+    /** Startup facts for the description (stat only; no process was launched). */
+    startup: {
+        candidates: boolean;
+        extras: string[];
+    };
+}
+/** `48 KB`, `1.2 MB`. */
+export declare function formatBytes(bytes: number): string;
+export declare function registerAnalysisTools(registry: ToolRegistry, deps: AnalysisToolDeps): void;