@alisio/core 0.1.0-alpha.10 → 0.1.0-alpha.11

package/README.md

@@ -1,9 +1,24 @@
 # @alisio/core
 
-Embeddable core of [Alisio](https://github.com/GustavoGutierrez/alisio): the agent tool loop, structured
-context compaction, the OpenAI-compatible provider (Chat Completions and Responses), local tools with
-explicit permissions, the MCP client, the plugin host (with hook timeouts and failure isolation) and a
-SQLite session store. Runs on Node.js >= 22.16 (`node:sqlite` with FTS5) and on Bun.
+**The embeddable core of [Alisio](https://github.com/GustavoGutierrez/alisio): a provider-agnostic
+agent you can drive from your own program.** No TUI, no CLI — just the tool loop, compaction, MCP
+and plugin host as a library.
+
+## What it is
+
+`@alisio/core` wires the agent tool loop, structured context compaction, the OpenAI-compatible
+provider (Chat Completions and Responses), local tools behind explicit permissions, the MCP client,
+the plugin host (hook timeouts and failure isolation) and a SQLite session store into one
+`createApplication` entry point. It runs on Node.js >= 22.16 (`node:sqlite` with FTS5) and on Bun,
+and uses only portable Node APIs.
+
+## Installation
+
+```sh
+npm i @alisio/core        # or: pnpm add @alisio/core · bun add @alisio/core
+```
+
+## Quick start
 
 ```ts
 import { createApplication } from "@alisio/core";
@@ -18,8 +33,38 @@ try {
 }
 ```
 
+## What you get
+
+- **Runner**: `AgentRunner` with turn limits, timeouts, token budgets and versioned `RunEvent`
+  output (`schemaVersion: 1`).
+- **Context compaction**: `planCompaction`, `summarize`, `renderCheckpoint`,
+  `shouldCompactContext` and checkpoint helpers; memory plugins hook in via `CompactionHooks`.
+- **Providers**: `ProviderRegistry` / `ActiveProvider` for OpenAI-compatible, DeepSeek, OpenCode
+  Console and OpenCode Go; `ProviderSettingsStore` for non-secret profiles plus a separate
+  credentials store.
+- **Local tools**: reads by default, `--allow-write`/`--allow-process`-style policy, path checks
+  and standard tools (`ToolRegistry`, `registerStandard`).
+- **MCP**: `McpConnector`, server discovery and tool projection.
+- **Plugin host**: `PluginHost` with built-in plugin catalogs, npm install (`installPlugin`,
+  `cliInstall`), hook timeouts and failure isolation.
+- **Sessions**: `SQLiteStore` with reconciliation and crash recovery.
+- **Skills and prompts**: `Skills`, `ProjectContext` (`AGENTS.md`), `loadPromptTemplates`.
+- **Trust**: `resolveTrust` / `setTrust` / `listTrust` for per-directory project trust.
+- **Startup screen**: reusable `renderStartup` sections and the default mascot.
+
 Built-in plugins are opt-in for embedders: pass `builtins` (the `alisio` CLI wires
-`@alisio/plugin-memory`). See the [architecture](https://gustavogutierrez.github.io/alisio/architecture) and
-[configuration](https://gustavogutierrez.github.io/alisio/configuration) docs.
+`@alisio/plugin-memory` and `@alisio/plugin-subagents`).
+
+## Docs
+
+Architecture: <https://gustavogutierrez.github.io/alisio/architecture> ·
+Configuration: <https://gustavogutierrez.github.io/alisio/configuration>.
+
+## Requirements
+
+Node.js **>= 22.16** or Bun **>= 1.4.2**.
+
+## License
 
-Maintainer: Gustavo Gutiérrez · License: MIT
+MIT. Maintained by Gustavo Gutiérrez Mercado. Source: <https://github.com/GustavoGutierrez/alisio> ·
+npm: <https://www.npmjs.com/settings/alisio/packages>.

package/dist/config.js

@@ -151,7 +151,7 @@ const configObjectSchema = z
         .default(() => ({ nativeToolType: "web_search" })),
     limits: z
         .object({
-        maxTurns: z.number().int().min(1).max(100).default(20),
+        maxTurns: z.number().int().min(1).max(100).default(100),
         timeoutMs: z.number().int().min(100).default(300000),
         maxContextChars: z.number().int().positive().default(800000),
         /**
@@ -163,7 +163,7 @@ const configObjectSchema = z
         maxTokens: z.number().int().positive().optional(),
     })
         .default(() => ({
-        maxTurns: 20,
+        maxTurns: 100,
         timeoutMs: 300000,
         maxContextChars: 800000,
         maxOutputTokens: 16384,

package/dist/core/runner.js

@@ -348,7 +348,8 @@ export class AgentRunner {
             emit("run_started", { model });
             const budget = options.maxTokens ?? o.maxTokens ?? defaultTokenBudget(o.contextWindow?.(model));
             const compaction = o.compaction ?? {};
-            for (let turn = 0; turn < (options.maxTurns ?? o.maxTurns ?? 20); turn++) {
+            const maxTurns = options.maxTurns ?? o.maxTurns ?? 100;
+            for (let turn = 0; turn < maxTurns; turn++) {
                 combined.throwIfAborted();
                 // Input queued while the run was working (e.g. a parent's message to a child).
                 if (turn > 0)
@@ -606,7 +607,12 @@ export class AgentRunner {
                 if (tokens >= budget)
                     throw new Error("Token budget exhausted");
             }
-            throw new Error("Maximum turns reached");
+            // Turn cap reached. This is NOT a failure: everything produced up to this point stays in
+            // the transcript and the run returns a successful-but-marked partial result, so the user
+            // can simply prompt again to continue in the same session. The real hard stops remain the
+            // token budget (`maxTokens`) and the timeout; the turn count is a safety rail.
+            emit("run_turns_exceeded", { turns: maxTurns, maxTurns });
+            return { sessionId, text: lastText, status: "turns-exceeded", usage: usageTotal };
         }
         catch (error) {
             // On cancellation report the abort reason, not the transport's secondary error.

package/dist/sessions/children.js

@@ -160,8 +160,18 @@ export class ChildSessions {
             });
             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/version.d.ts

@@ -1,7 +1,9 @@
 /**
  * Reads the @alisio/core package version at runtime so the MCP client metadata stays in sync
- * with the published package. Resolves the manifest relative to the module (`src/version.ts` →
- * `../package.json` in the source tree; `dist/version.js` → `../package.json` when installed).
- * Standalone binaries inject ALISIO_PACKAGE_VERSION at build time (scripts/binary-build.ts).
+ * with the published package. The manifest is resolved by walking UP from the module directory
+ * until a package.json with a string `version` is found (bounded, any depth: module, then up to
+ * 8 parents), so a deeply nested call site like `src/mcp/connector.ts` resolves the same
+ * manifest as `src/version.ts`. Standalone binaries inject ALISIO_PACKAGE_VERSION at build time
+ * (scripts/binary-build.ts).
  */
 export declare function loadVersion(fromHere: string): string;

package/dist/version.js

@@ -6,19 +6,48 @@ import { fileURLToPath } from "node:url";
  * A development marker, never a publish literal: it cannot silently desync from the package.
  */
 const FALLBACK = "dev";
+/**
+ * How many parent directories the loader walks up before giving up. Bounded so a missing
+ * manifest can never make the lookup climb an unbounded path.
+ */
+const MAX_PARENT_HOPS = 8;
+/**
+ * Walks up from `dir` looking for a package manifest. Returns the version of the nearest
+ * manifest that declares a string `version`. `undefined` when no manifest with a version is
+ * reached within the bound.
+ */
+function findManifestVersion(dir) {
+    let nearest;
+    let current = dir;
+    for (let hop = 0; hop <= MAX_PARENT_HOPS; hop++) {
+        try {
+            const parsed = JSON.parse(readFileSync(join(current, "package.json"), "utf8"));
+            if (typeof parsed.version === "string" && parsed.version)
+                nearest ??= parsed.version;
+        }
+        catch {
+            // No manifest here; keep walking up.
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            break; // Filesystem root.
+        current = parent;
+    }
+    return nearest;
+}
 /**
  * Reads the @alisio/core package version at runtime so the MCP client metadata stays in sync
- * with the published package. Resolves the manifest relative to the module (`src/version.ts` →
- * `../package.json` in the source tree; `dist/version.js` → `../package.json` when installed).
- * Standalone binaries inject ALISIO_PACKAGE_VERSION at build time (scripts/binary-build.ts).
+ * with the published package. The manifest is resolved by walking UP from the module directory
+ * until a package.json with a string `version` is found (bounded, any depth: module, then up to
+ * 8 parents), so a deeply nested call site like `src/mcp/connector.ts` resolves the same
+ * manifest as `src/version.ts`. Standalone binaries inject ALISIO_PACKAGE_VERSION at build time
+ * (scripts/binary-build.ts).
  */
 export function loadVersion(fromHere) {
     if (process.env.ALISIO_PACKAGE_VERSION)
         return process.env.ALISIO_PACKAGE_VERSION;
     try {
-        const manifest = join(dirname(fileURLToPath(fromHere)), "..", "package.json");
-        const parsed = JSON.parse(readFileSync(manifest, "utf8"));
-        return typeof parsed.version === "string" && parsed.version ? parsed.version : FALLBACK;
+        return findManifestVersion(dirname(fileURLToPath(fromHere))) ?? FALLBACK;
     }
     catch {
         return FALLBACK;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alisio/core",
-  "version": "0.1.0-alpha.10",
+  "version": "0.1.0-alpha.11",
   "description": "Embeddable provider-agnostic Alisio agent core: tool loop, context compaction, local tools, MCP, plugin host and SQLite session store. Runs on Node >=22.16 and Bun.",
   "author": "Gustavo Gutiérrez",
   "license": "MIT",
@@ -41,7 +41,7 @@
     "node": ">=22.16"
   },
   "dependencies": {
-    "@alisio/sdk": "0.1.0-alpha.6",
+    "@alisio/sdk": "0.1.0-alpha.7",
     "@mixmark-io/domino": "2.2.0",
     "@modelcontextprotocol/client": "2.1.0",
     "ajv": "8.20.0",