@agentorg/cli 0.0.5 → 0.0.7

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

@@ -0,0 +1,104 @@
+export const ISSUER = "https://auth.openai.com";
+export const AUTHORIZE = `${ISSUER}/api/accounts/authorize`;
+export const TOKEN = `${ISSUER}/api/accounts/oauth/token`;
+const DISCOVERY = `${ISSUER}/.well-known/openid-configuration`;
+/** The audience of the tokens: the Responses API. */
+export const RESOURCE = "https://api.openai.com/v1";
+/** The scope that lets the tokens draw on the person's ChatGPT plan. */
+export const PLAN_SCOPE = "chatgpt.tokens.use.direct";
+export const SCOPES = `openid profile email offline_access resource.invoke ${PLAN_SCOPE}`;
+/** The client id of a first sign-in; OpenAI then issues this app's own `oaiapp_…` id. */
+export const DYNAMIC_CLIENT = "dynamic_agent_client";
+export const AGENT_NAME = "AgentOrg";
+/** A word from a server, fit to show: at most 64 characters of letters, digits and `_.-[]`. */
+export const word = (value) => typeof value === "string" ? value.replace(/[^A-Za-z0-9_.[\]-]/g, "").slice(0, 64) : "";
+/** The token endpoint refused a grant, with OAuth's error code. */
+export class GrantError extends Error {
+    code;
+    status;
+    constructor(code, status) {
+        super(`The token endpoint refused the grant (${status} ${code}).`);
+        this.code = code;
+        this.status = status;
+    }
+}
+/** Refresh errors after which the refresh token can't be used again. */
+export const TERMINAL = new Set([
+    "invalid_grant",
+    "invalid_refresh_token",
+    "token_expired",
+    "refresh_token_expired",
+    "refresh_token_invalidated",
+    "refresh_token_reused",
+]);
+async function json(response) {
+    try {
+        const value = await response.json();
+        return typeof value === "object" && value !== null ? value : {};
+    }
+    catch {
+        return {};
+    }
+}
+const form = (url, params) => new Request(url, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded", accept: "application/json" },
+    body: new URLSearchParams(params),
+});
+/** An authorization-code or refresh-token grant, at the token endpoint. */
+export async function grant(fetch, params, now) {
+    const response = await fetch(form(TOKEN, { ...params, resource: RESOURCE }));
+    const body = await json(response);
+    if (!response.ok)
+        throw new GrantError(word(body.error) || "error", response.status);
+    const { access_token, refresh_token, id_token, expires_in, scope } = body;
+    if (typeof access_token !== "string" || typeof refresh_token !== "string")
+        throw new GrantError("invalid_response", response.status);
+    return {
+        accessToken: access_token,
+        refreshToken: refresh_token,
+        ...(typeof id_token === "string" ? { idToken: id_token } : {}),
+        expiresAt: now + (typeof expires_in === "number" ? expires_in : 3600) * 1000,
+        scopes: typeof scope === "string" ? scope.split(" ").filter(Boolean) : [],
+    };
+}
+/** Read the issuer's configuration and keys; anything short of a usable key set throws. */
+export async function discover(fetch) {
+    const found = await fetch(new Request(DISCOVERY));
+    const config = await json(found);
+    if (!found.ok || config.issuer !== ISSUER || typeof config.jwks_uri !== "string")
+        throw new Error("unexpected OpenID configuration");
+    const fetched = await fetch(new Request(config.jwks_uri));
+    const jwks = await json(fetched);
+    const keys = Array.isArray(jwks.keys) ? jwks.keys : [];
+    if (!fetched.ok || keys.length === 0)
+        throw new Error("no signing keys");
+    return {
+        keys,
+        ...(typeof config.revocation_endpoint === "string"
+            ? { revocation: config.revocation_endpoint }
+            : {}),
+    };
+}
+/** Revoke a refresh token: true when the issuer confirmed it. Retried on 5xx and network errors. */
+export async function revoke(fetch, issuer, clientId, refreshToken) {
+    if (!issuer.revocation)
+        return false;
+    const params = { token: refreshToken, token_type_hint: "refresh_token", client_id: clientId };
+    for (let attempt = 0;; attempt++) {
+        try {
+            const response = await fetch(form(issuer.revocation, params));
+            await response.body?.cancel();
+            if (response.ok)
+                return true;
+            if (response.status < 500)
+                return false;
+        }
+        catch {
+            // A network failure: try again while the token is still in hand.
+        }
+        if (attempt === 2)
+            return false;
+        await new Promise((resolve) => setTimeout(resolve, 250 * 2 ** attempt));
+    }
+}

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

@@ -0,0 +1,23 @@
+import type { Log } from "@agentorg/sdk";
+export interface ChatGPTOptions {
+    hubUrl: string;
+    /** Its own Actor. It needs no slots: no `storage`, no `net`. */
+    actorId: string;
+    credential: string;
+    /** A private folder of its own, which holds the sign-in. */
+    dir: string;
+    log?: Log;
+    /** How a request leaves, instead of the network. For tests. */
+    fetch?: (request: Request, init: RequestInit) => Promise<Response>;
+}
+export interface ChatGPT {
+    /** Stop every response under way and leave the Hub. The sign-in stays. */
+    close(): Promise<void>;
+}
+/**
+ * Run ChatGPT as a program: an Actor exporting `account.login@1` as `login` and `llm.session@1` as
+ * `session`, with its sign-in in its own file and the network directly. It uses the person's plan,
+ * never API billing. Only https goes out, and a redirect comes back as it is, never followed with a
+ * request's token or form.
+ */
+export declare function startChatGPT(options: ChatGPTOptions): Promise<ChatGPT>;

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

@@ -0,0 +1,41 @@
+import { accountLogin, llmSession } from "@agentorg/interfaces";
+import { connect } from "@agentorg/sdk/client";
+import { fileStore } from "./file-store.js";
+import { serveChatGPT } from "./serve.js";
+const quiet = { info() { }, warn() { }, error() { } };
+/**
+ * Run ChatGPT as a program: an Actor exporting `account.login@1` as `login` and `llm.session@1` as
+ * `session`, with its sign-in in its own file and the network directly. It uses the person's plan,
+ * never API billing. Only https goes out, and a redirect comes back as it is, never followed with a
+ * request's token or form.
+ */
+export async function startChatGPT(options) {
+    const log = options.log ?? quiet;
+    const store = fileStore(options.dir, log);
+    const send = options.fetch ?? ((request, init) => fetch(request, init));
+    const outbound = async (request) => {
+        if (new URL(request.url).protocol !== "https:")
+            throw new Error("Only https addresses are reached.");
+        // Given beside the request, not by a copy of it: a copy's link to its signal can be collected,
+        // and a cancel would then wait for OpenAI's first byte.
+        return send(request, { redirect: "manual" });
+    };
+    let session;
+    const client = await connect({
+        hubUrl: options.hubUrl,
+        actorId: options.actorId,
+        credential: options.credential,
+        exports: { login: accountLogin, session: llmSession },
+        log,
+        start(ctx) {
+            session = serveChatGPT(ctx.exports, { fetch: outbound, store, log });
+        },
+    });
+    return {
+        async close() {
+            session?.stop();
+            client.close();
+            await client.closed;
+        },
+    };
+}

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

@@ -0,0 +1,54 @@
+/** Inference on the person's ChatGPT plan: the Responses API, streamed, with nothing stored. */
+import type { llmSession } from "@agentorg/interfaces";
+import { Refused } from "@agentorg/sdk";
+import type { z } from "zod";
+import { type Account } from "./account.js";
+import { type Fetch } from "./oauth.js";
+export declare const USAGE_SETTINGS = "https://chatgpt.com/settings/usage";
+type RespondInput = z.output<typeof llmSession.methods.respond.input>;
+/**
+ * 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 declare function refusalOf(code: string | undefined, at?: {
+    status?: number;
+    requestId?: string | null;
+    param?: string;
+}): Refused;
+export declare function createSession(options: {
+    fetch: Fetch;
+    account: Account;
+    /** Streamed text, for the one Actor whose request it answers. */
+    delta(caller: string, requestId: string, text: string): void;
+}): {
+    /** Stop every response still running. */
+    stop(): void;
+    /** Forget the model list, so it is read again for the next account. */
+    reset(): void;
+    models(): Promise<{
+        models: {
+            id: string;
+            name: string;
+        }[];
+    }>;
+    cancel({ requestId }: {
+        requestId: string;
+    }, caller: string): {};
+    respond(input: RespondInput, 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/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"
+  }
+}