melchizedek-agents 1.2.0 → 1.3.0

package/dist/lib/chatgpt/adapter.js

@@ -0,0 +1,107 @@
+/**
+ * lib/chatgpt/adapter.ts — GPT on the person's ChatGPT plan, through Sign in
+ * with ChatGPT, on their own machine only (ADR 0126).
+ *
+ * It is GptAdapter (the Responses API) with a different credential and the
+ * request shape OpenAI documents for plan usage
+ * (developers.openai.com/siwc/token-sharing-open-source/models-and-inference
+ * and …/preview-limitations):
+ *   - always `POST https://api.openai.com/v1/responses`, never a proxy or a
+ *     platform, with the stored access token as the bearer, refreshed as it
+ *     nears expiry (lib/chatgpt/oauth.ts freshAccessToken), and no
+ *     organization or project header;
+ *   - `stream: true` and `store: false` on every request; a call that did
+ *     not ask to stream is streamed and folded back into one final;
+ *   - none of the parameters the preview refuses: `max_output_tokens`,
+ *     `temperature`, `top_p`;
+ *   - no SDK retries: a plan-usage limit (429) is reported, not hammered.
+ * The provider id stays `openai`, so reasoning replay and the stored events
+ * are the same as on a key.
+ *
+ * On a served surface (lib/chatgpt/state.ts markServedSurface) every call
+ * ends in a CHATGPT_SIGNIN_LOCAL_ONLY final before any token is read.
+ */
+import { GptAdapter } from '../models/gptAdapter.js';
+import { OPENAI_API_RESOURCE, SignInError, freshAccessToken } from './oauth.js';
+import { servedSurface, servedSurfaceMessage, signInFile } from './state.js';
+function failure(code, message) {
+    return { partial: false, parts: [], finishReason: 'error', error: { code, message, retryable: false } };
+}
+export class ChatGptSignInAdapter extends GptAdapter {
+    label = 'OpenAI (Sign in with ChatGPT)';
+    #file;
+    #oauth;
+    constructor(options) {
+        super({ model: options.model, endpoint: { platform: 'direct' } });
+        this.#file = options.file ?? signInFile();
+        this.#oauth = options.issuer ? { issuer: options.issuer } : {};
+    }
+    endpoint() {
+        return { platform: 'direct' };
+    }
+    baseURL() {
+        return OPENAI_API_RESOURCE;
+    }
+    missingKeyMessage() {
+        return 'No ChatGPT sign-in is stored; run `melchizedek-setup --chatgpt-signin`.';
+    }
+    /** The token source: read (and refreshed) on every request, never held in the adapter. */
+    clientAuth() {
+        return { apiKey: () => freshAccessToken(this.#file, this.#oauth), baseURL: OPENAI_API_RESOURCE };
+    }
+    clientOptions() {
+        return {
+            organization: null,
+            project: null,
+            maxRetries: 0,
+            logLevel: 'warn',
+            fetchOptions: { redirect: 'error' },
+        };
+    }
+    /** The preview takes none of the sampling fields. */
+    acceptsSampling() {
+        return false;
+    }
+    requestBody(request, model, endpoint) {
+        const body = super.requestBody(request, model, endpoint);
+        delete body.max_output_tokens;
+        delete body.temperature;
+        delete body.top_p;
+        body.store = false;
+        return body;
+    }
+    async *generate(request) {
+        const surface = servedSurface();
+        if (surface) {
+            yield failure('CHATGPT_SIGNIN_LOCAL_ONLY', servedSurfaceMessage(surface));
+            return;
+        }
+        // Check the sign-in first, so a missing or expired one is a plain final, not an SDK error.
+        try {
+            await freshAccessToken(this.#file, this.#oauth);
+        }
+        catch (err) {
+            const code = err instanceof SignInError ? err.code : 'signin_unreadable';
+            yield failure(code === 'not_signed_in' ? 'MISSING_API_KEY' : 'CHATGPT_SIGNIN_ERROR', err instanceof Error ? err.message : String(err));
+            return;
+        }
+        if (request.stream === true) {
+            yield* super.generate(request);
+            return;
+        }
+        // The plan-usage route streams only: stream, then give the caller what a
+        // non-streamed call gives — at most one thinking partial, then the final.
+        const thoughts = [];
+        for await (const r of super.generate({ ...request, stream: true })) {
+            if (r.partial) {
+                for (const p of r.parts)
+                    if (p.type === 'thinking' && p.text)
+                        thoughts.push(p.text);
+                continue;
+            }
+            if (thoughts.length > 0 && !r.error)
+                yield { partial: true, parts: [{ type: 'thinking', text: thoughts.join('') }] };
+            yield r;
+        }
+    }
+}

package/dist/lib/chatgpt/cli.d.ts

@@ -0,0 +1,23 @@
+/**
+ * lib/chatgpt/cli.ts — the terminal side of Sign in with ChatGPT (ADR 0126),
+ * shared by `melchizedek-setup --chatgpt-signin | --chatgpt-signout |
+ * --chatgpt-status` and `melchizedek-chat --chatgpt-signin`.
+ *
+ * Prints the authorization link (it carries no secret: a one-time state and
+ * a PKCE challenge), the file the credential lives in, and what the sign-in
+ * now carries. Never a token.
+ */
+import type { OAuthOptions } from './oauth.ts';
+export interface ChatGptCliOptions extends OAuthOptions {
+    log?: (line: string) => void;
+    env?: NodeJS.ProcessEnv;
+    port?: number;
+    openBrowser?: (url: string) => Promise<void>;
+    timeoutMs?: number;
+}
+/** The browser sign-in, from a terminal. Returns an exit code. */
+export declare function runChatGptSignIn(opts?: ChatGptCliOptions): Promise<number>;
+/** Sign out: tokens removed locally, refresh token revoked at OpenAI. */
+export declare function runChatGptSignOut(opts?: ChatGptCliOptions): Promise<number>;
+/** Where the sign-in is, and whether it carries OpenAI ids here. */
+export declare function runChatGptStatus(opts?: ChatGptCliOptions): number;

package/dist/lib/chatgpt/cli.js

@@ -0,0 +1,77 @@
+/**
+ * lib/chatgpt/cli.ts — the terminal side of Sign in with ChatGPT (ADR 0126),
+ * shared by `melchizedek-setup --chatgpt-signin | --chatgpt-signout |
+ * --chatgpt-status` and `melchizedek-chat --chatgpt-signin`.
+ *
+ * Prints the authorization link (it carries no secret: a one-time state and
+ * a PKCE challenge), the file the credential lives in, and what the sign-in
+ * now carries. Never a token.
+ */
+import { signIn, signOut } from './oauth.js';
+import { CHATGPT_SIGNIN_ENV, chatGptSignInRoutesOpenAi, chatGptSignInStatus, servedSurface, signInFile } from './state.js';
+/** The browser sign-in, from a terminal. Returns an exit code. */
+export async function runChatGptSignIn(opts = {}) {
+    const log = opts.log ?? ((l) => console.log(l));
+    const env = opts.env ?? process.env;
+    const surface = servedSurface();
+    if (surface) {
+        log(`✗ ${surface} is a served surface; Sign in with ChatGPT is for your own machine only.`);
+        return 1;
+    }
+    const file = signInFile(env);
+    try {
+        await signIn({
+            file,
+            ...(opts.issuer ? { issuer: opts.issuer } : {}),
+            ...(opts.port !== undefined ? { port: opts.port } : {}),
+            ...(opts.openBrowser ? { openBrowser: opts.openBrowser } : {}),
+            ...(opts.timeoutMs !== undefined ? { timeoutMs: opts.timeoutMs } : {}),
+            onUrl: (url) => log(`Opening your browser to sign in with ChatGPT. If it does not open, visit:\n\n  ${url}\n`),
+        });
+        log(`✓ Signed in with ChatGPT; your plan may be used for OpenAI requests (stored at ${file}, mode 600).`);
+        log(chatGptSignInRoutesOpenAi(env)
+            ? '  OpenAI model ids (gpt-*, o<digit>*) now run on it on this machine.'
+            : env[CHATGPT_SIGNIN_ENV]?.trim().toLowerCase() === 'off'
+                ? `  ${CHATGPT_SIGNIN_ENV}=off is set, so nothing uses it until you unset it.`
+                : '  OPENAI_API_KEY (or another OpenAI endpoint) is set and wins; unset it to run OpenAI ids on the sign-in.');
+        log('  Local only: melchizedek-serve and melchizedek-worker refuse to start while it is the OpenAI path. Usage limits are your ChatGPT plan\'s.');
+        return 0;
+    }
+    catch (err) {
+        log(`✗ ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+}
+/** Sign out: tokens removed locally, refresh token revoked at OpenAI. */
+export async function runChatGptSignOut(opts = {}) {
+    const log = opts.log ?? ((l) => console.log(l));
+    const file = signInFile(opts.env ?? process.env);
+    try {
+        const r = await signOut(file, opts.issuer ? { issuer: opts.issuer } : {});
+        if (!r.hadTokens)
+            log(`· No ChatGPT sign-in was stored at ${file}.`);
+        else if (r.revoked)
+            log(`✓ Signed out: the tokens are removed from ${file} and revoked at OpenAI.`);
+        else
+            log(`✓ Signed out locally (${file}). OpenAI did not confirm the revocation: disconnect the app in ChatGPT's settings.`);
+        return 0;
+    }
+    catch (err) {
+        log(`✗ ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+}
+/** Where the sign-in is, and whether it carries OpenAI ids here. */
+export function runChatGptStatus(opts = {}) {
+    const log = opts.log ?? ((l) => console.log(l));
+    const env = opts.env ?? process.env;
+    const s = chatGptSignInStatus(env);
+    if (s.problem) {
+        log(`✗ ${s.problem}`);
+        return 1;
+    }
+    log(`${s.signedIn ? '✓ signed in' : '· not signed in'} · ${s.file}${s.enabled ? '' : ` · ${CHATGPT_SIGNIN_ENV}=off`}`);
+    if (s.signedIn)
+        log(chatGptSignInRoutesOpenAi(env) ? '  carries OpenAI ids on this machine (local only)' : '  not used here: OPENAI_API_KEY or another OpenAI endpoint wins, or it is switched off');
+    return 0;
+}

package/dist/lib/chatgpt/oauth.d.ts

@@ -0,0 +1,103 @@
+/**
+ * lib/chatgpt/oauth.ts — OpenAI's Sign in with ChatGPT, plan-usage flow, for a
+ * local app (ADR 0126).
+ *
+ * Implemented from OpenAI's documentation of the flow for open-source apps
+ * that run on the user's machine:
+ *   https://developers.openai.com/siwc/token-sharing-open-source
+ *   https://developers.openai.com/siwc/token-sharing-open-source/sign-in
+ *   https://developers.openai.com/siwc/token-sharing-open-source/profiles-and-sessions
+ *   https://developers.openai.com/siwc/token-sharing-open-source/token-reference
+ *   https://developers.openai.com/siwc/token-sharing-open-source/errors-and-recovery
+ *
+ * THE FLOW: an authorization-code grant with PKCE (S256), a fresh state and
+ * nonce per attempt, and a loopback redirect on http://127.0.0.1:<port>/auth/callback.
+ * The app registers itself dynamically: the first authorization sends
+ * `client_id=dynamic_agent_client` with an `agent_name_hint`, and the callback
+ * returns the client id OpenAI issued, which is kept for every later sign-in
+ * and refresh. No client secret, no pre-registration, and never another
+ * app's client id or stored token. The token request names the resource
+ * `https://api.openai.com/v1`; the ID token is verified (signature against
+ * the issuer's JWKS, iss, aud = the issued client id, exp, nonce) before
+ * anything is saved, and the plan scope must be granted.
+ *
+ * TOKENS: an access token lasts an hour and the refresh token rotates on every
+ * refresh. Refreshes are serialized through a lock file (lib/chatgpt/store.ts)
+ * and an unusable refresh token clears the tokens and asks for a new sign-in.
+ * No token is ever logged or put in an error message.
+ */
+export declare const OPENAI_AUTH_ISSUER = "https://auth.openai.com";
+/** The resource the tokens are for: the public API, where the Responses endpoint lives. */
+export declare const OPENAI_API_RESOURCE = "https://api.openai.com/v1";
+export declare const SIGNIN_SCOPES = "openid profile email offline_access resource.invoke chatgpt.tokens.use.direct";
+export declare const CALLBACK_PATH = "/auth/callback";
+/** The client id an app sends before OpenAI has issued it one. */
+export declare const DYNAMIC_CLIENT_ID = "dynamic_agent_client";
+export declare const APP_NAME = "Melchizedek";
+/** A sign-in failure: a code for the program, a message for the person, never a token. */
+export declare class SignInError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export interface OAuthOptions {
+    /** The authorization server. Default https://auth.openai.com; an http issuer is accepted on loopback only (tests). */
+    issuer?: string;
+}
+interface Discovery {
+    issuer: string;
+    authorization_endpoint: string;
+    token_endpoint: string;
+    jwks_uri: string;
+    revocation_endpoint?: string;
+}
+/** The issuer's OpenID configuration; every endpoint must be on the issuer's own origin. */
+export declare function discover(opts?: OAuthOptions): Promise<Discovery>;
+export declare const pkceChallenge: (verifier: string) => string;
+/** Open a URL in the default browser, with no shell. */
+export declare function openInBrowser(url: string): Promise<void>;
+export interface SignInOptions extends OAuthOptions {
+    /** The credential file (lib/chatgpt/state.ts signInFile). */
+    file: string;
+    /** The loopback port; 0 (the default) takes a free one. */
+    port?: number;
+    /** Opens the authorization URL; default the system browser. */
+    openBrowser?: (url: string) => Promise<void>;
+    /** Called with the authorization URL before the browser opens, so the person can open it themselves. */
+    onUrl?: (url: string) => void;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+/** What a sign-in reports: never a token. */
+export interface SignInResult {
+    subject: string;
+    scopes: string[];
+    expiresAt: number;
+    planUsage: boolean;
+}
+/**
+ * The browser sign-in. Stores the registration (host id, issued client id)
+ * before the code exchange, and the tokens after the ID token verifies and
+ * the plan scope is confirmed.
+ */
+export declare function signIn(opts: SignInOptions): Promise<SignInResult>;
+export interface AccessTokenOptions extends OAuthOptions {
+    now?: () => number;
+}
+/**
+ * A usable access token from the credential file, refreshed when it is within
+ * two minutes of expiry (and past `earliest_refresh_at`). Refreshes take the
+ * file's lock and re-read it first, so a refresh another process just made is
+ * used rather than repeated.
+ */
+export declare function freshAccessToken(file: string, opts?: AccessTokenOptions): Promise<string>;
+/**
+ * Sign out: the tokens leave the file (the host id and issued client id
+ * stay, for the next sign-in), and the refresh token is revoked at the
+ * issuer. `revoked: false` means the local tokens are gone but the remote
+ * revocation was not confirmed: disconnect the app in ChatGPT's settings.
+ */
+export declare function signOut(file: string, opts?: OAuthOptions): Promise<{
+    hadTokens: boolean;
+    revoked: boolean;
+}>;
+export {};