@byokit/accounts 0.9.0 → 0.11.0

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## Unreleased
 
+- Expose fresh subscription access to host-side capabilities using the app’s own sign-in.
+
+## 0.11.0 (2026-09-30)
+
+
+
+- Add optional `parallelToolCalls` to `respond` and `Accounts.respond`, passed through to ChatGPT as `parallel_tool_calls`; omitted keeps the provider default.
+
+## 0.10.0 (2026-09-30)
+
+
+
+- Export portable `classifyFailure` and `Failure`, with an injectable clock and `REST_MS` fallbacks; retain `classify` as an alias.
+
 ## 0.9.0 (2026-09-30)
 
 

package/README.md

@@ -122,7 +122,7 @@ and [`examples/pwa`](../../examples/pwa) (browser sign-in).
 | `offered`, `provider`, `PROVIDERS` | The catalogue: each provider's billing, terms status, reason and source |
 | `billingWords`, `say`, `WORDS`, `signInError`, `failure`, `clock`, `callbackPage` | The plain sentences every app shows the same way (`words.json`), a time in words, and the page a browser sees after a sign-in |
 | `respond`, `ResponseError`, `IncompleteError`, `sseReader`, `limitResponse`, `isFunctionCall` | Ask ChatGPT's answers endpoint with a sign-in, with tools, pictures, thinking effort and an answer shape; the error with the words to show and the kind acted on |
-| `classify`, `REST_MS` | An error's kind (limit, overload, plan without this use, lapsed sign-in, network) and default rest times |
+| `classifyFailure`, `classify`, `REST_MS` | An error's kind (limit, overload, plan without this use, lapsed sign-in, network) and default rest times |
 | `planOf`, `claims` | The ChatGPT plan and email behind a sign-in, from its own token |
 | `deviceStart`, `devicePoll`, `credentialOf`, `portableEngine`, `PORTABLE` | The device-code flow, the sign-in built from a token answer, and the engine under `portable` |
 | `isolate`, `INHERITED`, `emptyAuthContext` (`/isolate`) | Scrub inherited Pi settings and provider keys; ambient discovery off |
@@ -260,6 +260,11 @@ already have shown partial words. This covers `response.incomplete` events and `
 whether fetch streams SSE, buffers it, or returns JSON. The account stays signed in and is not put to rest.
 Successful return values are unchanged.
 
+Set `parallelToolCalls: false` to request one tool call at a time; `true` allows parallel calls. Both pass through as
+`parallel_tool_calls`; omitting it sends nothing and keeps the provider default. `respond` supports only the ChatGPT
+subscription route; OpenRouter, Grok and Copilot are credential routes without `respond` support, and there is no
+Anthropic response route.
+
 The whole question passes through: `input` takes the turns so far (messages, with `input_image` where the person
 attached a picture), `tools` and `tool_choice` take the app's own function tools and built-ins (including
 `image_generation`), `reasoning.effort` how hard the model thinks, and `text` how long the answer is with the shape it
@@ -355,3 +360,11 @@ For a plaintext store, stop all writers, revoke the old credentials using the ol
 remove the old app-owned credential file, and sign in again with a sealing adapter. Old plaintext
 backups may retain tokens: delete them under the host's retention policy and revoke the affected
 credentials. Do not point this migration at another tool's sign-in directory.
+`classifyFailure(error, nowMs?)` returns a typed `Failure` (`{ kind, until }`) or `null`
+for an unrecognized error. `until` is epoch milliseconds when the error says "try again
+in N min/hours", and zero otherwise. For resting kinds, use
+`failure.until || nowMs + REST_MS[failure.kind]`; signed-out, not-included and network
+failures have no fallback rest. `classify` remains an alias. Pass a clock for deterministic
+classification; the default uses `Date.now()`. It stores and logs no error text.
+
+For a capability running where the sign-in lives, `await accounts.access(member, signal)` returns fresh `{ access, accountId }` from the app’s own ChatGPT store. Keep these credentials in that process; proxy signaling or relay media for another device. This uses the same refresh and signed-out behavior as `respond`.

package/dist/accounts.d.ts

@@ -1,6 +1,5 @@
 import type { CredentialStore, Models } from '@earendil-works/pi-ai';
 import { type Provider } from './catalogue.ts';
-import { type Kind } from './limits.ts';
 import { ResponseError, type Ask, type ResponseResult, type ResponseTool } from './responses.ts';
 import { type EndingStore, type RefreshStore } from './stores.ts';
 import { type Why } from './words.ts';
@@ -126,10 +125,11 @@ export declare class Accounts<R extends AuthHost = AuthHost, M extends Member =
     forget(member: M, key: string): void;
     /** 0 when the account is available; otherwise when it stops resting. */
     restingUntil(member: M, key: string): number;
-    /** An account's error, acted on. A limit or overload rests it (until when it said, or a default). A plan without this
-     *  use is marked so. A refusal is checked: a sign-in that no longer refreshes is signed out for real, one that still
-     *  does was a passing refusal and rests a few minutes (kind `overloaded`) rather than loop. Returns the kind acted on,
-     *  or null for an error that is not about the account; `network` changes nothing. */
+    /** Fresh ChatGPT access for a host-side capability. Never send this to another device. */
+    access(member: M, signal?: AbortSignal): Promise<{
+        access: string;
+        accountId: string;
+    }>;
     /** Ask ChatGPT with this member's own sign-in, the answer streaming into `onText`; refreshed first when due. A
      *  failure about the account (a limit, a lapsed sign-in) is acted on as `failed()` does, then thrown as a
      *  ResponseError with the words to show. Without `tools` the answer is the plain text, as before: pass `input` as
@@ -141,10 +141,11 @@ export declare class Accounts<R extends AuthHost = AuthHost, M extends Member =
     respond(member: M, ask: Ask & {
         tools: ResponseTool[];
     }): Promise<ResponseResult>;
-    failed(member: M, key: string, error: string | ResponseError): Promise<{
-        kind: Kind;
-        until: number;
-    } | null>;
+    /** An account's error, acted on. A limit or overload rests it (until when it said, or a default). A plan without this
+     *  use is marked so. A refusal is checked: a sign-in that no longer refreshes is signed out for real, one that still
+     *  does was a passing refusal and rests a few minutes (kind `overloaded`) rather than loop. Returns the kind acted on,
+     *  or null for an error that is not about the account; `network` changes nothing. */
+    failed(member: M, key: string, error: string | ResponseError): Promise<import("./limits.ts").Failure | null>;
     /** The first choice whose account is neither resting nor known to be unusable: the fallback ladder. */
     ladder<T>(member: M, choices: readonly T[], key?: (c: T) => string): T | undefined;
     /** Where one account stands, in one plain sentence every app shows the same way. */

package/dist/accounts.js

@@ -228,7 +228,9 @@ export class Accounts {
         const r = this.rests.get(`${member}:${key}`);
         return r && r.until > Date.now() ? r.until : 0;
     }
-    async respond(member, ask) {
+    /** Fresh ChatGPT access for a host-side capability. Never send this to another device. */
+    async access(member, signal) {
+        signal?.throwIfAborted();
         const key = 'chatgpt';
         const p = this.offer(key);
         const rt = await this.runtime(member);
@@ -247,8 +249,15 @@ export class Accounts {
         const c = await rt.readCredential(p.pi).catch(() => undefined);
         if (!access || c?.type !== 'oauth')
             throw new ResponseError(say('status.signedOut', { name: p.name }), 'signed_out');
+        signal?.throwIfAborted();
+        return { access, accountId: String(c.accountId ?? '') };
+    }
+    async respond(member, ask) {
+        const key = 'chatgpt';
+        const p = this.offer(key);
+        const { access, accountId } = await this.access(member);
         try {
-            const base = { ...ask, access, accountId: String(c.accountId ?? ''), model: ask.model ?? p.models.strong, base: this.opts.apiBase, fetch: this.opts.fetch, originator: ask.originator ?? this.opts.originator };
+            const base = { ...ask, access, accountId, model: ask.model ?? p.models.strong, base: this.opts.apiBase, fetch: this.opts.fetch, originator: ask.originator ?? this.opts.originator };
             return ask.tools ? await respond({ ...base, tools: ask.tools }) : await respond({ ...base, tools: undefined });
         }
         catch (e) {
@@ -260,6 +269,10 @@ export class Accounts {
             throw e;
         }
     }
+    /** An account's error, acted on. A limit or overload rests it (until when it said, or a default). A plan without this
+     *  use is marked so. A refusal is checked: a sign-in that no longer refreshes is signed out for real, one that still
+     *  does was a passing refusal and rests a few minutes (kind `overloaded`) rather than loop. Returns the kind acted on,
+     *  or null for an error that is not about the account; `network` changes nothing. */
     async failed(member, key, error) {
         const c = error instanceof ResponseError ? error.kind && { kind: error.kind, until: error.until } : classify(error);
         if (!c || c.kind === 'network')

package/dist/limits.d.ts

@@ -2,7 +2,11 @@ export type Kind = 'rate_limit' | 'overloaded' | 'signed_out' | 'not_included' |
 /** How long an account rests when its error didn't say. */
 export declare const REST_MS: Record<Kind, number>;
 /** `until` is 0 when the error didn't say. Anything unrecognised is null: the app fails that one request. */
-export declare function classify(error: string): {
+export type Failure = {
     kind: Kind;
     until: number;
-} | null;
+};
+/** Pure when the host passes its clock. REST_MS supplies the fallback rest duration. */
+export declare function classifyFailure(error: string, nowMs?: number): Failure | null;
+/** Backwards-compatible name for classifyFailure. */
+export declare const classify: typeof classifyFailure;

package/dist/limits.js

@@ -1,9 +1,9 @@
 /** How long an account rests when its error didn't say. */
 export const REST_MS = { rate_limit: 60 * 60_000, overloaded: 5 * 60_000, signed_out: 0, not_included: 0, network: 0 };
-/** `until` is 0 when the error didn't say. Anything unrecognised is null: the app fails that one request. */
-export function classify(error) {
+/** Pure when the host passes its clock. REST_MS supplies the fallback rest duration. */
+export function classifyFailure(error, nowMs = Date.now()) {
     const m = /try again in ~?(\d+)\s*(min|h)/i.exec(error);
-    const until = m ? Date.now() + Number(m[1]) * (m[2].toLowerCase() === 'h' ? 3_600_000 : 60_000) : 0;
+    const until = m ? nowMs + Number(m[1]) * (m[2].toLowerCase() === 'h' ? 3_600_000 : 60_000) : 0;
     if (/your plan doesn't include/i.test(error))
         return { kind: 'not_included', until };
     if (/usage limit|rate.?limit|quota|too many requests|\b429\b/i.test(error))
@@ -16,3 +16,5 @@ export function classify(error) {
         return { kind: 'network', until };
     return null;
 }
+/** Backwards-compatible name for classifyFailure. */
+export const classify = classifyFailure;

package/dist/portable.d.ts

@@ -1,7 +1,7 @@
 export { Accounts, planOf, portable, type AccountsOptions, type AuthHost, type Loopback, type Member, type Platform, type SignIn, type Status } from './accounts.ts';
 export { PROVIDERS, offered, provider, type Billing, type Provider, type Terms } from './catalogue.ts';
 export { PORTABLE, claims, credentialOf, devicePoll, deviceStart, portableEngine, type EngineOptions, type Poll } from './engine.ts';
-export { REST_MS, classify, type Kind } from './limits.ts';
+export { REST_MS, classify, classifyFailure, type Failure, type Kind } from './limits.ts';
 export { IncompleteError, ResponseError, isFunctionCall, limitResponse, respond, sseReader, type Ask, type ResponseFunctionCall, type ResponseInputItem, type ResponseOutputItem, type ResponseOutputMessage, type ResponseReasoning, type ResponseResult, type ResponseStreamEvent, type ResponseText, type ResponseTextFormat, type ResponseTool, type ResponseToolChoice } from './responses.ts';
 export { browserStore, memoryStore, recordStore, secureStore, RefreshRequiredError, type RefreshStore, type SecureStoreLike } from './stores.ts';
 export { WORDS, billingWords, callbackPage, clock, failure, say, signInError, type WordKey, type Why } from './words.ts';

package/dist/portable.js

@@ -3,7 +3,7 @@
 export { Accounts, planOf, portable } from "./accounts.js";
 export { PROVIDERS, offered, provider } from "./catalogue.js";
 export { PORTABLE, claims, credentialOf, devicePoll, deviceStart, portableEngine } from "./engine.js";
-export { REST_MS, classify } from "./limits.js";
+export { REST_MS, classify, classifyFailure } from "./limits.js";
 export { IncompleteError, ResponseError, isFunctionCall, limitResponse, respond, sseReader } from "./responses.js";
 export { browserStore, memoryStore, recordStore, secureStore, RefreshRequiredError } from "./stores.js";
 export { WORDS, billingWords, callbackPage, clock, failure, say, signInError } from "./words.js";

package/dist/responses.d.ts

@@ -175,6 +175,8 @@ export type Ask = {
     model?: string;
     /** The tools the model may call. Passed, the result carries the output items next to the text. */
     tools?: ResponseTool[];
+    /** Whether ChatGPT may call tools in parallel. Omitted: the provider's default. */
+    parallelToolCalls?: boolean;
     /** Which tool the model must use. Default: whatever it wants. */
     tool_choice?: ResponseToolChoice;
     /** How hard the model thinks. Default: none. */

package/dist/responses.js

@@ -182,6 +182,7 @@ export async function respond(o) {
         body: JSON.stringify({
             model: o.model, store: false, stream: true, instructions: o.instructions, input,
             ...(o.tools ? { tools: o.tools } : {}),
+            ...(o.parallelToolCalls !== undefined ? { parallel_tool_calls: o.parallelToolCalls } : {}),
             ...(o.tool_choice !== undefined ? { tool_choice: o.tool_choice } : {}),
             text: { verbosity, ...(format ? { format } : {}), ...textRest },
             reasoning: { effort, ...reasoningRest },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byokit/accounts",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Sign in with the AI plan you already pay for, into your app's own store.",
   "license": "Apache-2.0",
   "type": "module",