@agentorg/cli 0.0.8 → 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,10 +35,11 @@ export declare function createChats(options: {
     log: Log;
 }): {
     /**
-     * Say a message in a chat, or in a new chat it starts. A new chat's first message is put to
-     * the agent's main loop, which gives it to new work or to work in a turn; from then on the
-     * chat's messages are that work's: with no turn of it running one starts a turn, and a turn
-     * running 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;

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

@@ -263,10 +263,11 @@ export function createChats(options) {
     };
     return {
         /**
-         * Say a message in a chat, or in a new chat it starts. A new chat's first message is put to
-         * the agent's main loop, which gives it to new work or to work in a turn; from then on the
-         * chat's messages are that work's: with no turn of it running one starts a turn, and a turn
-         * running 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) {

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 = {

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.8",
+  "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);
-}