@nylorun/create-agent 0.6.0-beta → 0.7.0-beta

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.7.0-beta
+
+### Minor Changes
+
+- c0e74f1: Migrate the creator to the SDK registry, separate local Runtime and connected executor. Replace the Hono app template with a text-and-tool starter and canonical session Studio.
+- 41e613c: Ship the local SDK registry workflow with an independent SQLite Runtime, connected tool executor, authenticated Studio proxy, and a text-and-tool starter. Replace the legacy Hono starter and AG-UI transport. Require Node 24 and include the SDK in exact release compatibility pins.
+
+  Break the Harness execution import from `/engine` to `/run` and rename hosted execution APIs to durable execution APIs, including RunBinding, BoundRunOptions, and createRunState. Update all consumers without compatibility aliases; retain persisted checkpoint fields and version pins.
+
+- 2898d02: Extract shared definitions and contracts into core and local orchestration into
+  CLI. Harness becomes execution-only; the SDK no longer installs the engine and
+  Runtime no longer depends on the SDK. Author applications through agents and
+  install cli for the unchanged nylorun commands. See the package architecture and
+  migration guide. Cloud installs published packages from npm independently.
+
+### Patch Changes
+
+- Update the tested Harness, SDK, Runtime, and Studio compatibility combination.
+
 ## 0.6.0-beta
 
 ### Minor Changes

package/README.md

@@ -4,56 +4,24 @@
 npm create @nylorun/agent@beta my-agent
 ```
 
-Creates a project that directly installs Harness and Runtime, with Studio as a development dependency. The project owns its Hono application in `src/index.ts`; Runtime supplies the agent router and lifecycle only.
+Creates a Node 24 project with `@nylorun/agents`, `@nylorun/cli`, Zod, and optional Studio. The registry in `agents/index.ts` exports agent definitions. The starter includes one ordinary `lookup_order` tool; ask “Look up order demo-123”.
 
-Creation installs dependencies, runs Runtime’s provider/model configuration wizard in the same terminal, then starts the application and Studio. Pass `-- --no-studio` for a headless project or `-- --no-open` to start Studio without opening a browser. `nylorun configure` connects a provider without importing the agent graph.
-
-## Configuration and recovery
-
-Use `-- --skip-config` to start development without configuring a provider:
-
-```sh
-npm create @nylorun/agent@beta my-agent -- --skip-config
-```
-
-Without interactive stdin and stdout, creation requires `--skip-config` and fails
-before creating files when it is missing. `--yes` only affects installation; it
-does not skip configuration. After skipping, run `npm run configure` inside the
-project in another terminal before sending a message. Development and Studio
-start immediately; provider configuration takes effect without restarting them.
-
-If configuration fails or is cancelled, development does not start and the
-created project is retained. Resume from its directory:
+Creation installs dependencies, runs provider configuration, and starts development. Use `-- --no-studio` for headless development or `-- --no-open` to suppress browser opening. Noninteractive creation requires `-- --skip-config`; configure the retained project before running it. Without provider settings startup reports `nylorun configure`. `--yes` affects installation only.
 
 ```sh
 cd my-agent
 npm run configure
 npm run dev
+npm run build
+npm start
 ```
 
-If installation failed, run `npm install` first. Ctrl-C exits with status 130;
-SIGTERM exits with status 143. Cancelling setup also cancels pending authentication.
-Configuration saves the provider selection and credentials; it does not make a
-model request to validate connectivity.
-
-## Maintaining examples
-
-`starter/` is the canonical project template. `compatibility.json` pins tested Harness, Runtime, and Studio versions. `examples.recipe.json` explicitly adds local package references and test dependencies. Persistence and media stay in the authored examples catalog.
-
-From the repository root:
-
-```sh
-npm run examples:sync
-npm install --prefix examples
-npm run examples:check
-```
-
-The renderer is shared by project creation, the isolated starter development runner, and examples synchronization. Sync owns shell files listed in `examples/.scaffold-manifest.json`, including `src/index.ts`, `package.json`, and TypeScript configuration; it never edits `agents/`, tests, other scripts, local model selection, credentials, or `.data/`. Edit generated configuration in the recipe or template. Conflicts with manual generated-file edits fail before any writes. CI checks the rendered shell and runs examples against the current stack. Package changes can require explicit adaptations in authored code; sync does not rewrite TypeScript imports.
+Development restarts the Runtime and connected executor on source changes. Compiled start uses `dist/agents/index.js` and runs headless. Studio can attach separately. Local Runtime credentials and SQLite are stored in gitignored `.nylorun/`. Model selection remains Runtime configuration in `.env`; definitions have no model provider or `agent.run()`.
 
-`npm run dev:starter` from the repository root previews a fresh project using local packages, including unpublished changes. Each preview has its own retained directory and provider configuration.
+`starter/` is the canonical template. `compatibility.json` pins core, harness, SDK, Runtime, Studio and CLI. The examples recipe adds local package dependencies. Run `npm run examples:sync` after template changes, then `npm install --prefix examples`. Sync preserves authored agents, tests, credentials, and local state; it rejects conflicting edits to generated files.
 
-Repository development: [contributing](../CONTRIBUTING.md). Package publication: [releasing](../RELEASING.md).
+The default examples registry contains the release starter. Advanced examples remain outside that registry for later migration.
 
-Generated projects use `nylorun dev`, with `--no-studio` and `--no-open` options, rather than a copied supervisor script. They contain one `tsconfig.json`; `npm run check` checks without emitting and `npm run build` emits to `dist/`. Repository examples add their own build configuration to exclude tests. Provider/model selection and API keys use a conventional `.env` file (`MODEL_PROVIDER`, `MODEL`, `MODEL_PROVIDER_API_KEY`, and optional `MODEL_PROVIDER_BASE_URL`). The starter exports its Hono app; `nylorun start` supplies the production Node launcher. OAuth state is optional in `.nylorun/auth.json`. See [Runtime migration instructions](../runtime/README.md#upgrading-an-existing-starter).
+After building, `node create-agent/scripts/smoke-starter.mjs` installs packed packages outside the workspace and checks the actual Studio/tool workflow, history, reload, source restart, compiled start, headless mode, and shutdown. It uses a deterministic fixture without live provider calls. Browser checks require Chrome (or `NYLORUN_CHROME_PATH`).
 
-To verify the packed starter after building all packages, run `node create-agent/scripts/smoke-starter.mjs` from the repository root. It installs candidate tarballs into a disposable project and checks type checking, production output, agent assets, development CORS, streaming, watch reload, and shutdown. Add `--serve` to keep the fixture Studio running for browser verification; stop it with Ctrl-C. It uses a deterministic model adapter and makes no provider calls.
+See [RELEASING](../RELEASING.md) for the Changesets beta workflow. Nothing is published by the smoke check.

package/compatibility.json

@@ -1,5 +1,8 @@
 {
-  "harness": "0.13.0-beta",
-  "studio": "0.5.0-beta",
-  "runtime": "0.5.0-beta"
+  "harness": "0.15.0-beta",
+  "studio": "0.6.0-beta",
+  "runtime": "0.6.0-beta",
+  "agents": "0.2.0-beta",
+  "core": "0.1.1-beta",
+  "cli": "0.1.1-beta"
 }

package/dist/compatibility.json

@@ -1,5 +1,8 @@
 {
-  "harness": "0.13.0-beta",
-  "studio": "0.5.0-beta",
-  "runtime": "0.5.0-beta"
+  "harness": "0.15.0-beta",
+  "studio": "0.6.0-beta",
+  "runtime": "0.6.0-beta",
+  "agents": "0.2.0-beta",
+  "core": "0.1.1-beta",
+  "cli": "0.1.1-beta"
 }

package/dist/contracts.d.ts

@@ -1,5 +1,8 @@
 export type Compatibility = Readonly<{
+    core: string;
+    cli: string;
     harness: string;
+    agents: string;
     studio: string;
     runtime: string;
 }>;

package/dist/scaffold.js

@@ -22,7 +22,10 @@ export async function starterFiles(compatibility, studio) {
                 await walk(absolute);
             else
                 files[templatePath(relative(root, absolute))] = (await readFile(absolute, "utf8"))
+                    .replaceAll("{{CORE_VERSION}}", compatibility.core)
+                    .replaceAll("{{CLI_VERSION}}", compatibility.cli)
                     .replaceAll("{{HARNESS_VERSION}}", compatibility.harness)
+                    .replaceAll("{{AGENTS_VERSION}}", compatibility.agents)
                     .replaceAll("{{RUNTIME_VERSION}}", compatibility.runtime)
                     .replaceAll("{{STUDIO_VERSION}}", compatibility.studio);
         }
@@ -36,7 +39,6 @@ export async function starterFiles(compatibility, studio) {
         manifest.scripts.dev = "nylorun dev --no-studio";
         delete manifest.scripts.studio;
         files["package.json"] = JSON.stringify(manifest, null, 2) + "\n";
-        files["README.md"] = files["README.md"].replace("`npm run dev` starts your app on port 3000, waits until its agent endpoint is ready, then starts Studio and opens it in your browser. Use `npm run dev -- --no-open` to start Studio without opening a browser. Run `npm run studio` in another terminal to attach Studio separately.", "`npm run dev` starts your app on port 3000.");
     }
     return Object.freeze(files);
 }

package/dist/starter/.env.example

@@ -1,6 +1,7 @@
-# Copy to .env and fill in a provider and model, or run npm run configure.
-MODEL_PROVIDER=
-MODEL=
-MODEL_PROVIDER_API_KEY=
-# For MODEL_PROVIDER=custom only:
-# MODEL_PROVIDER_BASE_URL=https://your-provider.example/v1
+# Prefer npm run configure; model configuration belongs to the Runtime.
+# MODEL_PROVIDER=...
+# MODEL=...
+# MODEL_PROVIDER_API_KEY=...
+# MODEL_PROVIDER_BASE_URL=... # only for a custom provider
+# PORT=8787
+# NYLORUN_IMPLEMENTATION_VERSION=dev

package/dist/starter/README.md

@@ -1,10 +1,23 @@
-# My agent
+# My Nylorun agent
 
-The creator configures a provider before starting development. For later sessions, run `npm run dev`. If setup was skipped with `--skip-config` or interrupted, run `npm run configure` first, then `npm run dev`.
-Edit agents under `agents/` and compose your Hono app in `src/index.ts`.
+Requires Node 24 and npm 11. Agent and tool definitions live in `agents/`. The CLI runs a separate SQLite Runtime and connects your tools through the SDK's authenticated SSE executor.
 
-`npm run dev` starts your app on port 3000, waits until its agent endpoint is ready, then starts Studio and opens it in your browser. Use `npm run dev -- --no-open` to start Studio without opening a browser. Run `npm run studio` in another terminal to attach Studio separately. `npm run build` creates `dist/`; deploy it alongside `package.json`, installed production dependencies, and environment variables, then run `npm start`.
+```sh
+npm run configure
+npm run dev
+```
 
-Development orchestration is provided by the installed `nylorun` CLI. Use `npm run dev -- --no-studio` for the application alone. Copy `.env.example` to `.env` and fill in `MODEL_PROVIDER`, `MODEL`, and `MODEL_PROVIDER_API_KEY`, or run `npm run configure`. Custom OpenAI-compatible providers also use `MODEL_PROVIDER_BASE_URL`. Hosting providers can supply these variables directly; no credential files are required for API keys. The single `tsconfig.json` builds your sources; `npm run check` checks types without emitting files.
+Open Studio and ask **Look up order demo-123**. The local tool returns `shipped`; Studio shows the tool call and assistant response. Model calls use your configured provider and may incur its usual charges.
 
-`src/index.ts` exports the Hono app. `nylorun dev` and `nylorun start` supply the Node server and load `.env` without overriding process variables. OAuth state, when used, lives in ignored `.nylorun/auth.json`. Sessions use memory storage by default and disappear on process restart. For a single Node host, explicitly configure `localSessions({ root: ".data/sessions" })` from `@nylorun/runtime/node`. Shared storage alone does not provide distributed scheduling. See https://docs.nylorun.com/docs/run-agents/deploy for hosting guidance.
+`npm run dev -- --no-open` avoids opening a browser. `--no-studio` runs headless. Use `npm run studio` to attach separately. Runtime defaults to `http://127.0.0.1:8787`; `PORT` changes it. Studio chooses a free port starting at 4161.
+
+```sh
+npm run build
+npm start
+```
+
+Compiled start runs Runtime and executor without Studio or watching. Studio can attach in a separate terminal. `agents/index.ts` exports the registry; there is no Hono app to maintain. Source edits restart the local development stack. Start a new session after changing definitions or implementations; active-session upgrades are not supported.
+
+Local credentials and SQLite live in gitignored `.nylorun/`. Keep this directory private. Credentials are generated automatically and kept out of browser configuration. Ordinary shutdown/restart preserves completed session history. `NYLORUN_IMPLEMENTATION_VERSION` defaults to `dev`; assign an explicit version when changing a versioned implementation.
+
+This beta supports local text and ordinary tools. Advanced waits, media, MCP, subagents, deployment, reconciliation and broad recovery guarantees are deferred. `NYLORUN_DEV_MODEL=fixture` is a credential-free release-check fixture for this starter; it is not a general model.

package/dist/starter/_gitignore

@@ -7,3 +7,5 @@ dist/
 
 # Legacy local settings remain private until migrated.
 config/model.json
+
+.nylorun/

package/dist/starter/agents/assistant/agent.ts

@@ -1,7 +1,19 @@
-import { Agent } from "@nylorun/harness";
+import { Agent, tool } from "@nylorun/agents";
+import { z } from "zod";
+
+const lookupOrder = tool({
+  name: "lookup_order",
+  description: "Look up a sample order by ID. Try demo-123.",
+  input: z.object({ orderId: z.string() }),
+  output: z.object({ orderId: z.string(), status: z.string() }),
+  async run({ orderId }) {
+    return { orderId, status: orderId === "demo-123" ? "shipped" : "not found" };
+  },
+});
 
 export const assistant = Agent({
   id: "assistant",
-  name: "Assistant",
-  instructions: ["You are helpful."],
+  name: "Order assistant",
+  instructions: "Help with orders. Always use lookup_order for order questions. Remember conversation context.",
+  tools: [lookupOrder],
 }).build();

package/dist/starter/package.json

@@ -4,21 +4,20 @@
   "private": true,
   "type": "module",
   "engines": {
-    "node": ">=22.19.0"
+    "node": ">=24.0.0"
   },
   "scripts": {
     "configure": "nylorun configure",
     "dev": "nylorun dev",
-    "studio": "nylorun studio --agent-url http://localhost:3000/agents",
+    "studio": "nylorun studio --runtime-url http://127.0.0.1:8787",
     "build": "node -e \"import('node:fs/promises').then(async ({rm,cp}) => { await rm('dist', { recursive: true, force: true }); await cp('agents', 'dist/agents', { recursive: true, filter: (source) => !source.endsWith('.ts') }); })\" && tsc -p tsconfig.json",
     "start": "nylorun start",
     "check": "tsc --noEmit"
   },
   "dependencies": {
-    "@nylorun/harness": "{{HARNESS_VERSION}}",
-    "@nylorun/runtime": "{{RUNTIME_VERSION}}",
-    "hono": "^4.13.7",
-    "zod": "^4.1.12"
+    "zod": "^4.5.4",
+    "@nylorun/agents": "{{AGENTS_VERSION}}",
+    "@nylorun/cli": "{{CLI_VERSION}}"
   },
   "devDependencies": {
     "@nylorun/studio": "{{STUDIO_VERSION}}",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nylorun/create-agent",
-  "version": "0.6.0-beta",
+  "version": "0.7.0-beta",
   "description": "Create a local Nylorun Harness agent project.",
   "type": "module",
   "license": "Apache-2.0",
@@ -26,7 +26,7 @@
     "provenance": true
   },
   "engines": {
-    "node": ">=22.19.0"
+    "node": ">=24.0.0"
   },
   "scripts": {
     "build": "npm run clean && node ../scripts/check-typescript-version.mjs && tsc -p tsconfig.json && node scripts/copy-compatibility.mjs",
@@ -45,6 +45,8 @@
     "@typescript/native": "npm:typescript@^7.0.2",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
     "vitest": "^5.0.0",
-    "zod": "^4.1.12"
+    "zod": "^4.1.12",
+    "@nylorun/core": "file:../core",
+    "@nylorun/agents": "file:../agents"
   }
 }

package/dist/starter/src/index.ts

@@ -1,23 +0,0 @@
-import { Hono } from "hono";
-import { Runtime, serveAgents } from "@nylorun/runtime";
-import { agents } from "../agents/index.js";
-
-const app = new Hono();
-
-app.get("/", (c) =>
-  c.json({
-    agents: agents.map((agent) => ({
-      id: agent.id,
-      name: agent.name,
-      manifest: agent.manifest,
-    })),
-  }),
-);
-
-const runtime = new Runtime();
-app.route(
-  "/agents",
-  serveAgents({ agents, runtime })
-);
-
-export default app;