@byokit/accounts 0.10.0 → 0.11.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## 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)
 
 

package/README.md

@@ -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
@@ -361,3 +366,5 @@ 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

@@ -125,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
@@ -140,6 +141,10 @@ export declare class Accounts<R extends AuthHost = AuthHost, M extends Member =
     respond(member: M, ask: Ask & {
         tools: ResponseTool[];
     }): Promise<ResponseResult>;
+    /** 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;

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/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.10.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",