@agentorg/cli 0.0.7 → 0.0.9

package/dist/node_modules/assistant/dist/src/chats.d.ts

@@ -13,12 +13,16 @@ type Input<M extends keyof (typeof chat)["methods"]> = z.output<(typeof chat)["m
 type Emitted<E extends keyof (typeof chat)["events"]> = z.input<(typeof chat)["events"][E]["payload"]>;
 export declare function createChats(options: {
     store: Store;
-    /** The agent's model, and what a request to it says and offers, as its looper asks for them. */
+    /**
+     * The agent's model, and what a request to it says and offers, as its looper asks for them;
+     * `voice` is the agent's own instructions, which its main loop speaks as.
+     */
     model: Model;
     request(): Promise<{
         instructions: string;
         tools: Tool[];
         model?: string | undefined;
+        voice?: string | undefined;
     }>;
     /** Whether the agent is stopped when its chats are first held. */
     stopped: boolean;
@@ -31,8 +35,11 @@ export declare function createChats(options: {
     log: Log;
 }): {
     /**
-     * Say a message in a chat, or in a new chat it starts. With no turn in the chat it starts one;
-     * a turn running there takes it at its next model request.
+     * Say a message in a chat, or in a new chat it starts. A message in a chat no work follows is
+     * put to the agent's main loop. When that answers it itself, the chat stays no work's, and its
+     * next message is put to the main loop too. When it gives it to new work or to work there is,
+     * the chat's messages are that work's from then on: with no turn of it running one starts a
+     * turn, and a turn running takes it at its next model request.
      */
     send({ chat, text }: Input<"send">): Promise<{
         chat: string;
@@ -77,14 +84,14 @@ export declare function createChats(options: {
      */
     stop: () => Promise<void>;
     start: () => void;
-    /** Go on with the turns that were cut off when the agent last ran, each once. */
+    /** Go on with what was cut off when the agent last ran, each once: turns, and messages waiting. */
     resume(): Promise<void>;
     /**
-     * Close for good: its turns are cut, and none starts after. They stay marked, so the engine
-     * that opens this store next goes on with them.
+     * Close for good: its turns are cut, and none starts after. They stay marked, as do messages
+     * no work has taken, so the engine that opens this store next goes on with them.
      */
     close: () => Promise<void>;
-    /** Settles when every chat's latest turn has written all it will. */
+    /** Settles when every piece of work's latest turn has written all it will. */
     settled(): Promise<void>;
     /** Streamed text of the model request running now. */
     delta(requestId: string, text: string): void;

package/dist/node_modules/assistant/dist/src/chats.js

@@ -106,10 +106,10 @@ export function createChats(options) {
     /** The chats, by id, once their entries are read. */
     const chats = new Map();
     let loaded;
-    /** The chats whose loops are at work now: the agent is working while there is one. */
-    const atWork = new Set();
-    const stateNow = () => ({ state: atWork.size > 0 ? "working" : "idle" });
-    /** The chats' loops: a chat is the looper's thread of the same name. */
+    /** Whether the agent is working, as its looper last said. */
+    let working = false;
+    const stateNow = () => ({ state: working ? "working" : "idle" });
+    /** The agent's loops: a chat is the looper's thread of the same name. */
     const looper = forChats(createLooper({
         store: forLooper(store),
         model: options.model,
@@ -122,22 +122,18 @@ export function createChats(options) {
                 emit.message({ ...message, chat: thread });
             },
             delta: (thread, id, text) => emit.delta({ chat: thread, id, text }),
-            status(thread, status) {
-                const was = atWork.size > 0;
-                if (status.state === "thinking" || status.state === "tool")
-                    atWork.add(thread);
-                else
-                    atWork.delete(thread);
-                // A turn that failed left its chat's message with no answer: the chat is told why,
-                // before the agent is said to be idle.
+            working(on) {
+                working = on;
+                emit.status(stateNow());
+            },
+            // A message in the chat got no answer: the chat is told why. The looper says this before
+            // it says the agent is idle.
+            failed(thread, { code, message }) {
                 const held = chats.get(thread);
-                if (status.state === "error" && held) {
-                    const { code, message } = status.detail;
-                    held.stored.problem = { code: head(code, 128), message: head(message, 2000) };
-                    told(held);
-                }
-                if (atWork.size > 0 !== was)
-                    emit.status(stateNow());
+                if (!held)
+                    return;
+                held.stored.problem = { code: head(code, 128), message: head(message, 2000) };
+                told(held);
             },
         },
         stopped: options.stopped,
@@ -267,8 +263,11 @@ export function createChats(options) {
     };
     return {
         /**
-         * Say a message in a chat, or in a new chat it starts. With no turn in the chat it starts one;
-         * a turn running there takes it at its next model request.
+         * Say a message in a chat, or in a new chat it starts. A message in a chat no work follows is
+         * put to the agent's main loop. When that answers it itself, the chat stays no work's, and its
+         * next message is put to the main loop too. When it gives it to new work or to work there is,
+         * the chat's messages are that work's from then on: with no turn of it running one starts a
+         * turn, and a turn running takes it at its next model request.
          */
         async send({ chat, text }) {
             if (chat !== undefined) {
@@ -332,18 +331,18 @@ export function createChats(options) {
          */
         stop: () => looper.stop(),
         start: () => looper.start(),
-        /** Go on with the turns that were cut off when the agent last ran, each once. */
+        /** Go on with what was cut off when the agent last ran, each once: turns, and messages waiting. */
         async resume() {
             // The chats first: what a turn says moves its chat in the list.
             await load();
             await looper.resume();
         },
         /**
-         * Close for good: its turns are cut, and none starts after. They stay marked, so the engine
-         * that opens this store next goes on with them.
+         * Close for good: its turns are cut, and none starts after. They stay marked, as do messages
+         * no work has taken, so the engine that opens this store next goes on with them.
          */
         close: () => looper.close(),
-        /** Settles when every chat's latest turn has written all it will. */
+        /** Settles when every piece of work's latest turn has written all it will. */
         async settled() {
             await loaded?.catch(() => undefined);
             await looper.settled();

package/dist/node_modules/assistant/dist/src/engine.js

@@ -29,9 +29,9 @@ export function startEngine(ctx, options) {
      */
     const request = async () => {
         const settings = ctx.slots.settings.bound ? await ctx.slots.settings.call.get({}) : undefined;
-        const told = settings
-            ? instructionsWith(settings.instructions, settings.skills)
-            : { instructions: options.instructions(), leftOut: [] };
+        // The agent's own instructions: who its main loop speaks as, with nothing of its skills.
+        const voice = settings ? settings.instructions : options.instructions();
+        const told = instructionsWith(voice, settings?.skills ?? []);
         const own = settings?.skills.length ? [skillTool(ctx.slots.settings)] : [];
         // In the order they came, each asked at once so one slow server delays only itself.
         const exposed = await Promise.all(ctx
@@ -41,7 +41,13 @@ export function startEngine(ctx, options) {
         const fitted = offered([...own, ...exposed.flatMap((one) => one.candidates)]);
         const leftOut = [...told.leftOut, ...exposed.flatMap((one) => one.leftOut), ...fitted.leftOut];
         report(leftOut);
-        return { instructions: told.instructions, tools: fitted.tools, model: await chosen(), leftOut };
+        return {
+            instructions: told.instructions,
+            tools: fitted.tools,
+            model: await chosen(),
+            voice,
+            leftOut,
+        };
     };
     /** The model slot as the looper asks it: what it refuses is told with its code. */
     const model = {
@@ -68,7 +74,7 @@ export function startEngine(ctx, options) {
      * settings answer, and no tools slot is away. As the agent starts, what it is bound to may not
      * be running yet, so this is looked at again whenever that may have changed: a slot's provider
      * is back, a tools slot is made or gone, or one says its tools changed. A tools slot that stays
-     * away holds them back; a message in a chat starts that chat's turn anyway.
+     * away holds them back; a message in a chat starts a turn anyway.
      */
     let wentOn = false;
     /** Each tools slot heard for its tools changing, with how to stop hearing it. */

package/dist/node_modules/chatgpt/dist/src/account.js

@@ -6,7 +6,7 @@ import { AGENT_NAME, AUTHORIZE, DYNAMIC_CLIENT, discover, GrantError, grant, ISS
 const PENDING_FOR = 10 * 60_000;
 const MAX_PENDING = 16;
 const REFRESH_BEFORE = 5 * 60_000;
-export const notSignedIn = () => new Refused("not_signed_in", "Not signed in to ChatGPT. Continue with ChatGPT to sign in.");
+export const notSignedIn = () => new Refused("not_signed_in", "Not signed in to ChatGPT. Sign in to it to go on.");
 export const notEligible = () => new Refused("ineligible", "This ChatGPT account isn't eligible to use its plan in this app. Signing in again won't change that.");
 const unreachable = () => new Refused("unavailable", "OpenAI couldn't be reached. Try again later.");
 const address = (url) => `${url.origin}${url.pathname}`;

package/dist/src/gateway.js

@@ -9,7 +9,6 @@ import { describeInterface, Refused } from "@agentorg/sdk";
 import { connect } from "@agentorg/sdk/client";
 import { WebSocketServer } from "ws";
 import { serveSocket } from "./api.js";
-import { callFolders } from "./folders.js";
 import { LIVE_MAX, pipeLive } from "./live.js";
 import { Notes } from "./notes.js";
 import { oauthRoute } from "./oauth.js";
@@ -123,8 +122,6 @@ export async function startApp(options) {
         async call(slot, method, input) {
             if (slot === "store")
                 return notes.call(method, input);
-            if (slot === "folders")
-                return callFolders(method, input);
             const exposed = Object.hasOwn(SLOTS, slot) ? undefined : exposedSlot(slot);
             if (!exposed && !Object.hasOwn(SLOTS, slot))
                 throw new Refused("invalid", `The person has no slot ${slot}.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentorg/cli",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "AgentOrg as one app: the Hub, the person's gateway and the shell, on loopback.",
   "license": "MIT",
   "repository": {

package/dist/node_modules/@agentorg/interfaces/dist/src/folders.d.ts

@@ -1,19 +0,0 @@
-import { z } from "zod";
-/** The most folders one answer names. */
-export declare const FOLDERS_MAX = 2000;
-/**
- * `folders@1`: the folders on the machine the app runs on, for a person choosing one. It names
- * folders and nothing else. `list` starts at the person's home folder; `parent` is absent at the
- * top. Refused `unknown` when there's no such folder, `invalid` for a path that isn't absolute.
- */
-export declare const folders: import("@agentorg/sdk").RpcInterface<"folders", {
-    list: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        path: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        path: z.ZodString;
-        parent: z.ZodOptional<z.ZodString>;
-        folders: z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-}, {}, 1>;

package/dist/node_modules/@agentorg/interfaces/dist/src/folders.js

@@ -1,25 +0,0 @@
-import { defineInterface, method } from "@agentorg/sdk";
-import { z } from "zod";
-/** The most folders one answer names. */
-export const FOLDERS_MAX = 2000;
-const Path = z.string().min(1).max(4096);
-/**
- * `folders@1`: the folders on the machine the app runs on, for a person choosing one. It names
- * folders and nothing else. `list` starts at the person's home folder; `parent` is absent at the
- * top. Refused `unknown` when there's no such folder, `invalid` for a path that isn't absolute.
- */
-export const folders = defineInterface({
-    name: "folders",
-    major: 1,
-    kind: "rpc",
-    methods: {
-        list: method({
-            input: z.object({ path: Path.optional() }),
-            output: z.object({
-                path: Path,
-                parent: Path.optional(),
-                folders: z.array(z.object({ name: z.string().max(4096) })).max(FOLDERS_MAX),
-            }),
-        }),
-    },
-});

package/dist/src/folders.d.ts

@@ -1,2 +0,0 @@
-/** One `folders@1` call, checked as a call through the Hub would be. */
-export declare function callFolders(method: string, input: unknown): Promise<unknown>;

package/dist/src/folders.js

@@ -1,45 +0,0 @@
-import { readdir, stat } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname, isAbsolute, join, normalize } from "node:path";
-import { FOLDERS_MAX, folders } from "@agentorg/interfaces";
-import { Refused } from "@agentorg/sdk";
-async function isFolder(at, entry) {
-    if (entry.isDirectory())
-        return true;
-    if (!entry.isSymbolicLink())
-        return false;
-    return stat(join(at, entry.name)).then((found) => found.isDirectory(), () => false);
-}
-async function list(path) {
-    if (path !== undefined && !isAbsolute(path))
-        throw new Refused("invalid", "A folder's path starts at the top of the disk.");
-    const at = path === undefined ? homedir() : normalize(path);
-    const entries = await readdir(at, { withFileTypes: true }).catch((error) => {
-        if (error.code === "ENOENT" || error.code === "ENOTDIR")
-            throw new Refused("unknown", "There's no such folder.");
-        throw new Refused("invalid", "That folder can't be read.");
-    });
-    // Dot folders stay out of the list, as in a file picker; a path can still be typed.
-    const shown = entries.filter((entry) => !entry.name.startsWith("."));
-    const kept = await Promise.all(shown.map((entry) => isFolder(at, entry)));
-    const names = shown
-        .filter((_, i) => kept[i])
-        .map((entry) => entry.name)
-        .sort((a, b) => a.localeCompare(b))
-        .slice(0, FOLDERS_MAX);
-    const parent = dirname(at);
-    return {
-        path: at,
-        ...(parent === at ? {} : { parent }),
-        folders: names.map((name) => ({ name })),
-    };
-}
-/** One `folders@1` call, checked as a call through the Hub would be. */
-export function callFolders(method, input) {
-    if (method !== "list")
-        throw new Refused("invalid", `folders has no method ${method}.`);
-    const parsed = folders.methods.list.input.safeParse(input);
-    if (!parsed.success)
-        throw new Refused("invalid", `folders.list: ${parsed.error.message}`);
-    return list(parsed.data.path);
-}