agl 41.0.1 → 41.2.0

package/ts/classes.inferenceusage.ts

@@ -1,16 +1,19 @@
 import * as plugins from './plugins.js';
 import { inferenceProviders, type TInferenceProvider } from './functions.proxycontract.js';
-import type { IControllerUsageBucket, TControllerUsageSpan } from '../ts_interfaces/index.js';
+import type { IControllerUsageBucket, IControllerUsageCounts, TControllerUsageSpan } from '../ts_interfaces/index.js';
 
 /**
  * The tokens one answer used, by kind. Input counts only the tokens read neither from nor written to the provider's
  * prompt cache; the cache reads and writes are counted on their own, so the four add up to everything the answer used.
+ * `cacheReadTokens` and `cacheWriteTokens` are `null` when the answer did not state them, which is not the same as
+ * stating none. Whether the input count then holds them depends on the provider (`controllerUsageTotalIsLowerBound`):
+ * an OpenAI account's input counts every input token, an Anthropic account's leaves the cache out.
  */
 export interface IInferenceTokenCounts {
   inputTokens: number;
   outputTokens: number;
-  cacheReadTokens: number;
-  cacheWriteTokens: number;
+  cacheReadTokens: number | null;
+  cacheWriteTokens: number | null;
 }
 
 /**
@@ -33,8 +36,12 @@ export interface IInferenceUsageLedger {
   record(recordArg: IInferenceUsageRecord): void;
 }
 
+/** The counts a bucket stored before unknown cache counts were kept lacks. */
+type TUnknownCountKey = 'cacheReadUnknownCalls' | 'cacheWriteUnknownCalls';
+const unknownCountKeys: readonly TUnknownCountKey[] = ['cacheReadUnknownCalls', 'cacheWriteUnknownCalls'];
+
 /** One minute or hour of one model's tokens on one harness, account and session, as the proxy keeps it. */
-export interface IInferenceUsageBucket extends IInferenceTokenCounts {
+export interface IInferenceUsageBucket extends IControllerUsageCounts {
   /** The bucket's digest: SHA-256 of its span, start and dimensions. */
   id: string;
   span: TControllerUsageSpan;
@@ -45,16 +52,29 @@ export interface IInferenceUsageBucket extends IInferenceTokenCounts {
   harness: string | null;
   accountId: string;
   session: string | null;
-  /** The answers counted. */
-  calls: number;
   /** When a flush last added to the bucket. */
   updatedAt: Date;
 }
 
-export interface IInferenceUsageDocument extends IInferenceUsageBucket {
+/**
+ * A stored bucket. One written before unknown cache counts were kept has neither `cacheReadUnknownCalls` nor
+ * `cacheWriteUnknownCalls`: it did not record whether its answers stated their cache reads and writes, so each of its
+ * answers reads as one that stated neither.
+ */
+export interface IInferenceUsageDocument extends Omit<IInferenceUsageBucket, TUnknownCountKey>,
+  Partial<Pick<IInferenceUsageBucket, TUnknownCountKey>> {
   expiresAt: Date;
 }
 
+/** A stored bucket's counts, those of a bucket written before unknown cache counts were kept with every answer unknown. */
+const storedCounts = (documentArg: Omit<IInferenceUsageDocument, 'id' | 'span' | 'start' | 'provider' | 'model' | 'harness'
+  | 'accountId' | 'session' | 'updatedAt' | 'expiresAt'>): IControllerUsageCounts => ({
+  calls: documentArg.calls, inputTokens: documentArg.inputTokens, outputTokens: documentArg.outputTokens,
+  cacheReadTokens: documentArg.cacheReadTokens, cacheWriteTokens: documentArg.cacheWriteTokens,
+  cacheReadUnknownCalls: documentArg.cacheReadUnknownCalls ?? documentArg.calls,
+  cacheWriteUnknownCalls: documentArg.cacheWriteUnknownCalls ?? documentArg.calls,
+});
+
 /** A usage flush that failed, as the proxy reports it: no session id, prompt or account id. */
 export interface IInferenceUsageFlushFailure {
   /** The buckets kept for the next flush. */
@@ -96,10 +116,14 @@ const pageDocuments = 128;
 
 const validDate = (valueArg: unknown): valueArg is Date => valueArg instanceof Date && Number.isFinite(valueArg.getTime());
 const validCount = (valueArg: unknown): valueArg is number => Number.isSafeInteger(valueArg) && (valueArg as number) >= 0;
+/** A count of a bucket's answers: whole, and at most the answers it counts. */
+const countWithin = (countArg: unknown, callsArg: unknown): boolean => validCount(countArg) && validCount(callsArg) && countArg <= callsArg;
 
 const assertDocument: (valueArg: unknown) => asserts valueArg is IInferenceUsageDocument = (valueArg) => {
   const value = valueArg as Partial<IInferenceUsageDocument> | null;
-  if (!value || typeof value !== 'object' || Object.keys(value).length !== 15
+  // A bucket written before unknown cache counts were kept has neither of them; every bucket written since has both.
+  const kept = !!value && typeof value === 'object' && Object.hasOwn(value, 'cacheWriteUnknownCalls');
+  if (!value || typeof value !== 'object' || Object.keys(value).length !== 15 + (kept ? unknownCountKeys.length : 0)
     || typeof value.id !== 'string' || !hex64.test(value.id)
     || !usageSpans.includes(value.span as TControllerUsageSpan)
     || !validDate(value.start) || value.start.getTime() % spanMs[value.span as TControllerUsageSpan] !== 0
@@ -111,6 +135,7 @@ const assertDocument: (valueArg: unknown) => asserts valueArg is IInferenceUsage
     || !validCount(value.calls) || value.calls < 1
     || !validCount(value.inputTokens) || !validCount(value.outputTokens)
     || !validCount(value.cacheReadTokens) || !validCount(value.cacheWriteTokens)
+    || (kept && !unknownCountKeys.every((keyArg) => countWithin(value[keyArg], value.calls)))
     || !validDate(value.updatedAt) || !validDate(value.expiresAt)) {
     throw new Error('Invalid inference usage bucket.');
   }
@@ -134,6 +159,9 @@ export class InferenceUsageModel extends plugins.nosqldb.SmartDataDbDoc<Inferenc
   @plugins.nosqldb.svDb() public outputTokens!: number;
   @plugins.nosqldb.svDb() public cacheReadTokens!: number;
   @plugins.nosqldb.svDb() public cacheWriteTokens!: number;
+  /** These two are absent only on a bucket written before unknown cache counts were kept; every write sets them. */
+  @plugins.nosqldb.svDb() public cacheReadUnknownCalls?: number;
+  @plugins.nosqldb.svDb() public cacheWriteUnknownCalls?: number;
   @plugins.nosqldb.svDb()
   @plugins.nosqldb.index() public updatedAt!: Date;
   @plugins.nosqldb.svDb()
@@ -259,9 +287,11 @@ export class InferenceUsageStore implements IInferenceUsageLedger {
   public record(recordArg: IInferenceUsageRecord): void {
     try {
       if (this.stopped) return;
-      const counts = [recordArg.inputTokens, recordArg.outputTokens, recordArg.cacheReadTokens, recordArg.cacheWriteTokens];
+      const counts = [recordArg.inputTokens, recordArg.outputTokens, recordArg.cacheReadTokens ?? 0, recordArg.cacheWriteTokens ?? 0];
       if (!inferenceProviders.includes(recordArg.provider) || !usageModelPattern.test(recordArg.model)
         || (recordArg.harness !== null && !usageHarnessPattern.test(recordArg.harness)) || !hex64.test(recordArg.accountId)
+        || (recordArg.cacheReadTokens !== null && !validCount(recordArg.cacheReadTokens))
+        || (recordArg.cacheWriteTokens !== null && !validCount(recordArg.cacheWriteTokens))
         || !counts.every(validCount) || counts.every((countArg) => countArg === 0)) {
         this.droppedRecords += 1;
         return;
@@ -280,12 +310,12 @@ export class InferenceUsageStore implements IInferenceUsageLedger {
         this.droppedRecords += 1;
         return;
       }
+      const answer = answerCounts(recordArg);
       for (const { span, start, id } of buckets) {
         const held = this.pending.get(id);
-        if (held) { addCounts(held, recordArg, 1); continue; }
+        if (held) { addCounts(held, answer); continue; }
         this.pending.set(id, { id, span, start: new Date(start), provider: recordArg.provider, model: recordArg.model,
-          harness: recordArg.harness, accountId: recordArg.accountId, session, calls: 1, inputTokens: recordArg.inputTokens,
-          outputTokens: recordArg.outputTokens, cacheReadTokens: recordArg.cacheReadTokens, cacheWriteTokens: recordArg.cacheWriteTokens });
+          harness: recordArg.harness, accountId: recordArg.accountId, session, ...answer });
       }
     } catch {
       this.droppedRecords += 1;
@@ -364,7 +394,7 @@ export class InferenceUsageStore implements IInferenceUsageLedger {
     // The buckets that were not written join those recorded since, as far as the pending limit allows.
     for (const bucket of failed) {
       const held = this.pending.get(bucket.id);
-      if (held) addCounts(held, bucket, bucket.calls);
+      if (held) addCounts(held, bucket);
       else if (this.pending.size < maximumPendingBuckets) this.pending.set(bucket.id, bucket);
       else this.droppedRecords += bucket.calls;
     }
@@ -388,7 +418,10 @@ export class InferenceUsageStore implements IInferenceUsageLedger {
         return;
       }
       const result = await InferenceUsageModel.exact.transition({ current, change: (modelArg) => {
-        addCounts(modelArg, bucketArg, bucketArg.calls);
+        // A bucket written before unknown cache counts were kept gets them, its own answers as unknown.
+        const counts = storedCounts(modelArg);
+        addCounts(counts, bucketArg);
+        Object.assign(modelArg, counts);
         modelArg.updatedAt = updatedAt;
       } }, { signal: signalArg });
       if (result.status === 'transitioned') {
@@ -418,15 +451,21 @@ export class InferenceUsageStore implements IInferenceUsageLedger {
 }
 
 /** A stored bucket as a reader receives it: its start in Unix milliseconds, without its bookkeeping. */
-const wireBucket = (documentArg: IInferenceUsageBucket): IControllerUsageBucket => ({ id: documentArg.id, span: documentArg.span,
+const wireBucket = (documentArg: IInferenceUsageDocument): IControllerUsageBucket => ({ id: documentArg.id, span: documentArg.span,
   start: documentArg.start.getTime(), provider: documentArg.provider, model: documentArg.model, harness: documentArg.harness,
-  accountId: documentArg.accountId, session: documentArg.session, calls: documentArg.calls, inputTokens: documentArg.inputTokens,
-  outputTokens: documentArg.outputTokens, cacheReadTokens: documentArg.cacheReadTokens, cacheWriteTokens: documentArg.cacheWriteTokens });
+  accountId: documentArg.accountId, session: documentArg.session, ...storedCounts(documentArg) });
+
+/** One answer as a bucket counts it: the cache counts it stated, and for each it did not, one answer unknown. */
+const answerCounts = (countsArg: IInferenceTokenCounts): IControllerUsageCounts => ({ calls: 1, inputTokens: countsArg.inputTokens,
+  outputTokens: countsArg.outputTokens, cacheReadTokens: countsArg.cacheReadTokens ?? 0, cacheWriteTokens: countsArg.cacheWriteTokens ?? 0,
+  cacheReadUnknownCalls: countsArg.cacheReadTokens === null ? 1 : 0, cacheWriteUnknownCalls: countsArg.cacheWriteTokens === null ? 1 : 0 });
 
-const addCounts = (targetArg: IInferenceTokenCounts & { calls: number }, addArg: IInferenceTokenCounts, callsArg: number): void => {
-  targetArg.calls += callsArg;
+const addCounts = (targetArg: IControllerUsageCounts, addArg: IControllerUsageCounts): void => {
+  targetArg.calls += addArg.calls;
   targetArg.inputTokens += addArg.inputTokens;
   targetArg.outputTokens += addArg.outputTokens;
   targetArg.cacheReadTokens += addArg.cacheReadTokens;
   targetArg.cacheWriteTokens += addArg.cacheWriteTokens;
+  targetArg.cacheReadUnknownCalls += addArg.cacheReadUnknownCalls;
+  targetArg.cacheWriteUnknownCalls += addArg.cacheWriteUnknownCalls;
 };

package/ts/classes.inferenceusagetap.ts

@@ -29,6 +29,16 @@ interface IStatedUsage {
   ephemeral_1h_input_tokens?: number;
 }
 
+/**
+ * Which cache counts an Anthropic Messages answer stated: `reads` its `cache_read_input_tokens`, `writes` its
+ * `cache_creation_input_tokens` or its `cache_creation` split. Anthropic documents both as `number or null`, and a
+ * translated answer gives null for a count the model did not state.
+ */
+export interface IInferenceClaudeCacheStated {
+  reads: boolean;
+  writes: boolean;
+}
+
 /** What the relay hands each chunk of an answer it passed on, and the end of the answer. */
 export interface IInferenceUsageTap {
   chunk(bytesArg: Uint8Array): void;
@@ -43,7 +53,9 @@ export interface IInferenceUsageTap {
  * A stream (`sse`) states usage in `message_start` (`message.usage`, `message.model`) and in `message_delta` (`usage`,
  * cumulative), so only those events' data lines are parsed and every other line is skipped unread; a cut stream reports
  * what arrived. A JSON answer states `usage` and `model` at its top level and is read at its end. Anything unreadable
- * reports nothing: the estimate is the authority's, and the answer is never at stake.
+ * reports nothing: the estimate is the authority's, and the answer is never at stake. The report says which cache
+ * counts the answer stated (`IInferenceClaudeCacheStated`): one it did not state is unknown, not none. The usage
+ * reported for the estimate counts an unknown one as none, as the account service's token usage has no unknown.
  *
  * `answered`, given for an answer an API key served, takes at the end what the answer stated for its price: the model
  * that answered and its usage object as sent, a stream's merged field by field from `message_start` and the
@@ -66,7 +78,8 @@ export class InferenceClaudeUsageTap implements IInferenceUsageTap {
   private stopped = false;
   private ended = false;
 
-  constructor(private readonly format: 'sse' | 'json', private readonly report: (usageArg: TTokenUsage) => void,
+  constructor(private readonly format: 'sse' | 'json',
+    private readonly report: (usageArg: TTokenUsage, cacheStatedArg: IInferenceClaudeCacheStated) => void,
     private readonly answered?: (answeredArg: IInferenceAnsweredUsage) => void) {}
 
   /** Reads a chunk the relay passed on; never throws. */
@@ -102,7 +115,11 @@ export class InferenceClaudeUsageTap implements IInferenceUsageTap {
       }
       this.stopped = true;
       const usage = this.usage();
-      if (usage) this.report(usage);
+      if (usage) {
+        this.report(usage, { reads: this.stated.cache_read_input_tokens !== undefined,
+          writes: this.stated.cache_creation_input_tokens !== undefined || this.stated.ephemeral_5m_input_tokens !== undefined
+            || this.stated.ephemeral_1h_input_tokens !== undefined });
+      }
     } catch { this.stopped = true; } finally {
       try {
         this.answered?.({ ...(this.model === undefined ? {} : { model: this.model }), ...(this.raw ? { usage: this.raw } : {}),
@@ -207,7 +224,8 @@ const searchCallTypes: ReadonlyMap<string, 'web' | 'file'> = new Map([['web_sear
  * `response.output_item.done`; a data-only frame is kept up to the frame limit and parsed only when it names a terminal
  * type, or a finished output item that is a search call. A JSON answer states `usage` at its top level. `input_tokens`
  * counts every input token, so the cached reads (`cached_tokens`) and cache writes (`cache_write_tokens`) of
- * `input_tokens_details` are taken out of it.
+ * `input_tokens_details` are taken out of it. An answer that does not state `cached_tokens` or `cache_write_tokens`
+ * reports those as unknown (`null`), never as none, and its input count then holds whatever it read or wrote.
  *
  * `answered`, given for an answer an OpenAI API key served, takes at the end what the answer stated for its price
  * (`IInferenceResponsesAnswered`): whether its terminal event or its JSON body was read, arrived too large to read, or
@@ -380,10 +398,11 @@ export class InferenceResponsesUsageTap implements IInferenceUsageTap {
     const output = count(usage?.output_tokens);
     if (input === undefined && output === undefined) return undefined;
     const details = record(usage?.input_tokens_details);
-    const cacheRead = count(details?.cached_tokens) ?? 0;
-    const cacheWrite = count(details?.cache_write_tokens) ?? 0;
-    const counts: IInferenceTokenCounts = { inputTokens: Math.max(0, (input ?? 0) - cacheRead - cacheWrite),
+    const cacheRead = count(details?.cached_tokens) ?? null;
+    const cacheWrite = count(details?.cache_write_tokens) ?? null;
+    const counts: IInferenceTokenCounts = { inputTokens: Math.max(0, (input ?? 0) - (cacheRead ?? 0) - (cacheWrite ?? 0)),
       outputTokens: output ?? 0, cacheReadTokens: cacheRead, cacheWriteTokens: cacheWrite };
-    return counts.inputTokens + counts.outputTokens + counts.cacheReadTokens + counts.cacheWriteTokens > 0 ? counts : undefined;
+    return counts.inputTokens + counts.outputTokens + (counts.cacheReadTokens ?? 0) + (counts.cacheWriteTokens ?? 0) > 0
+      ? counts : undefined;
   }
 }

package/ts/classes.processinspection.ts

@@ -483,7 +483,8 @@ const readEffectiveArgvPort = (argumentsArg: string[]): number => {
 export const processIdentityHasCliCommand = async (
   identityArg: IControllerProcessIdentity,
   cliPathArg: string,
-  commandArg: '__serve' | '__upgrade-worker' | 'upgrade' | 'start' | 'restart' | 'service' | 'foreground' | 'temp-password' | 'config',
+  /** The CLI command the process runs; an upgrade owner may name a later release's (`IUpgradeProcessOwner`). */
+  commandArg: string,
   optionsArg: { allowMissingAbsolutePath?: boolean } = {},
 ): Promise<boolean> => {
   const cliIndex = await findCliArgumentIndex(

package/ts/classes.proxycontrol.ts

@@ -72,6 +72,8 @@ export interface IAglProxyStatus {
 export interface IAglProxyConfinedRunStatus {
   /** The run's id: the first 12 hex characters of its credential's SHA-256 digest, never the credential. */
   id: string;
+  /** The pool the run is served from: Claude accounts (`anthropic`) or ChatGPT accounts (`openai`). */
+  provider: TInferenceProvider;
   createdAt: string;
   /** False while a restarted proxy serves the credential for its reclaim window, waiting for its holder to take it back. */
   held: boolean;
@@ -148,24 +150,35 @@ export interface IReq_AglProxyReclaim extends ITypedRequest {
 
 /**
  * A confined run's credential: accepted on the confined listener alone, never on the loopback one, and served there from
- * the Claude pool exactly as the loopback listener serves a Claude client, its sessions those of the client
- * `aglProxyConfinedClient`. Like a lease it lives as long as the connection that asked for it, a restarted proxy keeps it
- * for its holder to take back (`agl.proxy.reclaim`), and the proxy keeps only its digest. `agl.proxy.confined.end` ends it
- * at once.
+ * the pool `provider` names -- the Claude pool when it names none -- exactly as the loopback listener serves Claude Code on
+ * that pool, its sessions those of the client `aglProxyConfinedClient` on that pool. A ChatGPT-pool run is served by the
+ * pool's ChatGPT accounts alone, since a translated Messages request never goes to an API key. Like a lease it lives as
+ * long as the connection that asked for it, a restarted proxy keeps it for its holder to take back
+ * (`agl.proxy.reclaim`), and the proxy keeps only its digest. `agl.proxy.confined.end` ends it at once.
  */
 export interface IReq_AglProxyConfined extends ITypedRequest {
   method: 'agl.proxy.confined';
-  request: Record<string, never>;
+  /** An empty request asks for a Claude-pool run, as every proxy since confined runs takes it. */
+  request: { provider?: TInferenceProvider };
   response: IAglProxyConfinedGrant;
 }
 
-/** What a confined run is given: its id, its credential, the confined listener's socket and the origin to name with it. */
+/**
+ * What a confined run is given: its id, its pool, its credential, the confined listener's socket and the origin to name
+ * with it, and, for a ChatGPT-pool run, the pool's models as the proxy read them when it issued the credential, which the
+ * launcher configures Claude Code with as `agl proxy run claude --provider openai` does. A Claude-pool run gets none:
+ * Claude Code reads that pool's models through the confined listener.
+ */
 export interface IAglProxyConfinedGrant {
   /** See `IAglProxyConfinedRunStatus.id`. */
   id: string;
+  /** The run's pool; a proxy older than ChatGPT-pool runs names none, and issues Claude-pool runs alone. */
+  provider?: TInferenceProvider;
   token: string;
   socketPath: string;
   baseUrl: string;
+  /** A ChatGPT-pool run's models, the pool's default among them; absent for a Claude-pool run. */
+  models?: TInferenceModel[];
 }
 
 /**
@@ -207,7 +220,7 @@ export interface IAglProxyControlHandlers {
   catalog(requestArg: IReq_AglProxyCatalog['request'], connectionArg: IAglProxyConnection): Promise<IReq_AglProxyCatalog['response']>;
   lease(requestArg: IReq_AglProxyLease['request'], connectionArg: IAglProxyConnection): Promise<IReq_AglProxyLease['response']>;
   reclaim(requestArg: IReq_AglProxyReclaim['request'], connectionArg: IAglProxyConnection): Promise<IReq_AglProxyReclaim['response']>;
-  confined(connectionArg: IAglProxyConnection): Promise<IReq_AglProxyConfined['response']>;
+  confined(requestArg: IReq_AglProxyConfined['request'], connectionArg: IAglProxyConnection): Promise<IReq_AglProxyConfined['response']>;
   confinedEnd(requestArg: IReq_AglProxyConfinedEnd['request']): Promise<IReq_AglProxyConfinedEnd['response']>;
   usage(requestArg: IReq_AglProxyUsage['request'], connectionArg: IAglProxyConnection): Promise<IReq_AglProxyUsage['response']>;
 }
@@ -303,8 +316,11 @@ export class AglProxyControlServer {
       return this.handlers!.reclaim(requestArg, connectionArg);
     }));
     this.router.addTypedHandler(handler<IReq_AglProxyConfined>('agl.proxy.confined', (requestArg, connectionArg) => {
-      if (!isRecord(requestArg) || Object.keys(requestArg).length !== 0) throw new AglProxyControlRefusal('Invalid proxy confined request.');
-      return this.handlers!.confined(connectionArg);
+      if (!isRecord(requestArg) || Object.keys(requestArg).some((keyArg) => keyArg !== 'provider')
+        || (requestArg.provider !== undefined && !inferenceProviders.includes(requestArg.provider))) {
+        throw new AglProxyControlRefusal('Invalid proxy confined request.');
+      }
+      return this.handlers!.confined(requestArg, connectionArg);
     }));
     this.router.addTypedHandler(handler<IReq_AglProxyConfinedEnd>('agl.proxy.confined.end', (requestArg) => {
       if (!isRecord(requestArg) || typeof requestArg.id !== 'string' || !aglProxyConfinedIdPattern.test(requestArg.id)

package/ts/classes.proxycontrolclient.ts

@@ -190,12 +190,15 @@ export class AglProxyControlClient {
   }
 
   /**
-   * A confined run's credential, the confined listener's socket and the origin to name with it; the credential lives as
-   * long as the returned connection (see `IReq_AglProxyConfined`).
+   * A confined run's credential on the pool `providerArg` names, the confined listener's socket and the origin to name
+   * with it; the credential lives as long as the returned connection (see `IReq_AglProxyConfined`). A Claude-pool run is
+   * asked for with the empty request every proxy since confined runs takes.
    */
-  public async confined(signalArg: AbortSignal): Promise<IReq_AglProxyConfined['response'] & IAglProxyLeaseConnection> {
+  public async confined(providerArg: TInferenceProvider,
+    signalArg: AbortSignal): Promise<IReq_AglProxyConfined['response'] & IAglProxyLeaseConnection> {
     let held: { socket: net.Socket; rest: Buffer } | undefined;
-    const response = await exchange<IReq_AglProxyConfined['response']>(this.socketPath, 'agl.proxy.confined', {},
+    const request: IReq_AglProxyConfined['request'] = providerArg === 'anthropic' ? {} : { provider: providerArg };
+    const response = await exchange<IReq_AglProxyConfined['response']>(this.socketPath, 'agl.proxy.confined', request,
       signalArg, (socketArg, restArg) => { held = { socket: socketArg, rest: restArg }; });
     return { ...response, ...leaseConnection(held) };
   }

package/ts/classes.proxydaemon.ts

@@ -8,7 +8,7 @@ import { InferenceRoutingError, type IInferenceRoutingPolicy } from './classes.i
 import { aglProxyConfinedClient, aglProxyConfinedOrigin, proxyClientNamePattern, type TInferenceProvider,
   type TProxyCredentialDelivery } from './functions.proxycontract.js';
 import { AglProxyControlRefusal, AglProxyControlServer, type IAglProxyConfinedGrant, type IAglProxyConnection,
-  type IAglProxyStatus, type IReq_AglProxyCatalog, type IReq_AglProxyReclaim,
+  type IAglProxyStatus, type IReq_AglProxyCatalog, type IReq_AglProxyConfined, type IReq_AglProxyReclaim,
   type TAglProxyLeaseCatalog } from './classes.proxycontrol.js';
 import { ProxyStore, type IProxySecretCodec } from './classes.proxystore.js';
 import type { InferenceUsageStore } from './classes.inferenceusage.js';
@@ -51,8 +51,16 @@ const catalogRefusal = (errorArg: unknown): AglProxyControlRefusal => new AglPro
   errorArg instanceof InferenceRoutingError ? errorArg.code : undefined,
 );
 
-/** The policy of every confined run's credential: the Claude pool, unrestricted, as Claude Code's own lease. */
-const confinedPolicy: IInferenceRoutingPolicy = Object.freeze({ provider: 'anthropic' });
+/**
+ * The policy of a confined run's credential, by its pool: the pool, unrestricted, as Claude Code's own lease on the Claude
+ * pool and `agl proxy run claude --provider openai`'s on the ChatGPT pool.
+ */
+const confinedPolicies: Readonly<Record<TInferenceProvider, IInferenceRoutingPolicy>> = Object.freeze({
+  anthropic: Object.freeze({ provider: 'anthropic' }),
+  // A ChatGPT-pool run's policy is the one `agl proxy run claude --provider openai` leases: its translated Messages
+  // requests go to the pool's ChatGPT accounts alone, never to an API key (see `IReq_AglProxyConfined`).
+  openai: Object.freeze({ provider: 'openai' }),
+});
 
 /** A confined run's id, as the operator names it: the first 12 hex characters of its credential's digest. */
 const confinedRunId = (digestArg: string): string => digestArg.slice(0, 12);
@@ -61,6 +69,8 @@ const confinedRunId = (digestArg: string): string => digestArg.slice(0, 12);
 interface IHeldLease {
   grant: IInferenceGatewayGrant;
   route: TInferenceGatewayRoute;
+  /** The pool the lease is served from; a policy that names none is the ChatGPT pool's, as the router reads it. */
+  provider: TInferenceProvider;
   createdAt: Date;
   /** The connection the lease lives as long as, while a holder has it. */
   holder?: IAglProxyConnection;
@@ -146,7 +156,7 @@ export class AglProxyDaemon {
       catalog: (requestArg, connectionArg) => this.catalog(requestArg, connectionArg),
       lease: (requestArg, connectionArg) => this.lease(requestArg.policy, requestArg.client, connectionArg),
       reclaim: async (requestArg, connectionArg) => this.reclaim(requestArg.token, connectionArg),
-      confined: (connectionArg) => this.confined(connectionArg),
+      confined: (requestArg, connectionArg) => this.confined(requestArg, connectionArg),
       confinedEnd: async (requestArg) => this.confinedEnd(requestArg.id),
       usage: async (requestArg, connectionArg) => 'since' in requestArg ? this.usage!.changes(requestArg)
         : await this.usage!.snapshot(requestArg, connectionArg.signal),
@@ -168,8 +178,8 @@ export class AglProxyDaemon {
       recentPlacements: status.recentPlacements, confinedSocketPath: this.options.confinedSocketPath ?? null,
       confinedRuns: [...this.leases].filter(([, heldArg]) => heldArg.route === 'confined')
         .sort(([, left], [, right]) => left.createdAt.getTime() - right.createdAt.getTime())
-        .map(([digestArg, heldArg]) => ({ id: confinedRunId(digestArg), createdAt: heldArg.createdAt.toISOString(),
-          held: heldArg.reclaimTimer === undefined })),
+        .map(([digestArg, heldArg]) => ({ id: confinedRunId(digestArg), provider: heldArg.provider,
+          createdAt: heldArg.createdAt.toISOString(), held: heldArg.reclaimTimer === undefined })),
     };
   }
 
@@ -289,7 +299,8 @@ export class AglProxyDaemon {
     // The lease continues the sessions of the client it is taken for (see `IReq_AglProxyLease`).
     try { lease = await service.open(policyArg, { sessionScope: clientArg }); }
     catch (errorArg) { throw new AglProxyControlRefusal(errorArg instanceof Error ? errorArg.message : 'The lease could not be opened.'); }
-    const held: IHeldLease = { grant: lease, route: 'loopback', createdAt: new Date(), holder: connectionArg };
+    const held: IHeldLease = { grant: lease, route: 'loopback', provider: policyArg.provider ?? 'openai', createdAt: new Date(),
+      holder: connectionArg };
     this.leases.set(lease.digest, held);
     try {
       await this.trackLeaseWrite(this.store!.recordLease({ digest: lease.digest, client: clientArg, policy: policyArg,
@@ -319,30 +330,45 @@ export class AglProxyDaemon {
    * proves the caller holds the credential the lease was issued with.
    */
   /**
-   * A confined run's credential (see `IReq_AglProxyConfined`): a lease of the Claude pool that continues the confined
-   * client's sessions and is accepted on the confined listener alone. It is kept, as its digest, before it is handed out,
-   * and ends when its holder's connection closes or the operator ends it (`confinedEnd`). No model list is read for it:
-   * Claude Code reads the pool's models through the confined listener, and the pool is judged at each request.
+   * A confined run's credential (see `IReq_AglProxyConfined`): a lease of the pool the request names -- the Claude pool
+   * when it names none -- that continues the confined client's sessions on that pool and is accepted on the confined
+   * listener alone. It is kept, as its digest, before it is handed out, and ends when its holder's connection closes or
+   * the operator ends it (`confinedEnd`). A Claude-pool run gets no model list: Claude Code reads the pool's models
+   * through the confined listener, and the pool is judged at each request. A ChatGPT-pool run gets the pool's models, as
+   * an `agl proxy run` lease does, for its launcher to configure Claude Code with.
    */
-  private async confined(connectionArg: IAglProxyConnection): Promise<IAglProxyConfinedGrant> {
+  private async confined(requestArg: IReq_AglProxyConfined['request'],
+    connectionArg: IAglProxyConnection): Promise<IAglProxyConfinedGrant> {
     const socketPath = this.options.confinedSocketPath;
     if (socketPath === undefined) throw new AglProxyControlRefusal('This AGL proxy has no confined listener.');
+    const provider = requestArg.provider ?? 'anthropic';
+    const policy = confinedPolicies[provider];
+    const service = this.service!;
     let lease: IInferenceGatewayLease;
-    try { lease = await this.service!.open(confinedPolicy, { sessionScope: aglProxyConfinedClient, route: 'confined' }); }
+    try { lease = await service.open(policy, { sessionScope: aglProxyConfinedClient, route: 'confined' }); }
     catch (errorArg) {
       throw new AglProxyControlRefusal(errorArg instanceof Error ? errorArg.message : 'The confined credential could not be issued.');
     }
-    const held: IHeldLease = { grant: lease, route: 'confined', createdAt: new Date(), holder: connectionArg };
+    const held: IHeldLease = { grant: lease, route: 'confined', provider, createdAt: new Date(), holder: connectionArg };
     this.leases.set(lease.digest, held);
     try {
       await this.trackLeaseWrite(this.store!.recordLease({ digest: lease.digest, client: aglProxyConfinedClient,
-        policy: confinedPolicy, createdAt: held.createdAt, route: 'confined' }));
+        policy, createdAt: held.createdAt, route: 'confined' }));
     } catch (errorArg) {
       this.endLease(lease.digest, held);
       throw new AglProxyControlRefusal(errorArg instanceof Error ? errorArg.message : 'The confined credential could not be recorded.');
     }
     connectionArg.onClose(() => this.endLease(lease.digest, held));
-    return { id: confinedRunId(lease.digest), token: lease.token, socketPath, baseUrl: aglProxyConfinedOrigin };
+    const grant: IAglProxyConfinedGrant = { id: confinedRunId(lease.digest), provider, token: lease.token, socketPath,
+      baseUrl: aglProxyConfinedOrigin };
+    if (provider === 'anthropic') return grant;
+    try {
+      // A launcher that goes away stops the model list read it asked for.
+      return { ...grant, models: await service.router.models(policy, AbortSignal.any([connectionArg.signal, AbortSignal.timeout(60_000)])) };
+    } catch (errorArg) {
+      this.endLease(lease.digest, held);
+      throw catalogRefusal(errorArg);
+    }
   }
 
   /**
@@ -414,7 +440,7 @@ export class AglProxyDaemon {
         await this.forgetLease(kept.digest);
         continue;
       }
-      const held: IHeldLease = { grant, route: kept.route, createdAt: kept.createdAt };
+      const held: IHeldLease = { grant, route: kept.route, provider: kept.policy.provider ?? 'openai', createdAt: kept.createdAt };
       held.reclaimTimer = setTimeout(() => this.endLease(kept.digest, held), Math.max(0, deadline - Date.now()));
       this.leases.set(kept.digest, held);
     }

package/ts/classes.proxyleaseholder.ts

@@ -1,6 +1,7 @@
 import * as plugins from './plugins.js';
-import type { IInferenceRoutingPolicy } from './classes.inferencerouter.js';
-import type { IReq_AglProxyReclaim, TAglProxyLeaseCatalog } from './classes.proxycontrol.js';
+import type { IInferenceRoutingPolicy, TInferenceModel } from './classes.inferencerouter.js';
+import type { IAglProxyConfinedGrant, IReq_AglProxyReclaim, TAglProxyLeaseCatalog } from './classes.proxycontrol.js';
+import type { TInferenceProvider } from './functions.proxycontract.js';
 import { AglProxyControlClient, AglProxyRefusedError, type IAglProxyLeaseConnection } from './classes.proxycontrolclient.js';
 
 /** The delays between attempts to take a lease back from a restarting proxy; the last one repeats. */
@@ -159,28 +160,56 @@ export class AglProxyLeaseHolder extends AglProxyHeldCredential {
   }
 }
 
+export interface IAglProxyConfinedHolderOptions extends IAglProxyHolderOptions {
+  /** The run's pool: Claude accounts (`anthropic`) or, translated, the ChatGPT accounts (`openai`). */
+  provider: TInferenceProvider;
+}
+
+/**
+ * Why a confined grant does not serve the pool it was asked for, or `undefined` when it does: a proxy older than
+ * ChatGPT-pool runs names no pool and issues Claude-pool runs alone, and a ChatGPT-pool run comes with the pool's models.
+ */
+const confinedGrantMismatch = (providerArg: TInferenceProvider, grantArg: IAglProxyConfinedGrant): string | undefined => {
+  if (providerArg === 'anthropic') {
+    return grantArg.provider === undefined || grantArg.provider === 'anthropic' ? undefined
+      : 'The AGL proxy issued a confined run of another pool than the Claude pool asked for.';
+  }
+  return grantArg.provider === 'openai' && Array.isArray(grantArg.models) ? undefined
+    : 'The AGL proxy issued no ChatGPT-pool confined run with the pool\'s models; it may run an AGL older than ChatGPT-pool runs.';
+};
+
 /**
  * A confined run's credential (see `IReq_AglProxyConfined`), held for as long as its container runs. It is configured
  * with the confined listener's socket, so one taken back on another socket cannot continue.
  */
 export class AglProxyConfinedHolder extends AglProxyHeldCredential {
   /** Takes a new confined run's credential of the proxy on `optionsArg.socketPath`, its control socket. */
-  public static async take(optionsArg: IAglProxyHolderOptions, signalArg: AbortSignal): Promise<AglProxyConfinedHolder> {
+  public static async take(optionsArg: IAglProxyConfinedHolderOptions, signalArg: AbortSignal): Promise<AglProxyConfinedHolder> {
     const control = new AglProxyControlClient(optionsArg.socketPath);
-    const grant = await control.confined(signalArg);
+    const grant = await control.confined(optionsArg.provider, signalArg);
+    const mismatch = confinedGrantMismatch(optionsArg.provider, grant);
+    if (mismatch !== undefined) {
+      grant.close();
+      throw new Error(mismatch);
+    }
     return new AglProxyConfinedHolder(control, grant, optionsArg);
   }
 
   /** The run's id, as `agl proxy confined end` and `agl proxy status` name it. */
   public readonly id: string;
+  /** The run's pool. */
+  public readonly provider: TInferenceProvider;
+  /** A ChatGPT-pool run's models as the proxy read them when it issued the credential; empty for a Claude-pool run. */
+  public readonly models: readonly TInferenceModel[];
   /** The confined listener's socket, on the host. */
   public readonly confinedSocketPath: string;
 
-  private constructor(controlArg: AglProxyControlClient,
-    grantArg: { id: string; baseUrl: string; token: string; socketPath: string } & IAglProxyLeaseConnection,
-    optionsArg: IAglProxyHolderOptions) {
+  private constructor(controlArg: AglProxyControlClient, grantArg: IAglProxyConfinedGrant & IAglProxyLeaseConnection,
+    optionsArg: IAglProxyConfinedHolderOptions) {
     super(controlArg, grantArg, optionsArg);
     this.id = grantArg.id;
+    this.provider = optionsArg.provider;
+    this.models = grantArg.models ?? [];
     this.confinedSocketPath = grantArg.socketPath;
   }
 

package/ts/classes.proxystore.ts

@@ -151,8 +151,9 @@ export interface IProxyLeaseDocument {
    */
   orphanedAt?: Date;
   /**
-   * `confined` for a confined run's credential, accepted on the confined listener alone, with the Claude pool's policy
-   * and the confined client's sessions; absent for a lease of the loopback listener.
+   * `confined` for a confined run's credential, accepted on the confined listener alone, with the policy of its pool,
+   * the Claude pool's or the ChatGPT pool's, unrestricted, and the confined client's sessions on that pool; absent for a
+   * lease of the loopback listener.
    */
   route?: 'confined';
 }
@@ -174,6 +175,10 @@ const assertLeasePolicy = (valueArg: unknown): IProxyLeasePolicyDocument => {
   return value;
 };
 
+/** A confined run's policy, as kept: one pool, unrestricted (see `IProxyLeaseDocument.route`). */
+const confinedLeasePolicies: ReadonlySet<string> = new Set([JSON.stringify({ provider: 'anthropic' }),
+  JSON.stringify({ provider: 'openai' })]);
+
 const assertLease: (valueArg: unknown) => asserts valueArg is IProxyLeaseDocument = (valueArg) => {
   const value = valueArg as Partial<IProxyLeaseDocument> | null;
   if (!value || typeof value !== 'object'
@@ -182,7 +187,7 @@ const assertLease: (valueArg: unknown) => asserts valueArg is IProxyLeaseDocumen
     || typeof value.client !== 'string' || !proxyClientNamePattern.test(value.client)
     || !isDate(value.createdAt) || (Object.hasOwn(value, 'orphanedAt') && !isDate(value.orphanedAt))
     || (Object.hasOwn(value, 'route') && (value.route !== 'confined' || value.client !== aglProxyConfinedClient
-      || JSON.stringify(value.policy) !== JSON.stringify({ provider: 'anthropic' })))) {
+      || !confinedLeasePolicies.has(JSON.stringify(value.policy))))) {
     throw new Error('Invalid proxy lease.');
   }
   assertLeasePolicy(value.policy);