@agentorg/cli 0.0.5 → 0.0.6

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

@@ -0,0 +1,300 @@
+import { Refused } from "@agentorg/sdk";
+import { notEligible } from "./account.js";
+import { word } from "./oauth.js";
+const API = "https://api.openai.com/v1";
+export const USAGE_SETTINGS = "https://chatgpt.com/settings/usage";
+/**
+ * OpenAI's error, as a refusal: by its code first, then its HTTP status when there is one (an error
+ * inside the stream has none). Only sanitized words of OpenAI's reply are shown.
+ */
+export function refusalOf(code, at = {}) {
+    const ref = at.requestId ? ` (request ${word(at.requestId)})` : "";
+    switch (code) {
+        case "subscription_sharing_usage_limit_exceeded":
+            return new Refused("usage_limit", `Usage limit reached. Review your plan or this app's limit in ChatGPT settings: ${USAGE_SETTINGS}`);
+        case "subscription_sharing_usage_unavailable":
+        case "subscription_sharing_user_unavailable":
+            return new Refused("unavailable", "ChatGPT plan usage is unavailable right now. Try again later.");
+        case "subscription_sharing_user_not_eligible":
+            return notEligible();
+        case "subscription_sharing_unsupported_capability":
+            return new Refused("unsupported", `The request asked for something plan usage doesn't support${at.param ? `: ${word(at.param)}` : ""}${ref}.`);
+    }
+    if (at.status === 429)
+        return refusalOf("subscription_sharing_usage_limit_exceeded", at);
+    if (at.status === 503)
+        return refusalOf("subscription_sharing_usage_unavailable", at);
+    const what = code ? ` ${word(code)}` : "";
+    return new Refused("failed", at.status === undefined
+        ? `OpenAI ended the response with an error${what}${ref}.`
+        : `OpenAI answered ${at.status}${what}${ref}.`);
+}
+async function errorOf(response) {
+    let error;
+    try {
+        error = (await response.json()).error;
+    }
+    catch {
+        // Admission errors may carry only `detail`, which is diagnostic and isn't echoed.
+    }
+    return refusalOf(typeof error?.code === "string" ? error.code : undefined, {
+        status: response.status,
+        requestId: response.headers.get("x-request-id"),
+        ...(typeof error?.param === "string" ? { param: error.param } : {}),
+    });
+}
+const BLANK_LINE = /\r?\n\r?\n/;
+/** Server-sent events, one parsed `data` object at a time, until the stream or `signal` ends. */
+async function* events(body, signal) {
+    const decoder = new TextDecoder();
+    const reader = body.getReader();
+    const stop = () => void reader.cancel().catch(() => { });
+    signal.addEventListener("abort", stop);
+    let buffer = "";
+    let done = false;
+    try {
+        while (!done) {
+            const read = await reader.read();
+            done = read.done;
+            if (signal.aborted)
+                return;
+            buffer += decoder.decode(read.value, { stream: !done });
+            for (let end = BLANK_LINE.exec(buffer); end; end = BLANK_LINE.exec(buffer)) {
+                const block = buffer.slice(0, end.index);
+                buffer = buffer.slice(end.index + end[0].length);
+                const data = block
+                    .split(/\r?\n/)
+                    .filter((line) => line.startsWith("data:"))
+                    .map((line) => line.slice(5).replace(/^ /, ""))
+                    .join("\n");
+                if (data && data !== "[DONE]") {
+                    const parsed = JSON.parse(data);
+                    if (typeof parsed === "object" && parsed !== null)
+                        yield parsed;
+                }
+            }
+        }
+    }
+    finally {
+        signal.removeEventListener("abort", stop);
+        // A response that ended early leaves the rest of its body: close it.
+        if (!done)
+            await reader.cancel().catch(() => { });
+        reader.releaseLock();
+    }
+}
+const toApi = (item) => {
+    switch (item.type) {
+        case "message":
+            return { type: "message", role: item.role, content: item.content };
+        case "function_call":
+            return {
+                type: "function_call",
+                call_id: item.callId,
+                name: item.name,
+                arguments: item.arguments,
+            };
+        case "function_call_output":
+            return { type: "function_call_output", call_id: item.callId, output: item.output };
+    }
+};
+/** The final output items of a completed response: assistant text and function calls. */
+function outputOf(response) {
+    const items = Array.isArray(response.output)
+        ? response.output
+        : [];
+    const output = [];
+    for (const item of items) {
+        if (item.type === "message" && Array.isArray(item.content)) {
+            const text = item.content
+                .map((part) => part.type === "output_text" && typeof part.text === "string"
+                ? part.text
+                : part.type === "refusal" && typeof part.refusal === "string"
+                    ? part.refusal
+                    : "")
+                .join("");
+            output.push({ type: "message", role: "assistant", content: text });
+        }
+        else if (item.type === "function_call" &&
+            typeof item.call_id === "string" &&
+            typeof item.name === "string" &&
+            typeof item.arguments === "string")
+            output.push({
+                type: "function_call",
+                callId: item.call_id,
+                name: item.name,
+                arguments: item.arguments,
+            });
+        // Reasoning items aren't carried: nothing is stored, and the next request sends the history.
+    }
+    return output;
+}
+const cancelled = () => new Refused("cancelled", "The response was cancelled.");
+export function createSession(options) {
+    const { fetch, account } = options;
+    let listed;
+    /**
+     * Responses still running, by caller and request id, so a caller's `cancel` can stop its own and
+     * no other's.
+     */
+    const running = new Map();
+    const keyOf = (caller, requestId) => `${caller}\0${requestId}`;
+    /** A request with the access token, refreshed and tried once more if OpenAI says 401. */
+    const authorized = async (build, signal) => {
+        let response;
+        try {
+            response = await fetch(build(await account.token()));
+            if (response.status === 401) {
+                await response.body?.cancel();
+                response = await fetch(build(await account.token(true)));
+            }
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw cancelled();
+            if (error instanceof Refused)
+                throw error;
+            throw new Refused("unavailable", "OpenAI couldn't be reached. Try again later.");
+        }
+        if (!response.ok) {
+            const refused = await errorOf(response);
+            if (refused.code === "ineligible")
+                await account.ineligible();
+            throw refused;
+        }
+        return response;
+    };
+    const models = () => {
+        listed ??= (async () => {
+            const response = await authorized((token) => new Request(`${API}/models`, { headers: { authorization: `Bearer ${token}` } }));
+            const body = (await response.json().catch(() => ({})));
+            if (!Array.isArray(body.models))
+                throw refusalOf("bad_models", { requestId: response.headers.get("x-request-id") });
+            return body.models
+                .filter((model) => model?.visibility === "list" && typeof model.slug === "string")
+                .map((model) => ({
+                id: model.slug.slice(0, 128),
+                name: (typeof model.display_name === "string"
+                    ? model.display_name
+                    : model.slug).slice(0, 256),
+            }));
+        })().catch((error) => {
+            listed = undefined;
+            throw error;
+        });
+        return listed;
+    };
+    async function stream(input, caller, signal) {
+        const model = input.model ?? (await models())[0]?.id;
+        if (!model)
+            throw new Refused("failed", "No model is offered to this account.");
+        if (signal.aborted)
+            throw cancelled();
+        const body = JSON.stringify({
+            model,
+            instructions: input.instructions,
+            input: input.input.map(toApi),
+            ...(input.tools?.length
+                ? {
+                    tools: input.tools.map((tool) => ({
+                        type: "function",
+                        name: tool.name,
+                        ...(tool.description === undefined ? {} : { description: tool.description }),
+                        parameters: tool.parameters,
+                        strict: false,
+                    })),
+                }
+                : {}),
+            stream: true,
+            store: false,
+        });
+        const response = await authorized((token) => new Request(`${API}/responses`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${token}`,
+                "content-type": "application/json",
+                accept: "text/event-stream",
+            },
+            body,
+            signal,
+        }), signal);
+        const requestId = response.headers.get("x-request-id");
+        if (!response.body)
+            throw refusalOf("empty_stream", { status: response.status, requestId });
+        try {
+            for await (const event of events(response.body, signal)) {
+                switch (event.type) {
+                    case "response.output_text.delta":
+                        if (typeof event.delta === "string")
+                            options.delta(caller, input.requestId, event.delta);
+                        break;
+                    case "response.completed": {
+                        const done = (event.response ?? {});
+                        const usage = done.usage;
+                        return {
+                            output: outputOf(done),
+                            ...(typeof usage?.input_tokens === "number" && typeof usage.output_tokens === "number"
+                                ? { usage: { inputTokens: usage.input_tokens, outputTokens: usage.output_tokens } }
+                                : {}),
+                        };
+                    }
+                    case "response.failed": {
+                        const error = (event.response?.error ??
+                            {});
+                        const refused = refusalOf(typeof error.code === "string" ? error.code : undefined, {
+                            requestId,
+                        });
+                        if (refused.code === "ineligible")
+                            await account.ineligible();
+                        throw refused;
+                    }
+                    case "response.incomplete":
+                        throw new Refused("failed", "The response ended incomplete.");
+                    case "error":
+                        throw refusalOf(typeof event.code === "string" ? event.code : undefined, { requestId });
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Refused)
+                throw error;
+            if (signal.aborted)
+                throw cancelled();
+            throw new Refused("failed", "The response stream broke off.");
+        }
+        if (signal.aborted)
+            throw cancelled();
+        throw new Refused("failed", "The response ended before it completed.");
+    }
+    return {
+        /** Stop every response still running. */
+        stop() {
+            for (const controller of running.values())
+                controller.abort();
+        },
+        /** Forget the model list, so it is read again for the next account. */
+        reset() {
+            listed = undefined;
+        },
+        async models() {
+            return { models: await models() };
+        },
+        cancel({ requestId }, caller) {
+            running.get(keyOf(caller, requestId))?.abort();
+            return {};
+        },
+        async respond(input, caller) {
+            const key = keyOf(caller, input.requestId);
+            if (running.has(key))
+                throw new Refused("invalid", "A response with this requestId is already running.");
+            const controller = new AbortController();
+            running.set(key, controller);
+            try {
+                return await stream(input, caller, controller.signal);
+            }
+            finally {
+                running.delete(key);
+            }
+        },
+    };
+}

package/dist/node_modules/chatgpt/dist/src/serve.d.ts

@@ -0,0 +1,65 @@
+import type { accountLogin, llmSession } from "@agentorg/interfaces";
+import type { Context, Interface, Log } from "@agentorg/sdk";
+import { type Store } from "./account.js";
+import type { Fetch } from "./oauth.js";
+type Exports = {
+    login: typeof accountLogin;
+    session: typeof llmSession;
+};
+export declare function serveChatGPT(exports: Context<Record<never, Interface>, Exports>["exports"], options: {
+    fetch: Fetch;
+    store: Store;
+    log: Log;
+}): {
+    stop(): void;
+    reset(): void;
+    models(): Promise<{
+        models: {
+            id: string;
+            name: string;
+        }[];
+    }>;
+    cancel({ requestId }: {
+        requestId: string;
+    }, caller: string): {};
+    respond(input: {
+        requestId: string;
+        model?: string | undefined;
+        instructions: string;
+        input: ({
+            type: "message";
+            role: "assistant" | "user";
+            content: string;
+        } | {
+            type: "function_call";
+            callId: string;
+            name: string;
+            arguments: string;
+        } | {
+            type: "function_call_output";
+            callId: string;
+            output: string;
+        })[];
+        tools?: {
+            name: string;
+            description?: string | undefined;
+            parameters: Record<string, import("zod").JSONType>;
+        }[] | undefined;
+    }, caller: string): Promise<{
+        output: ({
+            type: "message";
+            content: string;
+            role: "assistant";
+        } | {
+            type: "function_call";
+            callId: string;
+            name: string;
+            arguments: string;
+        })[];
+        usage?: {
+            inputTokens: number;
+            outputTokens: number;
+        } | undefined;
+    }>;
+};
+export {};

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

@@ -0,0 +1,46 @@
+import { createAccount } from "./account.js";
+import { createSession } from "./responses.js";
+export function serveChatGPT(exports, options) {
+    const { store, log } = options;
+    /** Every request's method, host, status and request id are logged; never its content. */
+    const fetch = async (request) => {
+        const { method } = request;
+        const { host } = new URL(request.url);
+        const response = await options.fetch(request);
+        log.info("request", {
+            method,
+            host,
+            status: response.status,
+            requestId: response.headers.get("x-request-id") ?? undefined,
+        });
+        return response;
+    };
+    let session;
+    const account = createAccount({
+        fetch,
+        store,
+        changed(state) {
+            session?.reset();
+            exports.login.emit("changed", { state });
+        },
+    });
+    const started = createSession({
+        fetch,
+        account,
+        // Each consumer's text goes to that consumer alone.
+        delta: (caller, requestId, text) => exports.session.emit("delta", { requestId, text }, { to: caller }),
+    });
+    session = started;
+    exports.login.implement({
+        status: () => account.status(),
+        start: (input) => account.start(input),
+        complete: (input) => account.complete(input),
+        logout: () => account.logout(),
+    });
+    exports.session.implement({
+        models: () => started.models(),
+        respond: (input, { caller }) => started.respond(input, caller),
+        cancel: (input, { caller }) => started.cancel(input, caller),
+    });
+    return started;
+}

package/dist/node_modules/chatgpt/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "chatgpt",
+  "version": "0.0.1",
+  "private": true,
+  "description": "Sign in with ChatGPT, and model inference on the person's ChatGPT plan",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    },
+    "./fake-openai": {
+      "types": "./dist/test/fake-openai.d.ts",
+      "default": "./dist/test/fake-openai.js"
+    }
+  },
+  "files": [
+    "dist/src"
+  ],
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json",
+    "test": "node --test \"dist/test/**/*.test.js\""
+  },
+  "dependencies": {
+    "@agentorg/interfaces": "0.0.0",
+    "@agentorg/sdk": "0.0.0",
+    "zod": "^4.6.7"
+  },
+  "devDependencies": {
+    "@agentorg/hub": "0.0.0"
+  }
+}

package/dist/src/api.d.ts

@@ -1,31 +1,9 @@
-/** A view the person has open: an Actor's `view` module. */
-export interface View {
-    actor: string;
-    module: string;
-}
-/** The person's own side: its slots, and `layout`, its own export, which the gateway serves. */
+/** The person's own side: the slots the gateway serves `/api` from. */
 export interface PersonSide {
     call(slot: string, method: string, input: unknown): Promise<unknown>;
     /** Events until the returned stop; `end` when the subscription can't go on. */
     subscribe(slot: string, event: string, send: (payload: unknown) => void, end: () => void): () => void;
 }
-/**
- * Calls run as a view's Actor through its `module.slot` bindings: the Hub's in-process view path
- * (`hub.viewCall` and `hub.viewSubscribe`), validated and audited like any call. The Hub refuses a
- * module that isn't one of the Actor's views, so any view of the Actor's package is open to the
- * person, and nothing else is.
- */
-export interface ViewCalls {
-    call(view: View, slot: string, method: string, input: unknown): Promise<unknown>;
-    subscribe(view: View, slot: string, event: string, send: (payload: unknown) => void, end: () => void): () => void;
-    /**
-     * The view's slots: `onSlot` hears each bound one at once, then every change (bound again when
-     * it's usable again). Returns how to stop. Refused for a module that isn't a view.
-     */
-    slots(view: View, onSlot: (slot: string, bound: boolean) => void): () => void;
-    /** A line for the view's Actor's log, which the Hub bounds as it does a frame's. */
-    log(view: View, level: "info" | "warn" | "error", message: string, fields?: Record<string, unknown>): void;
-}
 /** The socket a tab or the CLI holds: text messages in, text messages out. */
 export interface Socket {
     send(text: string): void;
@@ -34,21 +12,14 @@ export interface Socket {
 /**
  * One `/api` socket: the same calls a channel carries, as JSON.
  *
- * - `{id, op: "call", slot, method, input}`, or with `view: {actor, module}` for a view's slot;
- *   answered `{id, result}` or `{id, error}`.
- * - `{sub, op: "subscribe", slot, event}` (or with `view`): then `{sub, payload}` per event, and
- *   `{sub, end: true}` once it can't go on. `{sub, op: "unsubscribe"}` stops it.
- * - `{sub, op: "slots", view}`: the view's slots. First `{sub, payload: {bound: [slot]}}`, every
- *   one bound now, then `{sub, payload: {slot, bound}}` per change, `bound` again for a slot that's
- *   usable again. `{sub, op: "unsubscribe"}` stops it, as a subscription.
- * - `{op: "log", view, level, message, fields?}`: a line for the view's Actor's log, unanswered.
+ * - `{id, op: "call", slot, method, input}`: answered `{id, result}` or `{id, error}`.
+ * - `{sub, op: "subscribe", slot, event}`: then `{sub, payload}` per event, and `{sub, end: true}`
+ *   once it can't go on. `{sub, op: "unsubscribe"}` stops it.
  *
- * A view's calls run as its Actor, for one of its views only, which the Hub checks. Everything else
- * runs as the person: through its own slots, and `layout`, its own export.
+ * Everything runs as the person, through their slots.
  */
 export declare function serveSocket(socket: Socket, deps: {
     person: PersonSide;
-    views: ViewCalls;
 }): {
     receive(text: string): void;
     closed(): void;

package/dist/src/api.js

@@ -18,17 +18,11 @@ function errorBody(error) {
 /**
  * One `/api` socket: the same calls a channel carries, as JSON.
  *
- * - `{id, op: "call", slot, method, input}`, or with `view: {actor, module}` for a view's slot;
- *   answered `{id, result}` or `{id, error}`.
- * - `{sub, op: "subscribe", slot, event}` (or with `view`): then `{sub, payload}` per event, and
- *   `{sub, end: true}` once it can't go on. `{sub, op: "unsubscribe"}` stops it.
- * - `{sub, op: "slots", view}`: the view's slots. First `{sub, payload: {bound: [slot]}}`, every
- *   one bound now, then `{sub, payload: {slot, bound}}` per change, `bound` again for a slot that's
- *   usable again. `{sub, op: "unsubscribe"}` stops it, as a subscription.
- * - `{op: "log", view, level, message, fields?}`: a line for the view's Actor's log, unanswered.
+ * - `{id, op: "call", slot, method, input}`: answered `{id, result}` or `{id, error}`.
+ * - `{sub, op: "subscribe", slot, event}`: then `{sub, payload}` per event, and `{sub, end: true}`
+ *   once it can't go on. `{sub, op: "unsubscribe"}` stops it.
  *
- * A view's calls run as its Actor, for one of its views only, which the Hub checks. Everything else
- * runs as the person: through its own slots, and `layout`, its own export.
+ * Everything runs as the person, through their slots.
  */
 export function serveSocket(socket, deps) {
     const subscriptions = new Map();
@@ -41,13 +35,6 @@ export function serveSocket(socket, deps) {
             // The socket is gone; its close stops the rest.
         }
     };
-    const viewOf = (value) => {
-        if (value === undefined)
-            return undefined;
-        if (!isRecord(value) || !isName(value.actor) || !isName(value.module))
-            throw new Refused("invalid", "A view is {actor, module}.");
-        return { actor: value.actor, module: value.module };
-    };
     const receive = (text) => {
         let message;
         try {
@@ -72,10 +59,7 @@ export function serveSocket(socket, deps) {
                 void (async () => {
                     if (!isName(slot) || !isName(method))
                         throw new Refused("invalid", "A call names its slot and method.");
-                    const view = viewOf(message.view);
-                    return view
-                        ? deps.views.call(view, slot, method, input)
-                        : deps.person.call(slot, method, input);
+                    return deps.person.call(slot, method, input);
                 })()
                     .then((result) => send({ id, result }), (error) => send({ id, error: errorBody(error) }))
                     .finally(() => calls--);
@@ -99,14 +83,11 @@ export function serveSocket(socket, deps) {
                         throw new Refused("invalid", "A subscription names its slot and event.");
                     if (subscriptions.size >= MAX_SUBSCRIPTIONS)
                         throw new Refused("quota", `A socket holds ${MAX_SUBSCRIPTIONS} subscriptions at most.`);
-                    const view = viewOf(message.view);
                     const forward = (payload) => {
                         if (!ended)
                             send({ sub, payload });
                     };
-                    const stop = view
-                        ? deps.views.subscribe(view, slot, event, forward, end)
-                        : deps.person.subscribe(slot, event, forward, end);
+                    const stop = deps.person.subscribe(slot, event, forward, end);
                     if (ended)
                         stop();
                     else
@@ -118,49 +99,6 @@ export function serveSocket(socket, deps) {
                 }
                 return;
             }
-            case "slots": {
-                const { sub } = message;
-                if (!isId(sub) || subscriptions.has(sub))
-                    return;
-                try {
-                    if (subscriptions.size >= MAX_SUBSCRIPTIONS)
-                        throw new Refused("quota", `A socket holds ${MAX_SUBSCRIPTIONS} subscriptions at most.`);
-                    const view = viewOf(message.view);
-                    if (!view)
-                        throw new Refused("invalid", "A slots watch names its view.");
-                    // The Hub tells the bound slots at once, within the call: gathered, they're one snapshot.
-                    let snapshot = [];
-                    const stop = deps.views.slots(view, (slot, bound) => {
-                        if (snapshot && bound)
-                            snapshot.push(slot);
-                        else if (!snapshot)
-                            send({ sub, payload: { slot, bound } });
-                    });
-                    send({ sub, payload: { bound: snapshot } });
-                    snapshot = undefined;
-                    subscriptions.set(sub, stop);
-                }
-                catch (error) {
-                    send({ sub, end: true, error: errorBody(error) });
-                }
-                return;
-            }
-            case "log": {
-                const { level, message: text, fields } = message;
-                if (level !== "info" && level !== "warn" && level !== "error")
-                    return;
-                if (typeof text !== "string")
-                    return;
-                try {
-                    const view = viewOf(message.view);
-                    if (view)
-                        deps.views.log(view, level, text, isRecord(fields) ? fields : undefined);
-                }
-                catch {
-                    // Not one of an Actor's views: nothing is logged, and nothing answers.
-                }
-                return;
-            }
             case "unsubscribe": {
                 const stop = isId(message.sub) ? subscriptions.get(message.sub) : undefined;
                 if (!stop)

package/dist/src/cli.js

@@ -10,11 +10,7 @@ const USAGE = `Usage: agentorg [command] [--home DIR]
 
   (no command) [--port N] [--no-open]       run AgentOrg: the Hub, your gateway and the shell
   open                                      sign a browser in to the running app
-  build [package-dir]                       build a package into a .agentorg archive, in a
-                                            checkout of this repository; installed, use
-                                            call packages build '{"files": {...}}'
   hub [--port N]                            run a bare Hub, without the shell
-  add <file.agentorg>                       hub.packages.add
   actors | bindings | exports | audit       each one's list
   bind <consumer.slot> <provider.export>    hub.grants.bind
   call <slot> <method> [json]               call one of the person's slots
@@ -44,9 +40,9 @@ const { values, positionals } = parseArgs({
     strict: false,
 });
 const [command, ...rest] = positionals;
-// `build` and `hub` are the SDK's, which reads their options itself, strictly. Everything else is
+// `hub` is the SDK's, which reads its options itself, strictly. Everything else is
 // this command's: an option it doesn't know is a mistake, never a reason to start the app.
-if (command !== "build" && command !== "hub") {
+if (command !== "hub") {
     const unknown = Object.keys(values).find((name) => !["home", "port", "no-open", "help", "version"].includes(name));
     if (unknown !== undefined)
         usage(`Unknown option ${unknown.length === 1 ? "-" : "--"}${unknown}. An argument that starts with - goes after --.`);
@@ -202,7 +198,7 @@ else if (command === "open") {
         process.exit(1);
     }
 }
-else if (command === "build" || command === "hub")
+else if (command === "hub")
     await import("@agentorg/sdk/cli");
 else {
     let call;