@byokit/accounts 0.7.0 → 0.7.1

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+## 0.7.1 (2026-09-30)
+
+- FIX: a cut-off answer is now reported as cut off: `respond` throws `IncompleteError` with its reason and partial output, and notifies `onEvent`, instead of returning it as finished.
+
 ## 0.7.0 (2026-09-30)
 
 - Add the portable `chatgptPlan` adapter for a host-validated official token-sharing session, checking

package/README.md

@@ -119,7 +119,7 @@ and [`examples/pwa`](../../examples/pwa) (browser sign-in).
 | `memoryStore`, `fileStore`, `secureStore`, `browserStore`, `recordStore` | One store per person: in memory, a 0600 file (Node entry only), Keychain/Keystore, IndexedDB, or your own load and save |
 | `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`, `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 |
+| `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 |
 | `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` |
@@ -217,6 +217,14 @@ member's sign-in, refreshed first when due, and returns the whole text (`onText`
 returned completion is authoritative). A limit or a lapsed sign-in is acted on as `failed()` does, then thrown as a
 `ResponseError` with the words to show and the kind acted on. Rules: [conformance fixtures](../../fixtures/README.md).
 
+A cut-off answer always throws `IncompleteError` (a `ResponseError` with `kind: null`), with or without tools.
+Its `reason` preserves the provider's `incomplete_details.reason`, including `max_output_tokens` and
+`content_filter` (`unknown` when absent). Its `result` holds the partial `{ text, output }` for apps that want to
+show it as unfinished. `onEvent` also receives `{ type: 'incomplete', reason }` before rejection; `onText` may
+already have shown partial words. This covers `response.incomplete` events and `status: 'incomplete'` envelopes,
+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.
+
 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

package/dist/portable.d.ts

@@ -2,7 +2,7 @@ export { Accounts, planOf, portable, type AccountsOptions, type AuthHost, type L
 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 { 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 { 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, type SecureStoreLike } from './stores.ts';
 export { WORDS, billingWords, callbackPage, clock, failure, say, signInError, type WordKey, type Why } from './words.ts';
 export { chatgptPlan, UnsupportedAccountError, type ChatGPTPlanAccount, type ChatGPTPlanSession } from './chatgpt-plan.ts';

package/dist/portable.js

@@ -4,7 +4,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 { ResponseError, isFunctionCall, limitResponse, respond, sseReader } from "./responses.js";
+export { IncompleteError, ResponseError, isFunctionCall, limitResponse, respond, sseReader } from "./responses.js";
 export { browserStore, memoryStore, recordStore, secureStore } from "./stores.js";
 export { WORDS, billingWords, callbackPage, clock, failure, say, signInError } from "./words.js";
 export { chatgptPlan, UnsupportedAccountError } from "./chatgpt-plan.js";

package/dist/responses.d.ts

@@ -6,6 +6,12 @@ export declare class ResponseError extends Error {
     until: number;
     constructor(message: string, kind: Kind | null, until?: number);
 }
+/** An answer the provider cut off. Partial output is available, but never returned as a successful answer. */
+export declare class IncompleteError extends ResponseError {
+    reason: string;
+    result: ResponseResult;
+    constructor(reason: string, result: ResponseResult);
+}
 /** A ChatGPT HTTP error as the kind, when to come back, and the message (fixtures/conformance/limit-responses.json). */
 export declare function limitResponse(status: number, body: string, now?: number): {
     kind: Kind | null;
@@ -129,6 +135,9 @@ export type ResponseResult = {
 };
 /** What streams besides the words: each text piece, each tool call as it builds and lands, and each output item. */
 export type ResponseStreamEvent = {
+    type: 'incomplete';
+    reason: string;
+} | {
     type: 'text_delta';
     delta: string;
 } | {
@@ -149,7 +158,8 @@ export type ResponseStreamEvent = {
  *  `result` for the text with every output item. `onEvent` sees each tool call and output item as it lands.
  *  Events split on any blank line (LF, CRLF or bare CR). A data line that is not JSON throws a ResponseError;
  *  a stream ending with nothing to show throws too. The text is the streamed deltas; the completed envelope
- *  only fills in when no deltas arrived. An error event throws a ResponseError. */
+ *  only fills in when no deltas arrived. An error event throws a ResponseError. An incomplete answer
+ *  emits an incomplete event and throws IncompleteError with its reason and partial result. */
 export declare function sseReader(onText?: (delta: string) => void, onEvent?: (event: ResponseStreamEvent) => void): {
     push(chunk: string): void;
     end(): string;
@@ -173,7 +183,7 @@ export type Ask = {
     text?: ResponseText;
     /** Each piece of the answer as it streams. */
     onText?: (delta: string) => void;
-    /** Each tool call and output item as it lands. */
+    /** Each text piece, tool call, output item, and incomplete answer notification. */
     onEvent?: (event: ResponseStreamEvent) => void;
     signal?: AbortSignal;
     /** The app's own originator header value. Default: 'byokit'. */
@@ -187,7 +197,8 @@ type Access = {
     fetch?: typeof fetch;
 };
 /** Ask ChatGPT with a signed-in token. `fetch`: pass one that streams (Expo's `expo/fetch`); any fetch works.
- *  Without `tools` the answer is the plain text, as before; with `tools` it is the text with every output item. */
+ *  Without `tools` the answer is the plain text, as before; with `tools` it is the text with every output item.
+ *  Incomplete answers always throw IncompleteError and notify onEvent, including with tools. */
 export declare function respond(o: Ask & Access & {
     tools?: undefined;
 }): Promise<string>;

package/dist/responses.js

@@ -16,6 +16,17 @@ export class ResponseError extends Error {
     until;
     constructor(message, kind, until = 0) { super(message); this.kind = kind; this.until = until; }
 }
+/** An answer the provider cut off. Partial output is available, but never returned as a successful answer. */
+export class IncompleteError extends ResponseError {
+    reason;
+    result;
+    constructor(reason, result) {
+        super('ChatGPT cut off its answer before it was complete.', null);
+        this.name = 'IncompleteError';
+        this.reason = reason;
+        this.result = result;
+    }
+}
 /** A ChatGPT HTTP error as the kind, when to come back, and the message (fixtures/conformance/limit-responses.json). */
 export function limitResponse(status, body, now = Date.now()) {
     let err = {};
@@ -41,10 +52,12 @@ export const isFunctionCall = (item) => isRecord(item) && item.type === 'functio
  *  `result` for the text with every output item. `onEvent` sees each tool call and output item as it lands.
  *  Events split on any blank line (LF, CRLF or bare CR). A data line that is not JSON throws a ResponseError;
  *  a stream ending with nothing to show throws too. The text is the streamed deltas; the completed envelope
- *  only fills in when no deltas arrived. An error event throws a ResponseError. */
+ *  only fills in when no deltas arrived. An error event throws a ResponseError. An incomplete answer
+ *  emits an incomplete event and throws IncompleteError with its reason and partial result. */
 export function sseReader(onText, onEvent) {
     let buffer = '', text = '', completed;
     let done = false, finished;
+    let incomplete;
     const output = [];
     const emitted = new Set();
     const calls = new Map();
@@ -100,7 +113,7 @@ export function sseReader(onText, onEvent) {
             }
             land(e.item, e.output_index ?? 0);
         }
-        if (e.type === 'response.completed' || e.type === 'response.incomplete') {
+        if (e.type === 'response.completed' || e.type === 'response.incomplete' || e.response?.status === 'incomplete') {
             done = true;
             if (Array.isArray(e.response?.output)) {
                 for (const [i, item] of e.response.output.entries())
@@ -108,6 +121,11 @@ export function sseReader(onText, onEvent) {
                 completed = e.response.output.flatMap((o) => o?.content ?? []).filter((c) => c?.type === 'output_text').map((c) => c.text ?? '').join('');
             }
         }
+        if ((e.type === 'response.incomplete' || e.response?.status === 'incomplete') && incomplete === undefined) {
+            const reason = typeof e.response?.incomplete_details?.reason === 'string' ? e.response.incomplete_details.reason : 'unknown';
+            incomplete = reason;
+            onEvent?.({ type: 'incomplete', reason });
+        }
         const failed = e.type === 'error' ? e : e.type === 'response.failed' ? e.response?.error : undefined;
         if (failed) {
             const message = String(failed.message ?? 'Request failed');
@@ -133,12 +151,14 @@ export function sseReader(onText, onEvent) {
             if (!done)
                 throw new ResponseError('ChatGPT stopped before completing its answer.', 'network');
             const whole = text !== '' ? text : (completed ?? '');
-            if (whole === '' && output.length === 0)
+            if (incomplete === undefined && whole === '' && output.length === 0)
                 throw new ResponseError('ChatGPT stopped before completing its answer.', 'network');
             if (text === '' && whole !== '')
                 onText?.(whole);
             finished = { text: whole, output };
         }
+        if (incomplete !== undefined)
+            throw new IncompleteError(incomplete, finished);
         return finished;
     };
     return {
@@ -173,7 +193,18 @@ export async function respond(o) {
     }
     const reader = sseReader(o.onText, o.onEvent);
     const body = res.body;
-    if (body?.getReader && typeof TextDecoder !== 'undefined') {
+    if (res.headers?.get('content-type')?.includes('application/json')) {
+        let response;
+        try {
+            response = JSON.parse(await res.text());
+        }
+        catch {
+            throw new ResponseError("ChatGPT's answer could not be read.", null);
+        }
+        const type = isRecord(response) ? `response.${String(response.status)}` : '';
+        reader.push(`data: ${JSON.stringify({ type, response })}\n\n`);
+    }
+    else if (body?.getReader && typeof TextDecoder !== 'undefined') {
         const r = body.getReader();
         const decoder = new TextDecoder();
         for (let c = await r.read(); !c.done; c = await r.read())

package/package.json

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