@modelprofile.com/flexharness-providers 8.5.0 → 9.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist_ts_openai_account/plugins.d.ts +2 -0
- package/dist_ts_openai_account/plugins.js +4 -1
- package/dist_ts_openai_account/smartai.providers.interfaces.d.ts +6 -22
- package/dist_ts_openai_account/smartai.providers.openai.js +15 -134
- package/dist_ts_openai_auth/index.d.ts +1 -2
- package/dist_ts_openai_auth/index.js +2 -3
- package/dist_ts_openai_auth/interfaces.d.ts +1 -1
- package/dist_ts_openai_auth/smartai.auth.openai.d.ts +3 -15
- package/dist_ts_openai_auth/smartai.auth.openai.js +3 -17
- package/dist_ts_openai_auth/smartai.connection.openai.d.ts +1 -1
- package/dist_ts_openai_auth/smartai.connection.openai.js +2 -3
- package/dist_ts_providers/openai/index.d.ts +4 -0
- package/dist_ts_providers/openai/index.js +5 -1
- package/dist_ts_providers/openai/plugins.d.ts +4 -4
- package/dist_ts_providers/openai/plugins.js +3 -3
- package/dist_ts_providers/openai/smartai.chatgpt.catalog.d.ts +59 -0
- package/dist_ts_providers/openai/smartai.chatgpt.catalog.js +245 -0
- package/{dist_ts_openai_auth/smartai.limits.openai.d.ts → dist_ts_providers/openai/smartai.chatgpt.limits.d.ts} +2 -2
- package/dist_ts_providers/openai/smartai.chatgpt.limits.js +49 -0
- package/{dist_ts_openai_auth/smartai.middleware.openai.d.ts → dist_ts_providers/openai/smartai.chatgpt.middleware.d.ts} +2 -2
- package/dist_ts_providers/openai/smartai.chatgpt.middleware.js +47 -0
- package/dist_ts_providers/openai/smartai.chatgpt.openai.d.ts +92 -0
- package/dist_ts_providers/openai/smartai.chatgpt.openai.js +160 -0
- package/package.json +2 -2
- package/readme.md +8 -0
- package/ts_openai_account/plugins.ts +5 -0
- package/ts_openai_account/smartai.providers.interfaces.ts +11 -25
- package/ts_openai_account/smartai.providers.openai.ts +16 -135
- package/ts_openai_auth/index.ts +4 -2
- package/ts_openai_auth/interfaces.ts +1 -1
- package/ts_openai_auth/smartai.auth.openai.ts +12 -24
- package/ts_openai_auth/smartai.connection.openai.ts +5 -3
- package/ts_providers/openai/index.ts +29 -0
- package/ts_providers/openai/plugins.ts +4 -3
- package/ts_providers/openai/readme.md +58 -7
- package/ts_providers/openai/smartai.chatgpt.catalog.ts +308 -0
- package/{ts_openai_auth/smartai.limits.openai.ts → ts_providers/openai/smartai.chatgpt.limits.ts} +6 -7
- package/{ts_openai_auth/smartai.middleware.openai.ts → ts_providers/openai/smartai.chatgpt.middleware.ts} +6 -6
- package/ts_providers/openai/smartai.chatgpt.openai.ts +271 -0
- package/ts_providers/readme.md +8 -0
- package/dist_ts_openai_auth/smartai.limits.openai.js +0 -49
- package/dist_ts_openai_auth/smartai.middleware.openai.js +0 -47
|
@@ -0,0 +1,271 @@
|
|
|
1
|
+
// OpenAI protocol portions are adapted in TypeScript; see third-party-notices.md.
|
|
2
|
+
import { classifyOpenAiChatGptLimit } from './smartai.chatgpt.limits.js';
|
|
3
|
+
import { createOpenAiChatGptInstructionsMiddleware } from './smartai.chatgpt.middleware.js';
|
|
4
|
+
import type { IOpenAiModelConnection } from './index.js';
|
|
5
|
+
|
|
6
|
+
export const OPENAI_CHATGPT_CODEX_BASE_URL = 'https://chatgpt.com/backend-api/codex';
|
|
7
|
+
export const OPENAI_CHATGPT_DEFAULT_ORIGINATOR = 'smartai';
|
|
8
|
+
|
|
9
|
+
/** Whether a failed ChatGPT request reached the provider: `notSent` never did, `outcomeUnknown` may have. */
|
|
10
|
+
export type TOpenAiChatGptRequestOutcome = 'notSent' | 'outcomeUnknown';
|
|
11
|
+
|
|
12
|
+
export class OpenAiChatGptAuthError extends Error {
|
|
13
|
+
public status?: number;
|
|
14
|
+
public body?: string;
|
|
15
|
+
public requestOutcome?: TOpenAiChatGptRequestOutcome;
|
|
16
|
+
public retryAfterMs?: number;
|
|
17
|
+
|
|
18
|
+
constructor(message: string, options: {
|
|
19
|
+
status?: number;
|
|
20
|
+
body?: string;
|
|
21
|
+
requestOutcome?: TOpenAiChatGptRequestOutcome;
|
|
22
|
+
retryAfterMs?: number;
|
|
23
|
+
} = {}) {
|
|
24
|
+
super(message);
|
|
25
|
+
this.name = 'OpenAiChatGptAuthError';
|
|
26
|
+
this.status = options.status;
|
|
27
|
+
this.body = options.body;
|
|
28
|
+
this.requestOutcome = options.requestOutcome;
|
|
29
|
+
this.retryAfterMs = options.retryAfterMs;
|
|
30
|
+
}
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
/**
|
|
34
|
+
* Access to ChatGPT with its identity stated by whoever issued it.
|
|
35
|
+
*
|
|
36
|
+
* `accountId` is optional only because a legacy login's token may carry no workspace claim; a request
|
|
37
|
+
* then goes out without a `ChatGPT-Account-ID` header. Model connections require the workspace and take
|
|
38
|
+
* `IOpenAiChatGptAccess`.
|
|
39
|
+
*/
|
|
40
|
+
export interface IOpenAiChatGptReadAccess {
|
|
41
|
+
readonly accessToken: string;
|
|
42
|
+
/** The ChatGPT workspace the token was issued for, sent as `ChatGPT-Account-ID`. */
|
|
43
|
+
readonly accountId?: string;
|
|
44
|
+
/** Sent as `X-OpenAI-Fedramp: true` when set. */
|
|
45
|
+
readonly isFedrampAccount: boolean;
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
/**
|
|
49
|
+
* Access to one ChatGPT workspace, as an account authority resolves it.
|
|
50
|
+
*
|
|
51
|
+
* The workspace and residency are the authority's statement and are used as given: this package never
|
|
52
|
+
* reads them back out of the token, because the claims have one owner, and it is the authority.
|
|
53
|
+
*/
|
|
54
|
+
export interface IOpenAiChatGptAccess extends IOpenAiChatGptReadAccess {
|
|
55
|
+
readonly accountId: string;
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
/** Resolved access, optionally stamped with the authority's generation of that access token. */
|
|
59
|
+
export interface IOpenAiChatGptAccessGrant extends IOpenAiChatGptAccess {
|
|
60
|
+
/**
|
|
61
|
+
* The authority's generation of this access token. When it is set and the provider rejects the token,
|
|
62
|
+
* the connection resolves once more naming this generation, so the authority can renew exactly that
|
|
63
|
+
* token, and sends the request again.
|
|
64
|
+
*/
|
|
65
|
+
readonly generation?: number;
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
export interface IOpenAiChatGptAccessResolveRequest {
|
|
69
|
+
/** The provider request signal. A resolver should pass it through to its authority. */
|
|
70
|
+
readonly signal: AbortSignal;
|
|
71
|
+
/** The generation of the access token the provider has just rejected with 401. */
|
|
72
|
+
readonly rejectedGeneration?: number;
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
/** The workspace and residency a connection is pinned to for its lifetime. */
|
|
76
|
+
export interface IOpenAiChatGptWorkspaceIdentity {
|
|
77
|
+
readonly accountId: string;
|
|
78
|
+
readonly isFedrampAccount: boolean;
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
export interface IOpenAiChatGptAccessConnectionOptions {
|
|
82
|
+
/** Stable provider originator header. Defaults to `smartai`. */
|
|
83
|
+
readonly originator?: string;
|
|
84
|
+
/** Optional underlying transport. Defaults to the current global fetch. */
|
|
85
|
+
readonly fetch?: typeof fetch;
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
export interface IOpenAiChatGptResolvingConnectionOptions extends IOpenAiChatGptAccessConnectionOptions {
|
|
89
|
+
/** Every resolved access must state exactly this workspace and residency. */
|
|
90
|
+
readonly expectedIdentity: IOpenAiChatGptWorkspaceIdentity;
|
|
91
|
+
/** Resolves current access immediately before every provider network request. */
|
|
92
|
+
readonly resolveAccess: (
|
|
93
|
+
request: IOpenAiChatGptAccessResolveRequest,
|
|
94
|
+
) => Promise<IOpenAiChatGptAccessGrant>;
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
const codexBaseUrl = new URL(OPENAI_CHATGPT_CODEX_BASE_URL);
|
|
98
|
+
|
|
99
|
+
const isNonEmptyString = (value: unknown): value is string => typeof value === 'string' && value.length > 0;
|
|
100
|
+
|
|
101
|
+
const isGeneration = (value: unknown): value is number => Number.isSafeInteger(value) && (value as number) >= 1;
|
|
102
|
+
|
|
103
|
+
function assertCodexRequestUrl(normalizedUrlArg: string): void {
|
|
104
|
+
const url = new URL(normalizedUrlArg);
|
|
105
|
+
const isCodexPath = url.pathname === codexBaseUrl.pathname
|
|
106
|
+
|| url.pathname.startsWith(`${codexBaseUrl.pathname}/`);
|
|
107
|
+
if (
|
|
108
|
+
url.origin !== codexBaseUrl.origin
|
|
109
|
+
|| url.username !== ''
|
|
110
|
+
|| url.password !== ''
|
|
111
|
+
|| !isCodexPath
|
|
112
|
+
) {
|
|
113
|
+
throw new OpenAiChatGptAuthError('OpenAI ChatGPT inference URL is outside the Codex endpoint.');
|
|
114
|
+
}
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
function requireWorkspaceIdentity(identityArg: IOpenAiChatGptWorkspaceIdentity | undefined): IOpenAiChatGptWorkspaceIdentity {
|
|
118
|
+
if (
|
|
119
|
+
!identityArg
|
|
120
|
+
|| !isNonEmptyString(identityArg.accountId)
|
|
121
|
+
|| typeof identityArg.isFedrampAccount !== 'boolean'
|
|
122
|
+
) {
|
|
123
|
+
throw new OpenAiChatGptAuthError('OpenAI ChatGPT workspace identity is invalid.');
|
|
124
|
+
}
|
|
125
|
+
return Object.freeze({
|
|
126
|
+
accountId: identityArg.accountId,
|
|
127
|
+
isFedrampAccount: identityArg.isFedrampAccount,
|
|
128
|
+
});
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
function assertGrant(
|
|
132
|
+
grantArg: IOpenAiChatGptAccessGrant,
|
|
133
|
+
expectedIdentityArg: IOpenAiChatGptWorkspaceIdentity,
|
|
134
|
+
): void {
|
|
135
|
+
if (
|
|
136
|
+
!grantArg
|
|
137
|
+
|| !isNonEmptyString(grantArg.accessToken)
|
|
138
|
+
|| (grantArg.generation !== undefined && !isGeneration(grantArg.generation))
|
|
139
|
+
) {
|
|
140
|
+
throw new OpenAiChatGptAuthError('OpenAI ChatGPT resolved access is invalid.');
|
|
141
|
+
}
|
|
142
|
+
if (
|
|
143
|
+
grantArg.accountId !== expectedIdentityArg.accountId
|
|
144
|
+
|| grantArg.isFedrampAccount !== expectedIdentityArg.isFedrampAccount
|
|
145
|
+
) {
|
|
146
|
+
throw new OpenAiChatGptAuthError('OpenAI ChatGPT resolved access identity does not match the connection.');
|
|
147
|
+
}
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
/** The headers a ChatGPT backend request authenticates with. Shared by inference and the model catalog. */
|
|
151
|
+
export function createOpenAiChatGptAccessHeaders(
|
|
152
|
+
accessArg: IOpenAiChatGptReadAccess,
|
|
153
|
+
originatorArg: string = OPENAI_CHATGPT_DEFAULT_ORIGINATOR,
|
|
154
|
+
): Record<string, string> {
|
|
155
|
+
return {
|
|
156
|
+
Authorization: `Bearer ${accessArg.accessToken}`,
|
|
157
|
+
originator: originatorArg,
|
|
158
|
+
...(accessArg.accountId ? { 'ChatGPT-Account-ID': accessArg.accountId } : {}),
|
|
159
|
+
...(accessArg.isFedrampAccount ? { 'X-OpenAI-Fedramp': 'true' } : {}),
|
|
160
|
+
};
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
const accessRejected = (): OpenAiChatGptAuthError => new OpenAiChatGptAuthError(
|
|
164
|
+
'OpenAI ChatGPT rejected the access token.',
|
|
165
|
+
{ status: 401 },
|
|
166
|
+
);
|
|
167
|
+
|
|
168
|
+
/**
|
|
169
|
+
* A ChatGPT connection that resolves its access before every provider HTTP request.
|
|
170
|
+
*
|
|
171
|
+
* The workspace and residency are pinned at construction; an access that states anything else stops the
|
|
172
|
+
* request before the transport is called. A provider 401 is answered once: when the rejected access carried
|
|
173
|
+
* a `generation`, the connection resolves again with `rejectedGeneration` and sends the request a second
|
|
174
|
+
* time with the new access. A 401 that cannot be retried, and a second 401, fail with an
|
|
175
|
+
* `OpenAiChatGptAuthError` whose `status` is 401.
|
|
176
|
+
*/
|
|
177
|
+
export const createOpenAiChatGptResolvingModelConnection = (
|
|
178
|
+
optionsArg: IOpenAiChatGptResolvingConnectionOptions,
|
|
179
|
+
): IOpenAiModelConnection => {
|
|
180
|
+
if (!optionsArg || typeof optionsArg.resolveAccess !== 'function') {
|
|
181
|
+
throw new OpenAiChatGptAuthError('OpenAI ChatGPT access resolver is required.');
|
|
182
|
+
}
|
|
183
|
+
const expectedIdentity = requireWorkspaceIdentity(optionsArg.expectedIdentity);
|
|
184
|
+
const resolveAccess = optionsArg.resolveAccess;
|
|
185
|
+
const originator = optionsArg.originator ?? OPENAI_CHATGPT_DEFAULT_ORIGINATOR;
|
|
186
|
+
const transport = optionsArg.fetch ?? globalThis.fetch;
|
|
187
|
+
if (typeof transport !== 'function') {
|
|
188
|
+
throw new OpenAiChatGptAuthError('fetch is not available for OpenAI ChatGPT inference.');
|
|
189
|
+
}
|
|
190
|
+
|
|
191
|
+
const resolveGrant = async (
|
|
192
|
+
requestArg: IOpenAiChatGptAccessResolveRequest,
|
|
193
|
+
): Promise<IOpenAiChatGptAccessGrant> => {
|
|
194
|
+
const grant = await resolveAccess(requestArg);
|
|
195
|
+
requestArg.signal.throwIfAborted();
|
|
196
|
+
assertGrant(grant, expectedIdentity);
|
|
197
|
+
return grant;
|
|
198
|
+
};
|
|
199
|
+
|
|
200
|
+
const send = async (requestArg: Request, grantArg: IOpenAiChatGptAccessGrant): Promise<Response> => {
|
|
201
|
+
const headers = new Headers(requestArg.headers);
|
|
202
|
+
for (const [name, value] of Object.entries(createOpenAiChatGptAccessHeaders(grantArg, originator))) {
|
|
203
|
+
headers.set(name, value);
|
|
204
|
+
}
|
|
205
|
+
if (!grantArg.isFedrampAccount) headers.delete('X-OpenAI-Fedramp');
|
|
206
|
+
const authenticatedRequest = new Request(requestArg, { headers });
|
|
207
|
+
authenticatedRequest.signal.throwIfAborted();
|
|
208
|
+
return transport(authenticatedRequest);
|
|
209
|
+
};
|
|
210
|
+
|
|
211
|
+
const fetchWithCurrentAccess: typeof fetch = async (inputArg, initArg) => {
|
|
212
|
+
const request = new Request(inputArg, {
|
|
213
|
+
...initArg,
|
|
214
|
+
redirect: 'error',
|
|
215
|
+
});
|
|
216
|
+
assertCodexRequestUrl(request.url);
|
|
217
|
+
request.signal.throwIfAborted();
|
|
218
|
+
|
|
219
|
+
const grant = await resolveGrant({ signal: request.signal });
|
|
220
|
+
// A replay needs the body the first attempt consumes, so it is kept only when a replay can happen.
|
|
221
|
+
const replay = grant.generation === undefined ? undefined : request.clone();
|
|
222
|
+
const response = await send(request, grant);
|
|
223
|
+
if (response.status !== 401) return response;
|
|
224
|
+
await response.body?.cancel().catch(() => undefined);
|
|
225
|
+
if (!replay) throw accessRejected();
|
|
226
|
+
|
|
227
|
+
const renewed = await resolveGrant({ signal: replay.signal, rejectedGeneration: grant.generation });
|
|
228
|
+
const replayed = await send(replay, renewed);
|
|
229
|
+
if (replayed.status !== 401) return replayed;
|
|
230
|
+
await replayed.body?.cancel().catch(() => undefined);
|
|
231
|
+
throw accessRejected();
|
|
232
|
+
};
|
|
233
|
+
|
|
234
|
+
return {
|
|
235
|
+
settings: {
|
|
236
|
+
apiKey: '',
|
|
237
|
+
baseURL: OPENAI_CHATGPT_CODEX_BASE_URL,
|
|
238
|
+
fetch: fetchWithCurrentAccess,
|
|
239
|
+
},
|
|
240
|
+
middleware: createOpenAiChatGptInstructionsMiddleware(),
|
|
241
|
+
// the ChatGPT Codex backend serves the Responses API only
|
|
242
|
+
apis: ['responses'],
|
|
243
|
+
classifyLimit: classifyOpenAiChatGptLimit,
|
|
244
|
+
};
|
|
245
|
+
};
|
|
246
|
+
|
|
247
|
+
/**
|
|
248
|
+
* A ChatGPT connection for one fixed access, with the workspace and residency its issuer stated.
|
|
249
|
+
*
|
|
250
|
+
* It sends exactly the access it was given, and a provider 401 fails with an `OpenAiChatGptAuthError`
|
|
251
|
+
* whose `status` is 401. Use `createOpenAiChatGptResolvingModelConnection` when an authority renews the
|
|
252
|
+
* access.
|
|
253
|
+
*/
|
|
254
|
+
export const createOpenAiChatGptAccessModelConnection = (
|
|
255
|
+
accessArg: IOpenAiChatGptAccess,
|
|
256
|
+
optionsArg: IOpenAiChatGptAccessConnectionOptions = {},
|
|
257
|
+
): IOpenAiModelConnection => {
|
|
258
|
+
if (!accessArg || !isNonEmptyString(accessArg.accessToken)) {
|
|
259
|
+
throw new OpenAiChatGptAuthError('OpenAI ChatGPT access is invalid.');
|
|
260
|
+
}
|
|
261
|
+
const access: IOpenAiChatGptAccess = Object.freeze({
|
|
262
|
+
accessToken: accessArg.accessToken,
|
|
263
|
+
accountId: accessArg.accountId,
|
|
264
|
+
isFedrampAccount: accessArg.isFedrampAccount,
|
|
265
|
+
});
|
|
266
|
+
return createOpenAiChatGptResolvingModelConnection({
|
|
267
|
+
...optionsArg,
|
|
268
|
+
expectedIdentity: access,
|
|
269
|
+
resolveAccess: async () => access,
|
|
270
|
+
});
|
|
271
|
+
};
|
package/ts_providers/readme.md
CHANGED
|
@@ -42,6 +42,14 @@ instead; it resolves current access at every provider HTTP request while keeping
|
|
|
42
42
|
account and residency identity fixed for the connection. API-key inference
|
|
43
43
|
needs no authentication setup.
|
|
44
44
|
|
|
45
|
+
When an account authority such as authswitch owns the login, `/openai` runs
|
|
46
|
+
ChatGPT inference from access alone:
|
|
47
|
+
`createOpenAiChatGptResolvingModelConnection({ expectedIdentity, resolveAccess })`
|
|
48
|
+
resolves the access token, workspace and residency before every provider request
|
|
49
|
+
and resolves once more after a rejected token, and `listOpenAiChatGptModels()`
|
|
50
|
+
reads the model catalog with the same access. Neither parses the token; see
|
|
51
|
+
`openai/readme.md`.
|
|
52
|
+
|
|
45
53
|
The package includes the applicable OpenAI Codex license and third-party notices.
|
|
46
54
|
|
|
47
55
|
## License and Legal Information
|
|
@@ -1,49 +0,0 @@
|
|
|
1
|
-
import { readEpochSeconds } from '@modelprofile.com/flexharness-models';
|
|
2
|
-
import { readOpenAiError } from '@modelprofile.com/flexharness-providers/openai';
|
|
3
|
-
const codexUsageLimitIdentifiers = new Set(['usage_limit_reached', 'usage_not_included']);
|
|
4
|
-
const codexWindows = ['primary', 'secondary'];
|
|
5
|
-
function formatWindowMinutes(minutes) {
|
|
6
|
-
if (minutes % 1440 === 0)
|
|
7
|
-
return `${minutes / 1440}d`;
|
|
8
|
-
if (minutes % 60 === 0)
|
|
9
|
-
return `${minutes / 60}h`;
|
|
10
|
-
return `${minutes}m`;
|
|
11
|
-
}
|
|
12
|
-
function readExhaustedWindow(headers) {
|
|
13
|
-
const exhausted = codexWindows.flatMap((name) => {
|
|
14
|
-
const usedPercent = Number(headers[`x-codex-${name}-used-percent`]);
|
|
15
|
-
const minutes = Number(headers[`x-codex-${name}-window-minutes`]);
|
|
16
|
-
const resetsAt = readEpochSeconds(headers[`x-codex-${name}-reset-at`]);
|
|
17
|
-
if (!(usedPercent >= 100) || resetsAt === undefined)
|
|
18
|
-
return [];
|
|
19
|
-
return [{ label: Number.isSafeInteger(minutes) && minutes > 0 ? formatWindowMinutes(minutes) : name, resetsAt }];
|
|
20
|
-
});
|
|
21
|
-
// every exhausted window must reset before a request can pass
|
|
22
|
-
return exhausted.sort((left, right) => right.resetsAt - left.resetsAt)[0];
|
|
23
|
-
}
|
|
24
|
-
function readResetsInSeconds(value, observedAt) {
|
|
25
|
-
return typeof value === 'number' && Number.isFinite(value) && value >= 0
|
|
26
|
-
? observedAt + Math.round(value * 1000)
|
|
27
|
-
: undefined;
|
|
28
|
-
}
|
|
29
|
-
/**
|
|
30
|
-
* The ChatGPT Codex backend reports a spent plan quota as `usage_limit_reached`, and a plan
|
|
31
|
-
* without Codex access as `usage_not_included`, in the 429 body or a `response.failed` frame.
|
|
32
|
-
*/
|
|
33
|
-
export const classifyOpenAiChatGptLimit = (failure) => {
|
|
34
|
-
const error = readOpenAiError(failure.body);
|
|
35
|
-
if (!error?.identifiers.some((identifier) => codexUsageLimitIdentifiers.has(identifier)))
|
|
36
|
-
return undefined;
|
|
37
|
-
const exhaustedWindow = readExhaustedWindow(failure.headers);
|
|
38
|
-
const resetsAt = readEpochSeconds(error.fields.resets_at)
|
|
39
|
-
?? readResetsInSeconds(error.fields.resets_in_seconds, failure.observedAt)
|
|
40
|
-
?? exhaustedWindow?.resetsAt;
|
|
41
|
-
const planType = error.fields.plan_type;
|
|
42
|
-
return {
|
|
43
|
-
kind: 'usage_limit',
|
|
44
|
-
...(resetsAt === undefined ? {} : { resetsAt }),
|
|
45
|
-
...(typeof planType === 'string' ? { planType } : {}),
|
|
46
|
-
...(exhaustedWindow ? { window: exhaustedWindow.label } : {}),
|
|
47
|
-
};
|
|
48
|
-
};
|
|
49
|
-
//# sourceMappingURL=data:application/json;base64,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
|
|
@@ -1,47 +0,0 @@
|
|
|
1
|
-
const isNonEmptyString = (value) => typeof value === 'string' && value.trim().length > 0;
|
|
2
|
-
const getSystemInstructions = (prompt) => {
|
|
3
|
-
const instructions = prompt
|
|
4
|
-
.filter((message) => message.role === 'system')
|
|
5
|
-
.map((message) => message.content)
|
|
6
|
-
.filter(isNonEmptyString);
|
|
7
|
-
return instructions.length > 0 ? instructions.join('\n') : undefined;
|
|
8
|
-
};
|
|
9
|
-
const hasUnsupportedChatGptCacheRetention = (options) => {
|
|
10
|
-
return options.promptCacheRetention !== undefined || options.prompt_cache_retention !== undefined;
|
|
11
|
-
};
|
|
12
|
-
/**
|
|
13
|
-
* ChatGPT's Codex backend requires top-level Responses API instructions.
|
|
14
|
-
* The standard OpenAI provider otherwise serializes system prompts as input items.
|
|
15
|
-
*/
|
|
16
|
-
export function createOpenAiChatGptInstructionsMiddleware() {
|
|
17
|
-
return {
|
|
18
|
-
specificationVersion: 'v4',
|
|
19
|
-
transformParams: async ({ params }) => {
|
|
20
|
-
const instructions = getSystemInstructions(params.prompt);
|
|
21
|
-
const providerOptions = params.providerOptions ?? {};
|
|
22
|
-
const openAiProviderOptions = providerOptions.openai ?? {};
|
|
23
|
-
const shouldApplyInstructions = !!instructions && !isNonEmptyString(openAiProviderOptions.instructions);
|
|
24
|
-
const shouldStripCacheRetention = hasUnsupportedChatGptCacheRetention(openAiProviderOptions);
|
|
25
|
-
if (!shouldApplyInstructions && !shouldStripCacheRetention) {
|
|
26
|
-
return params;
|
|
27
|
-
}
|
|
28
|
-
const nextOpenAiProviderOptions = { ...openAiProviderOptions };
|
|
29
|
-
delete nextOpenAiProviderOptions.promptCacheRetention;
|
|
30
|
-
delete nextOpenAiProviderOptions.prompt_cache_retention;
|
|
31
|
-
if (shouldApplyInstructions) {
|
|
32
|
-
nextOpenAiProviderOptions.instructions = instructions;
|
|
33
|
-
}
|
|
34
|
-
return {
|
|
35
|
-
...params,
|
|
36
|
-
prompt: shouldApplyInstructions
|
|
37
|
-
? params.prompt.filter((message) => message.role !== 'system')
|
|
38
|
-
: params.prompt,
|
|
39
|
-
providerOptions: {
|
|
40
|
-
...providerOptions,
|
|
41
|
-
openai: nextOpenAiProviderOptions,
|
|
42
|
-
},
|
|
43
|
-
};
|
|
44
|
-
},
|
|
45
|
-
};
|
|
46
|
-
}
|
|
47
|
-
//# sourceMappingURL=data:application/json;base64,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
|