@volter/twin-openai 0.1.1 → 2.0.0

package/dist/src/generated/ui.gen.json

@@ -0,0 +1 @@
+{"generatedBy":"scripts/derive-pack.ts","resources":{"Model":{"list":"/v1/models","retrieve":"/v1/models/{model}","actions":[],"states":{},"embeds":{}},"OpenAIFile":{"list":"/v1/files","retrieve":"/v1/files/{file_id}","create":{"path":"/v1/files","encoding":"multipart","body":[{"name":"expires_after","type":"FileExpirationAfter","required":false},{"name":"file","type":"string","required":true},{"name":"purpose","type":"string","required":true}]},"actions":[],"states":{},"embeds":{}},"FineTuningJob":{"list":"/v1/fine_tuning/jobs","retrieve":"/v1/fine_tuning/jobs/{fine_tuning_job_id}","create":{"path":"/v1/fine_tuning/jobs","encoding":"json","body":[{"name":"hyperparameters","type":"object","required":false},{"name":"integrations","type":"array","required":false},{"name":"metadata","type":"Metadata","required":false},{"name":"method","type":"FineTuneMethod","required":false},{"name":"model","type":"union","required":true},{"name":"seed","type":"integer","required":false},{"name":"suffix","type":"string","required":false},{"name":"training_file","type":"string","required":true},{"name":"validation_file","type":"string","required":false}]},"actions":[{"operation":"cancelFineTuningJob","method":"POST","path":"/v1/fine_tuning/jobs/{fine_tuning_job_id}/cancel","field":"status","from":["validating_files","queued","running","paused"],"to":"cancelled"},{"operation":"pauseFineTuningJob","method":"POST","path":"/v1/fine_tuning/jobs/{fine_tuning_job_id}/pause","field":"status","from":["validating_files","queued","running"],"to":"paused"},{"operation":"resumeFineTuningJob","method":"POST","path":"/v1/fine_tuning/jobs/{fine_tuning_job_id}/resume","field":"status","from":["paused"],"to":"queued"}],"states":{"status":["cancelled","paused","queued","running","succeeded","validating_files"]},"embeds":{}},"FineTuningJobEvent":{"list":"/v1/fine_tuning/jobs/{fine_tuning_job_id}/events","actions":[],"states":{},"embeds":{}},"FineTuningJobCheckpoint":{"list":"/v1/fine_tuning/jobs/{fine_tuning_job_id}/checkpoints","actions":[],"states":{},"embeds":{}},"VectorStoreObject":{"list":"/v1/vector_stores","retrieve":"/v1/vector_stores/{vector_store_id}","create":{"path":"/v1/vector_stores","encoding":"json","body":[{"name":"chunking_strategy","type":"union","required":false},{"name":"description","type":"string","required":false},{"name":"expires_after","type":"VectorStoreExpirationAfter","required":false},{"name":"file_ids","type":"array","required":false},{"name":"metadata","type":"Metadata","required":false},{"name":"name","type":"string","required":false}]},"actions":[],"states":{"status":["completed"]},"embeds":{}},"VectorStoreFileObject":{"list":"/v1/vector_stores/{vector_store_id}/files","retrieve":"/v1/vector_stores/{vector_store_id}/files/{file_id}","create":{"path":"/v1/vector_stores/{vector_store_id}/files","encoding":"json","body":[{"name":"attributes","type":"VectorStoreFileAttributes","required":false},{"name":"chunking_strategy","type":"ChunkingStrategyRequestParam","required":false},{"name":"file_id","type":"string","required":true}]},"actions":[],"states":{"status":["cancelled","completed","in_progress"]},"embeds":{}},"VectorStoreFileBatchObject":{"retrieve":"/v1/vector_stores/{vector_store_id}/file_batches/{batch_id}","create":{"path":"/v1/vector_stores/{vector_store_id}/file_batches","encoding":"json","body":[{"name":"attributes","type":"VectorStoreFileAttributes","required":false},{"name":"chunking_strategy","type":"ChunkingStrategyRequestParam","required":false},{"name":"file_ids","type":"array","required":false},{"name":"files","type":"array","required":false}]},"actions":[{"operation":"cancelVectorStoreFileBatch","method":"POST","path":"/v1/vector_stores/{vector_store_id}/file_batches/{batch_id}/cancel","field":"status","from":["in_progress"],"to":"cancelled"}],"states":{"status":["cancelled","completed","in_progress"]},"embeds":{}},"CreateChatCompletionResponse":{"list":"/v1/chat/completions","retrieve":"/v1/chat/completions/{completion_id}","create":{"path":"/v1/chat/completions","encoding":"json","body":[]},"actions":[],"states":{},"embeds":{}},"Response":{"retrieve":"/v1/responses/{response_id}","create":{"path":"/v1/responses","encoding":"json","body":[]},"actions":[{"operation":"cancelResponse","method":"POST","path":"/v1/responses/{response_id}/cancel","field":"status","from":["queued","in_progress"],"to":"cancelled"},{"operation":"cancelResponse","method":"POST","path":"/v1/responses/{response_id}/cancel","field":"status","from":["cancelled"]}],"states":{"status":["cancelled","completed","in_progress","queued"]},"embeds":{}},"BetaResponse":{"retrieve":"/v1/responses/{response_id}","create":{"path":"/v1/responses","encoding":"json","body":[]},"actions":[{"operation":"beta_cancelResponse","method":"POST","path":"/v1/responses/{response_id}/cancel","field":"status","from":["queued","in_progress"],"to":"cancelled"},{"operation":"beta_cancelResponse","method":"POST","path":"/v1/responses/{response_id}/cancel","field":"status","from":["cancelled"]}],"states":{"status":["cancelled","completed","in_progress","queued"]},"embeds":{}},"ItemResource":{"list":"/v1/responses/{response_id}/input_items","actions":[],"states":{},"embeds":{}},"BetaItemResource":{"list":"/v1/responses/{response_id}/input_items","actions":[],"states":{},"embeds":{}},"AssistantObject":{"list":"/v1/assistants","retrieve":"/v1/assistants/{assistant_id}","create":{"path":"/v1/assistants","encoding":"json","body":[{"name":"description","type":"union","required":false},{"name":"instructions","type":"union","required":false},{"name":"metadata","type":"Metadata","required":false},{"name":"model","type":"union","required":true},{"name":"name","type":"union","required":false},{"name":"reasoning_effort","type":"ReasoningEffort","required":false},{"name":"response_format","type":"union","required":false},{"name":"temperature","type":"union","required":false},{"name":"tool_resources","type":"union","required":false},{"name":"tools","type":"array","required":false},{"name":"top_p","type":"union","required":false}]},"actions":[],"states":{},"embeds":{}},"ThreadObject":{"retrieve":"/v1/threads/{thread_id}","create":{"path":"/v1/threads","encoding":"json","body":[{"name":"messages","type":"array","required":false},{"name":"metadata","type":"Metadata","required":false},{"name":"tool_resources","type":"union","required":false}]},"actions":[],"states":{},"embeds":{}},"MessageObject":{"list":"/v1/threads/{thread_id}/messages","retrieve":"/v1/threads/{thread_id}/messages/{message_id}","create":{"path":"/v1/threads/{thread_id}/messages","encoding":"json","body":[{"name":"attachments","type":"union","required":false},{"name":"content","type":"union","required":true},{"name":"metadata","type":"Metadata","required":false},{"name":"role","type":"string","required":true}]},"actions":[],"states":{},"embeds":{}},"RunObject":{"list":"/v1/threads/{thread_id}/runs","retrieve":"/v1/threads/{thread_id}/runs/{run_id}","create":{"path":"/v1/threads/{thread_id}/runs","encoding":"json","body":[{"name":"additional_instructions","type":"string","required":false},{"name":"additional_messages","type":"array","required":false},{"name":"assistant_id","type":"string","required":true},{"name":"instructions","type":"string","required":false},{"name":"max_completion_tokens","type":"integer","required":false},{"name":"max_prompt_tokens","type":"integer","required":false},{"name":"metadata","type":"Metadata","required":false},{"name":"model","type":"union","required":false},{"name":"parallel_tool_calls","type":"ParallelToolCalls","required":false},{"name":"reasoning_effort","type":"ReasoningEffort","required":false},{"name":"response_format","type":"AssistantsApiResponseFormatOption","required":false},{"name":"stream","type":"boolean","required":false},{"name":"temperature","type":"number","required":false},{"name":"tool_choice","type":"any","required":false},{"name":"tools","type":"array","required":false},{"name":"top_p","type":"number","required":false},{"name":"truncation_strategy","type":"any","required":false}]},"actions":[{"operation":"cancelRun","method":"POST","path":"/v1/threads/{thread_id}/runs/{run_id}/cancel","field":"status","from":["queued","in_progress","requires_action"],"to":"cancelling"},{"operation":"submitToolOuputsToRun","method":"POST","path":"/v1/threads/{thread_id}/runs/{run_id}/submit_tool_outputs","field":"status","from":["requires_action"],"to":"queued"}],"states":{"status":["cancelled","cancelling","completed","in_progress","queued","requires_action"]},"embeds":{}},"RunStepObject":{"list":"/v1/threads/{thread_id}/runs/{run_id}/steps","retrieve":"/v1/threads/{thread_id}/runs/{run_id}/steps/{step_id}","actions":[],"states":{},"embeds":{}},"Project":{"list":"/v1/organization/projects","retrieve":"/v1/organization/projects/{project_id}","create":{"path":"/v1/organization/projects","encoding":"json","body":[{"name":"external_key_id","type":"union","required":false},{"name":"geography","type":"union","required":false},{"name":"name","type":"string","required":true},{"name":"residency","type":"union","required":false}]},"actions":[{"operation":"archive-project","method":"POST","path":"/v1/organization/projects/{project_id}/archive","field":"status","from":"*","to":"archived"}],"states":{"status":["active","archived"]},"embeds":{}},"ProjectApiKey":{"list":"/v1/organization/projects/{project_id}/api_keys","retrieve":"/v1/organization/projects/{project_id}/api_keys/{api_key_id}","actions":[],"states":{},"embeds":{}},"UsageTimeBucket":{"list":"/v1/organization/costs","actions":[],"states":{},"embeds":{}},"Eval":{"list":"/v1/evals","retrieve":"/v1/evals/{eval_id}","create":{"path":"/v1/evals","encoding":"json","body":[{"name":"data_source_config","type":"union","required":true},{"name":"metadata","type":"Metadata","required":false},{"name":"name","type":"string","required":false},{"name":"testing_criteria","type":"array","required":true}]},"actions":[],"states":{},"embeds":{}},"EvalRun":{"list":"/v1/evals/{eval_id}/runs","retrieve":"/v1/evals/{eval_id}/runs/{run_id}","create":{"path":"/v1/evals/{eval_id}/runs","encoding":"json","body":[{"name":"data_source","type":"union","required":true},{"name":"metadata","type":"Metadata","required":false},{"name":"name","type":"string","required":false}]},"actions":[{"operation":"cancelEvalRun","method":"POST","path":"/v1/evals/{eval_id}/runs/{run_id}","field":"status","from":["queued","in_progress"],"to":"canceled"}],"states":{"status":["canceled","completed","in_progress","queued"]},"embeds":{}},"EvalRunOutputItem":{"list":"/v1/evals/{eval_id}/runs/{run_id}/output_items","actions":[],"states":{},"embeds":{}},"ContainerResource":{"list":"/v1/containers","retrieve":"/v1/containers/{container_id}","create":{"path":"/v1/containers","encoding":"json","body":[{"name":"expires_after","type":"object","required":false},{"name":"file_ids","type":"array","required":false},{"name":"memory_limit","type":"string","required":false},{"name":"name","type":"string","required":true},{"name":"network_policy","type":"union","required":false},{"name":"skills","type":"array","required":false}]},"actions":[],"states":{"status":["expired","running"]},"embeds":{}},"ContainerFileResource":{"list":"/v1/containers/{container_id}/files","retrieve":"/v1/containers/{container_id}/files/{file_id}","create":{"path":"/v1/containers/{container_id}/files","encoding":"json","body":[{"name":"file","type":"string","required":false},{"name":"file_id","type":"string","required":false}]},"actions":[],"states":{},"embeds":{}},"Batch":{"list":"/v1/batches","retrieve":"/v1/batches/{batch_id}","create":{"path":"/v1/batches","encoding":"json","body":[{"name":"completion_window","type":"string","required":true},{"name":"endpoint","type":"string","required":true},{"name":"input_file_id","type":"string","required":true},{"name":"metadata","type":"Metadata","required":false},{"name":"output_expires_after","type":"BatchFileExpirationAfter","required":false}]},"actions":[{"operation":"cancelBatch","method":"POST","path":"/v1/batches/{batch_id}/cancel","field":"status","from":["validating","in_progress","finalizing"],"to":"cancelling"}],"states":{"status":["cancelled","cancelling","completed","finalizing","in_progress","validating"]},"embeds":{}},"Upload":{"actions":[],"states":{"status":["cancelled","completed","expired","pending"]},"embeds":{}}}}

package/dist/src/index.d.ts

@@ -0,0 +1,19 @@
+export { handleOpenAITwinRequest, streamChat } from './openai-twin.js';
+export type { OpenAIRequest, OpenAIResponseEnvelope } from './openai-twin.js';
+export { createOpenAITwinFetch, createOpenAITwinServer } from './openai-server.js';
+export type { OpenAITwinFetchOptions } from './openai-server.js';
+export { OPENAI_MODELS, findModel } from './openai-models.js';
+export type { OpenAIModel } from './openai-models.js';
+export { countPromptTokens, estimateTokens, stubAssistantText, stubToolCall, contentToText, lastUserText, pseudoEmbedding, moderateText, MODERATION_CATEGORIES, } from './openai-stub.js';
+export type { ModerationResult } from './openai-stub.js';
+export type { ChatMessageParam, ChatToolCall, ChatCompletion, ChatChoice, ChatUsage, OpenAIResponse, EmbeddingResponse, Embedding, OpenAIError, SseEvent, SseSink, } from './openai-types.js';
+export { performOpenAIAction, openaiExecuteOver, openaiRequestForAction, liveOpenAIExecute, mapFile, mapBatch, mapFineTune, mapVectorStore, pullOpenAIState, pushOpenAIAction, syncOpenAIFromReal, } from './openai-connector.js';
+export type { OpenAIExecute, LiveOpenAIOptions } from './openai-connector.js';
+export { OPENAI_BUDGET_CEILING, OPENAI_BUDGET_MAX_RETRY_AFTER_S, OPENAI_BUDGET_WINDOW_MS, OPENAI_CALL_WEIGHTS, OPENAI_RATE_BUDGET, OpenAIBudget, OpenAIBudgetError, openaiBudgetPath, openaiCallWeight, } from './openai-budget.js';
+export type { OpenAIBudgetErrorKind, OpenAIBudgetOptions, OpenAIBudgetReservation, OpenAIBudgetSnapshot } from './openai-budget.js';
+export { verifyOpenAIWebhook, computeOpenAIWebhookSignature, buildSignedOpenAIWebhook, OpenAIWebhookVerificationError, OPENAI_WEBHOOK_EVENT_TYPES, } from './openai-webhooks.js';
+export type { OpenAIWebhookEvent } from './openai-webhooks.js';
+import type { TwinPack } from '@volter/world-core';
+export declare const pack: TwinPack;
+export { createOpenAIScenarioEngine, loadOpenAIScenarioDocument, openaiScenarioAdapter, realizeOpenAIRespond } from './openai-scenario.js';
+export type { OpenAIScenarioEngine, OpenAIScenarioRequest, OpenAIScenarioRespond } from './openai-scenario.js';

package/dist/src/index.js

@@ -0,0 +1,72 @@
+// @volter/twin-openai — the OpenAI twin (one vendor, one package), built on the shared
+// @volter/world-core kernel. The OpenAI API: a vendor-faithful protocol envelope (chat
+// completions/streaming/tool_calls, the Responses API, embeddings), a static models catalog,
+// deterministic moderations, and STATEFUL files / batches / fine-tuning jobs / vector stores —
+// over an event/action log. (OpenAI is an API-first vendor with no meaningful product UI worth
+// mirroring — docs/contributing/architecture.md C1b — so this pack ships no mirror.)
+//
+// THE HONEST CARVE-OUTS: the twin cannot run the model, so POST /v1/chat/completions and
+// /v1/responses return a DETERMINISTIC STUB completion (clearly labeled), and /v1/embeddings
+// returns DETERMINISTIC pseudo-vectors — never pretending to be real inference. Everything
+// around them — the wire protocol — is faithful. (Conformance + capability tooling live in
+// @volter/world-tooling, a dev dependency — NOT re-exported here, per E2.)
+export { handleOpenAITwinRequest, streamChat } from "./openai-twin.js";
+export { createOpenAITwinFetch, createOpenAITwinServer } from "./openai-server.js";
+export { OPENAI_MODELS, findModel } from "./openai-models.js";
+export { countPromptTokens, estimateTokens, stubAssistantText, stubToolCall, contentToText, lastUserText, pseudoEmbedding, moderateText, MODERATION_CATEGORIES, } from "./openai-stub.js";
+export { performOpenAIAction, openaiExecuteOver, openaiRequestForAction, liveOpenAIExecute, mapFile, mapBatch, mapFineTune, mapVectorStore, pullOpenAIState, pushOpenAIAction, syncOpenAIFromReal, } from "./openai-connector.js";
+// The client-side rate budget — the fail-closed backstop `liveOpenAIExecute` routes every live
+// request through. The MECHANISM is the kernel's shared, vendor-agnostic `RateBudget`; what lives
+// here is OpenAI's DECLARATION (window/ceiling/per-endpoint weights) plus the vendor-bound
+// bindings. Exported so an operator can inspect spend (`snapshot`) and so a caller can catch
+// `OpenAIBudgetError` by type; there is deliberately no export that disables the guard.
+export { OPENAI_BUDGET_CEILING, OPENAI_BUDGET_MAX_RETRY_AFTER_S, OPENAI_BUDGET_WINDOW_MS, OPENAI_CALL_WEIGHTS, OPENAI_RATE_BUDGET, OpenAIBudget, OpenAIBudgetError, openaiBudgetPath, openaiCallWeight, } from "./openai-budget.js";
+export { verifyOpenAIWebhook, computeOpenAIWebhookSignature, buildSignedOpenAIWebhook, OpenAIWebhookVerificationError, OPENAI_WEBHOOK_EVENT_TYPES, } from "./openai-webhooks.js";
+import { registerPack } from '@volter/world-core';
+import { OPENAI_RATE_BUDGET as RATE_BUDGET } from "./openai-budget.js";
+import { performOpenAIAction } from "./openai-connector.js";
+export const pack = {
+    vendor: 'openai',
+    // PROTOCOL 2 (docs/contributing/architecture.md#protocol-2-the-pack-is-a-plugin): the wire, the tree, and the real apply — a recorded call
+    // forwarded as the same request. A generative vendor has no state to refresh from.
+    protocol: '2',
+    stateSystem: { perform: performOpenAIAction },
+    roundTrip: { method: 'POST', path: '/v1/chat/completions', body: { model: 'gpt-4o-mini', messages: [{ role: 'user', content: 'round trip' }] }, headers: { authorization: 'Bearer sk-round-trip' } },
+    // The SAME object openai-budget.ts declares at module load — one source of truth, so registering
+    // the pack and importing the connector can never arm two different ceilings.
+    rateBudget: RATE_BUDGET,
+    transport: 'rest',
+    archetype: 'generative',
+    bin: 'world-openai',
+    resources: ['file', 'batch', 'fine_tuning_job', 'vector_store', 'vector_store_file', 'response', 'chat_completion'],
+    specSource: 'OpenAI API (envelope-faithful; model output is a deterministic stub, embeddings are deterministic pseudo-vectors)',
+    description: 'OpenAI API twin — faithful protocol envelope (chat completions/streaming/tool_calls, Responses API, embeddings), models, moderations, stateful files/batches/fine-tuning/vector stores; generative output is a labeled stub.',
+    // Adoption + interception, all in the pack's one home (descriptor-first back-migration, adding-a-twin.md §3,
+    // 2026-08-31; the bare `openai` stem and both SDK names moved off the central maps unchanged).
+    // The stems are the bare OPENAI_* pair plus the credential-var shapes real apps use beside it
+    // (AP_OPENAI_*, OPENAI_MODERATION_*).
+    adoption: {
+        // OpenAI's official Python library and Agents SDK. THE DISTRIBUTION IS THE CLAIM: `openai` stays
+        // this pack's even when a caller points it at DeepSeek, xAI, OpenRouter, Perplexity, an AI Gateway
+        // or an Azure OpenAI endpoint - those packs claim the ENDPOINT ENV that routes it, never this name.
+        // `tiktoken` is deliberately UNCLAIMED: it is a local tokenizer that makes no API call at all.
+        pypi: ['openai', 'openai-agents'],
+        sdks: ['openai', '@ai-sdk/openai'],
+        // 'REWORKDPLATFORMOPENAI' — AgentGPT names its key REWORKD_PLATFORM_OPENAI_API_KEY, the same
+        // app-prefixed shape as APOPENAI (ladder classification 2026-09-02). Deliberately NOT
+        // 'OPENAIOAUTH': postiz's OPENAI_OAUTH_CLIENT_ID is the client id its own MCP OAuth SERVER
+        // accepts from the ChatGPT connector — inbound, no api.openai.com call — so it is ruled
+        // not-a-vendor in the packless registry instead.
+        envStems: ['OPENAI', 'APOPENAI', 'OPENAIMODERATION', 'REWORKDPLATFORMOPENAI'],
+    },
+    // The whole REST surface the `openai` SDK talks to uses one base, https://api.openai.com — the
+    // same default the pack's own connector pins (openai-connector.ts).
+    hosts: [{ host: 'api.openai.com' }, { host: 'platform.openai.com', pathPattern: '^/(settings/proj[-_][^/]+/api-keys|login$)' }],
+    // The SDK calls the same-origin '/v1/…' and loads from api.openai.com — the dev proxy
+    // forwards '/v1/' to the twin and strips the absolute host so calls come back same-origin.
+    browserRouting: { apiPathPrefix: '/v1/', loaderHost: 'https://api.openai.com' },
+};
+export { createOpenAIScenarioEngine, loadOpenAIScenarioDocument, openaiScenarioAdapter, realizeOpenAIRespond } from "./openai-scenario.js";
+// PROTOCOL 2: the pack registers itself on load — its rate budget and its state system (the head
+// resolves `stateSystemFor(vendor)` in the process that serves the twin).
+registerPack(pack);

package/dist/src/manifest.d.ts

@@ -0,0 +1,6 @@
+import type { DerivedManifest } from '@volter/world-core';
+/** A file attached to a store as OpenAI shows it: its id is the file's, not the twin's composite key. */
+export declare function vectorStoreFileView(body: Record<string, unknown>, subject: {
+    id: string;
+}): Record<string, unknown>;
+export declare const manifest: DerivedManifest;

package/dist/src/manifest.js

@@ -0,0 +1,323 @@
+const vendor = (from, to, source, effects) => ({ actor: 'vendor', from, to, source, ...(effects ? { effects } : {}) });
+const time = (from, to, source, effects) => ({ actor: 'time', from, to, source, ...(effects ? { effects } : {}) });
+/** A Batch's `status`. OpenAI validates, runs and finalizes a batch on its own; the twin does that work
+ *  when a read first looks (semantics/progress.ts). Only a batch still in flight can be cancelled: it is
+ *  `cancelling` until OpenAI stops it (https://platform.openai.com/docs/guides/batch#batch-object). */
+const BATCH_DOCS = 'spec:/components/schemas/Batch/properties/status "The current status of the batch."';
+const batchStatus = {
+    initial: 'validating',
+    transitions: [
+        {
+            operation: 'cancelBatch',
+            from: ['validating', 'in_progress', 'finalizing'],
+            to: 'cancelling',
+            effects: { cancelling_at: { now: true } },
+            refusal: { status: 409, message: "Cannot cancel a batch with status '{from}'." },
+            source: 'spec:cancelBatch "The batch will be in status `cancelling` for up to 10 minutes, before changing to `cancelled`"',
+        },
+        vendor(['validating'], 'in_progress', BATCH_DOCS, { in_progress_at: { now: true } }),
+        vendor(['in_progress'], 'finalizing', BATCH_DOCS, { finalizing_at: { now: true } }),
+        vendor(['finalizing'], 'completed', BATCH_DOCS, { completed_at: { now: true } }),
+        vendor(['cancelling'], 'cancelled', BATCH_DOCS, { cancelled_at: { now: true } }),
+        // OpenAI also fails a batch whose input does not validate and expires one not done in its completion
+        // window; the twin validates every input and works a batch the moment a read looks, so it does neither
+    ],
+};
+/** A fine-tuning job's `status`. OpenAI validates the files, queues and trains on its own; the twin
+ *  finishes that work when a read first looks, unless the job is paused. Cancel stops a job still in
+ *  flight, pause one not yet finished, resume a paused one. `paused` is OpenAI's, though its spec's
+ *  enum omits it. A resumed job is queued again. */
+const invalidStatus = (verb) => ({ status: 400, code: 'invalid_status', message: `Cannot ${verb} a job with status '{from}'.` });
+const FT_DOCS = 'spec:/components/schemas/FineTuningJob/properties/status "The current status of the fine-tuning job"';
+const fineTuningJobStatus = {
+    initial: 'validating_files',
+    transitions: [
+        { operation: 'cancelFineTuningJob', from: ['validating_files', 'queued', 'running', 'paused'], to: 'cancelled', refusal: invalidStatus('cancel'), source: 'spec:cancelFineTuningJob "Immediately cancel a fine-tune job."' },
+        { operation: 'pauseFineTuningJob', from: ['validating_files', 'queued', 'running'], to: 'paused', refusal: invalidStatus('pause'), source: 'spec:pauseFineTuningJob "Pause a fine-tune job."' },
+        // a resumed job queues again (the reference's resume example answers `"status": "queued"`)
+        { operation: 'resumeFineTuningJob', from: ['paused'], to: 'queued', refusal: invalidStatus('resume'), source: 'spec:resumeFineTuningJob "Resume a fine-tune job."' },
+        vendor(['validating_files'], 'queued', FT_DOCS),
+        vendor(['queued'], 'running', FT_DOCS),
+        vendor(['running'], 'succeeded', FT_DOCS, { finished_at: { now: true } }),
+        // OpenAI also fails a job whose files do not validate; the twin trains on any file, so none fails
+    ],
+};
+/** A response's `status`, for the GA and the beta operations alike. A foreground response is answered
+ *  `completed`; a background one is created `queued` and OpenAI works it on its own, over time on the
+ *  World clock. Only a queued or in-progress one can be cancelled, and cancelling a
+ *  cancelled one again answers it as it is (https://platform.openai.com/docs/guides/background). */
+const BACKGROUND = 'https://platform.openai.com/docs/guides/background';
+const responseStatus = (prefix) => ({
+    initial: 'completed',
+    transitions: [
+        {
+            operation: `${prefix}cancelResponse`,
+            from: ['queued', 'in_progress'],
+            to: 'cancelled',
+            refusal: { status: 400, code: 'invalid_status', message: "Cannot cancel a response with status '{from}'." },
+            source: 'spec:cancelResponse "Only responses created with the `background` parameter set to `true` can be cancelled."',
+        },
+        { operation: `${prefix}cancelResponse`, from: ['cancelled'], source: BACKGROUND },
+        // OpenAI writes a background response over time: queued, in progress, completed (semantics/responses.ts
+        // times it); it may also fail it or leave it incomplete, which a stub that runs no model never does
+        vendor(['queued'], 'in_progress', BACKGROUND),
+        vendor(['queued', 'in_progress'], 'completed', BACKGROUND),
+    ],
+});
+/** A run's `status`. OpenAI queues a run and works it on its own, stopping at `requires_action` for
+ *  its function tools' outputs; the twin works it when a read first looks: a run with function tools
+ *  stops for them (the placeholder model calls them), then, once they are submitted, ends with a labeled
+ *  stub reply. Only a run in flight can be cancelled (`cancelling` until OpenAI stops it), and only one
+ *  waiting on tools takes outputs. */
+const RUN_DOCS = 'spec:/components/schemas/RunObject/properties/status "The status of the run, which can be either `queued`, `in_progress`, `requires_action`, `cancelling`, `cancelled`, `failed`, `completed`, `incomplete`"';
+const runStatus = {
+    initial: 'queued',
+    transitions: [
+        {
+            operation: 'cancelRun',
+            from: ['queued', 'in_progress', 'requires_action'],
+            to: 'cancelling',
+            // a run being cancelled needs no action ("Will be `null` if no action is required", RunObject.required_action)
+            effects: { required_action: { value: null } },
+            refusal: { status: 400, message: "Cannot cancel run with status '{from}'." },
+            source: 'spec:cancelRun "Cancels a run that is `in_progress`."',
+        },
+        {
+            operation: 'submitToolOuputsToRun',
+            from: ['requires_action'],
+            to: 'queued',
+            refusal: { status: 400, message: 'Runs in status "{from}" do not accept tool outputs.' },
+            source: 'spec:submitToolOuputsToRun "When a run has the `status: \"requires_action\"`"',
+        },
+        vendor(['queued'], 'in_progress', RUN_DOCS, { started_at: { now: true } }),
+        vendor(['in_progress'], 'completed', RUN_DOCS, { completed_at: { now: true } }),
+        // a run whose model calls its function tools stops for their outputs
+        // (https://platform.openai.com/docs/assistants/tools/function-calling)
+        vendor(['in_progress'], 'requires_action', RUN_DOCS),
+        vendor(['cancelling'], 'cancelled', RUN_DOCS, { cancelled_at: { now: true } }),
+        // OpenAI also fails a run, leaves it incomplete or expires it; the twin's stub model never does
+    ],
+};
+/** A project's `status`: archive moves any project to `archived`, stamping when. */
+const projectStatus = {
+    initial: 'active',
+    transitions: [
+        { operation: 'archive-project', from: '*', to: 'archived', effects: { archived_at: { now: true } }, source: 'spec:archive-project "Archives a project in the organization. Archived projects cannot be used or updated."' },
+    ],
+};
+/** A vector store's `status`: it is `in_progress` while OpenAI embeds files added to it, and expires
+ *  when its `expires_after` policy runs out. The twin embeds nothing, so a store stays `completed`. */
+// the twin neither embeds nor keeps an expiry policy, so no move of a store's status is the twin's
+// (OpenAI's: "The status of the vector store, which can be either `expired`, `in_progress`, or `completed`.")
+const vectorStoreStatus = { initial: 'completed', transitions: [] };
+/** A file attached to a store, or a batch of them: OpenAI processes it on its own (the twin, when a read
+ *  first looks); cancelling the batch cancels what is still in progress, and a finished batch is refused. */
+// Extrapolation: the wording of OpenAI's refusal to cancel a finished batch or eval run is not sourced from
+// a recording; that only one in progress can be cancelled is (the spec's operation descriptions).
+const notInFlight = (what) => ({ status: 400, message: `Cannot cancel ${what} with status '{from}'.` });
+const vectorStoreFileStatus = (source, refusal) => ({
+    initial: 'in_progress',
+    transitions: [
+        // the batch is the cancel's subject (its files stop when the cancel lands, the vendor's move below)
+        ...(refusal ? [{ operation: 'cancelVectorStoreFileBatch', from: ['in_progress'], to: 'cancelled', refusal, source: 'spec:cancelVectorStoreFileBatch "Cancel a vector store file batch."' }] : []),
+        vendor(['in_progress'], 'completed', source),
+        // a cancel asked for lands once the work in flight is done (semantics/vector-stores.ts)
+        vendor(['in_progress'], 'cancelled', 'spec:cancelVectorStoreFileBatch "This attempts to cancel the processing of files in this batch as soon as possible."'),
+        // OpenAI fails a file it cannot parse; the twin embeds nothing, so none fails
+    ],
+});
+/** An Upload's `status` (the spec declares no Upload resource: semantics/uploads.ts serves it). Parts
+ *  are added and it is completed or cancelled only while `pending`; an hour after creation it expires.
+ *  OpenAI answers a finished Upload as though it were not there. */
+const UPLOAD_DOCS = 'spec:/components/schemas/Upload/properties/status "The status of the Upload."';
+const noUpload = { status: 404, message: 'No such Upload object: {id}' };
+const uploadStatus = {
+    initial: 'pending',
+    transitions: [
+        { operation: 'addUploadPart', from: ['pending'], refusal: noUpload, source: 'spec:addUploadPart "Adds a [Part]"' },
+        { operation: 'completeUpload', from: ['pending'], to: 'completed', refusal: noUpload, source: 'spec:completeUpload "Completes the [Upload]"' },
+        { operation: 'cancelUpload', from: ['pending'], to: 'cancelled', refusal: noUpload, source: 'spec:cancelUpload "No Parts may be added after an Upload is cancelled."' },
+        time(['pending'], 'expired', UPLOAD_DOCS),
+    ],
+};
+/** A container's `status`: running while in use, expired once idle past its `expires_after` (by default
+ *  20 minutes after `last_active_at`), observed when a read or a use looks (semantics/containers.ts).
+ *  An expired container's files can no longer be listed, read, added or removed. */
+const CONTAINERS = 'https://platform.openai.com/docs/guides/tools-code-interpreter#containers';
+// Extrapolation: the status, code and wording of OpenAI's refusal to use an expired container are not
+// sourced from a recording; the rule that an expired container cannot be used is (CONTAINERS).
+const containerExpired = { status: 400, code: 'container_expired', message: 'Container {id} is expired.' };
+const inRunning = (operation) => ({ operation, from: ['running'], refusal: containerExpired, source: CONTAINERS });
+const containerStatus = {
+    initial: 'running',
+    transitions: [
+        time(['running'], 'expired', CONTAINERS),
+        ...['CreateContainerFile', 'ListContainerFiles', 'RetrieveContainerFile', 'RetrieveContainerFileContent', 'DeleteContainerFile'].map(inRunning),
+    ],
+};
+/** An eval run's `status`: OpenAI queues and grades it on its own; the twin grades it (a stub grader)
+ *  when a read first looks. A run in flight can be cancelled. */
+const EVAL_DOCS = 'spec:/components/schemas/EvalRun/properties/status "The status of the evaluation run."';
+const evalRunStatus = {
+    initial: 'queued',
+    transitions: [
+        { operation: 'cancelEvalRun', from: ['queued', 'in_progress'], to: 'canceled', refusal: notInFlight('an eval run'), source: 'spec:cancelEvalRun "Cancel an ongoing evaluation run."' },
+        vendor(['queued'], 'in_progress', EVAL_DOCS),
+        vendor(['in_progress'], 'completed', EVAL_DOCS),
+        // OpenAI fails a run whose data source or model errors; the twin grades with a stub, which never does
+    ],
+};
+/** A file attached to a store as OpenAI shows it: its id is the file's, not the twin's composite key. */
+export function vectorStoreFileView(body, subject) {
+    return { id: subject.id.split('::')[1] ?? subject.id, object: 'vector_store.file', vector_store_id: body.vector_store_id, created_at: body.created_at, status: body.status, usage_bytes: body.usage_bytes ?? 0, last_error: body.last_error ?? null, ...(body.attributes ? { attributes: body.attributes } : {}) };
+}
+/** OpenAI's list order: newest first by creation time. */
+const NEWEST = { field: 'created_at', direction: 'desc' };
+/** OpenAI's deletion answer names the deleted object's own type (`vector_store.deleted`). */
+const deletedAs = (object) => ({ id: '{id}', object, deleted: true });
+const underStore = { param: 'vector_store_id', field: 'vector_store_id', resource: 'VectorStoreObject' };
+const underThread = { param: 'thread_id', field: 'thread_id', resource: 'ThreadObject' };
+export const manifest = {
+    vendor: 'openai',
+    service: 'openai',
+    body: {},
+    ids: { template: '{prefix}-twin-{n}' },
+    // The screens people reach (docs/contributing/architecture.md, "Screens"): a project's secret keys are made on the
+    // dashboard's API keys page, never through the API, which only lists, reads and deletes them.
+    screens: [
+        {
+            id: 'api-keys', kind: 'workspace', host: 'platform.openai.com', path: '/settings/{project}/api-keys', status: 'done',
+            demand: 'every application that calls the API runs on a key a person made on this page',
+            controls: ['Name', 'Permissions', 'Create secret key', 'Revoke key'],
+            source: 'https://platform.openai.com/docs/api-reference/project-api-keys',
+        },
+    ],
+    time: 'unix',
+    error: { error: { message: '{message}', type: '{kind}', param: '{param}', code: '{code}' } },
+    defaultKind: 'invalid_request_error',
+    readOnly: { status: 405, code: 'method_not_allowed', message: 'twin is read-only; omit readOnly to accept writes' },
+    notFound: { status: 404, message: "No such {object}: '{id}'" },
+    list: {
+        style: 'envelope',
+        envelope: { object: 'list', data: '{data}', has_more: '{has_more}', first_id: '{first_id}', last_id: '{last_id}' },
+        limit: { param: 'limit', default: 20, max: 100 },
+        after: 'after',
+        before: 'before',
+        unknownCursor: 'end',
+    },
+    deleted: { id: '{id}', object: '{object}', deleted: true },
+    // OpenAI requires a bearer key on every request. The twin cannot check real keys, so it answers
+    // the checkable failures: none, or a key it reserves as invalid.
+    auth: {
+        header: 'authorization',
+        scheme: 'Bearer',
+        gateWhenAbsent: true,
+        missing: { status: 401, code: 'invalid_api_key', message: "You didn't provide an API key. You need to provide your API key in an Authorization header using Bearer auth (i.e. Authorization: Bearer YOUR_KEY)." },
+        invalidKeys: ['sk-invalid', 'invalid'],
+        invalid: { status: 401, code: 'invalid_api_key', message: 'Incorrect API key provided. You can find your API key at https://platform.openai.com/account/api-keys.' },
+    },
+    answerHeaders: { 'x-request-id': 'req_twin' },
+    sse: { named: false, done: '[DONE]' },
+    // a response streams named events (`event: response.created`) and ends with `response.completed`, no sentinel
+    // (https://platform.openai.com/docs/api-reference/responses-streaming; the reference's Streaming example)
+    // a streamed transcription is `data:` events ending with `transcript.text.done`, no sentinel (the reference's
+    // Streaming transcription example); a streamed image is named events ending with its `completed` event
+    // (https://platform.openai.com/docs/api-reference/images-streaming)
+    streamFor: { createResponse: { named: true }, beta_createResponse: { named: true }, createTranscription: { named: false }, createImage: { named: true }, createImageEdit: { named: true } },
+    // operations of declared resources the twin does not model: OpenAI's unknown-URL answer, not the core's
+    unmodeled: [
+        'updateChatCompletion',
+        'modifyVectorStore', 'updateVectorStoreFileAttributes',
+        'modifyMessage', 'deleteMessage', 'modifyRun',
+        'updateEval', 'deleteEval', 'deleteEvalRun', 'getEvalRunOutputItem',
+    ],
+    // a search is a POST that only reads: a read-only twin answers it
+    reads: ['searchVectorStore'],
+    resources: {
+        // the catalog is static data and fine-tuned models are read off their jobs; a row here is only
+        // a deletion (semantics/models.ts serves every operation)
+        Model: { storedAs: 'model', idPrefix: 'model', notFound: { code: 'model_not_found', message: "The model '{id}' does not exist" } },
+        // `status` is deprecated on a File (always `processed` here) and `purpose` is what it is for:
+        // neither moves (https://platform.openai.com/docs/api-reference/files/object)
+        OpenAIFile: { storedAs: 'file', idPrefix: 'file', notFound: 'No such File object: {id}', notState: ['purpose', 'status'], order: NEWEST },
+        FineTuningJob: { storedAs: 'fine_tuning_job', idPrefix: 'ftjob', notFound: 'No such fine-tuning job: {id}', state: { status: fineTuningJobStatus }, order: NEWEST },
+        // read off their job, never stored (semantics/fine-tuning.ts)
+        FineTuningJobEvent: { idPrefix: 'ftevent', notState: ['level', 'type'] },
+        FineTuningJobCheckpoint: { idPrefix: 'ftckpt' },
+        // a store and what it holds are born completed (the twin embeds nothing)
+        VectorStoreObject: { storedAs: 'vector_store', idPrefix: 'vs', notFound: 'No such vector store: {id}', deleted: deletedAs('vector_store.deleted'), state: { status: vectorStoreStatus }, order: NEWEST },
+        // one file may sit in several stores, so an attached file is keyed by both and shown by the file's id
+        VectorStoreFileObject: {
+            storedAs: 'vector_store_file',
+            idPrefix: 'vsf',
+            parent: underStore,
+            key: '{vector_store_id}::{file_id}',
+            view: vectorStoreFileView,
+            state: { status: vectorStoreFileStatus('spec:/components/schemas/VectorStoreFileObject/properties/status "The status of the vector store file, which can be either `in_progress`, `completed`, `cancelled`, or `failed`."') },
+        },
+        VectorStoreFileBatchObject: {
+            storedAs: 'vector_store_file_batch',
+            idPrefix: 'vsfb',
+            notFound: 'No such file batch: {id}',
+            parent: underStore,
+            state: { status: vectorStoreFileStatus('spec:/components/schemas/VectorStoreFileBatchObject/properties/status "The status of the vector store files batch, which can be either `in_progress`, `completed`, `cancelled` or `failed`."', notInFlight('a vector store file batch')) },
+        },
+        // every call is recorded; only a `store: true` one reads back (semantics/chat-completions.ts)
+        CreateChatCompletionResponse: {
+            storedAs: 'chat_completion',
+            idPrefix: 'chatcmpl',
+            readableWhen: { _stored: true },
+            notFound: "No chat completion found with id '{id}'.",
+            deleted: deletedAs('chat.completion.deleted'),
+            order: { field: 'created', direction: 'desc' },
+        },
+        // a stored response and its input items (semantics/responses.ts); one tree type for both surfaces. Its deletion
+        // answers `"object": "response"` (the reference's delete example: https://platform.openai.com/docs/api-reference/responses/delete)
+        Response: { storedAs: 'response', idPrefix: 'resp', notFound: "Response with id '{id}' not found.", deleted: deletedAs('response'), state: { status: responseStatus('') } },
+        BetaResponse: { storedAs: 'response', idPrefix: 'resp', notFound: "Response with id '{id}' not found.", deleted: deletedAs('response'), state: { status: responseStatus('beta_') } },
+        // the items live inside their response, never stored on their own: who wrote one, where a tool
+        // call ran, and how far generation got are what it is, and the twin's are whole
+        ItemResource: { idPrefix: 'item', notState: ['execution', 'role', 'status'] },
+        BetaItemResource: { idPrefix: 'item', notState: ['execution', 'role', 'status'] },
+        // the Assistants API (semantics/assistants.ts); messages and runs live under their thread
+        AssistantObject: { storedAs: 'assistant', idPrefix: 'asst', notFound: "No assistant found with id '{id}'.", deleted: deletedAs('assistant.deleted'), order: NEWEST },
+        ThreadObject: { storedAs: 'thread', idPrefix: 'thread', notFound: "No thread found with id '{id}'.", deleted: deletedAs('thread.deleted') },
+        // a message's role is who wrote it and its status is not modeled (every message is whole)
+        MessageObject: { storedAs: 'message', idPrefix: 'msg', notFound: "No message found with id '{id}'.", parent: underThread, notState: ['role', 'status'], order: NEWEST },
+        RunObject: { storedAs: 'run', idPrefix: 'run', notFound: "No run found with id '{id}'.", parent: underThread, state: { status: runStatus }, order: NEWEST },
+        // a run's steps are read off the run, never stored, so neither field moves on its own
+        RunStepObject: { idPrefix: 'step', notState: ['status', 'type'] },
+        // the Admin API (semantics/organization.ts); residency and a key's project access are settings
+        Project: { storedAs: 'project', idPrefix: 'proj', notFound: 'Project {id} not found', state: { status: projectStatus }, notState: ['residency'], order: NEWEST },
+        ProjectApiKey: {
+            storedAs: 'api_key',
+            idPrefix: 'key',
+            notFound: 'API key {id} not found',
+            parent: { param: 'project_id', field: '_project_id', resource: 'Project' },
+            deleted: deletedAs('organization.project.api_key.deleted'),
+            notState: ['owner_project_access'],
+            order: NEWEST,
+        },
+        // computed from the recorded usage, never stored
+        UsageTimeBucket: { idPrefix: 'bucket' },
+        // the Evals API (semantics/evals.ts); a run lives under its eval, its output items are read off it
+        Eval: { storedAs: 'eval', idPrefix: 'eval', notFound: 'Eval {id} not found', order: NEWEST },
+        EvalRun: { storedAs: 'eval_run', idPrefix: 'evalrun', notFound: 'Eval run {id} not found', parent: { param: 'eval_id', field: 'eval_id', resource: 'Eval' }, state: { status: evalRunStatus }, order: NEWEST },
+        // an output item's status is its grade (pass or fail), not a lifecycle
+        EvalRunOutputItem: { idPrefix: 'evalitem', notState: ['status'] },
+        // code-interpreter sandboxes (semantics/containers.ts); a file lives under its container, and a
+        // container's memory_limit is a setting
+        ContainerResource: { storedAs: 'container', idPrefix: 'cntr', notFound: 'Container {id} not found', deleted: deletedAs('container.deleted'), state: { status: containerStatus }, notState: ['memory_limit'], order: NEWEST },
+        ContainerFileResource: {
+            storedAs: 'container_file',
+            idPrefix: 'cfile',
+            notFound: 'Container file {id} not found',
+            parent: { param: 'container_id', field: 'container_id', resource: 'ContainerResource' },
+            deleted: deletedAs('container.file.deleted'),
+            order: NEWEST,
+        },
+        Batch: { storedAs: 'batch', idPrefix: 'batch', notFound: 'No such Batch object: {id}', state: { status: batchStatus }, order: NEWEST },
+        // a large file sent in parts (semantics/uploads.ts); the spec names no resource for it
+        Upload: { storedAs: 'upload', idPrefix: 'upload', notFound: 'No such Upload object: {id}', state: { status: uploadStatus } },
+    },
+};

package/dist/src/openai-budget.d.ts

@@ -0,0 +1,53 @@
+import { RateBudget, type RateBudgetDeclaration, type RateBudgetOptions, type RateBudgetReservation, type RateBudgetSnapshot } from '@volter/world-core';
+/** Rolling window, in ms. Spend older than this is pruned. */
+export declare const OPENAI_BUDGET_WINDOW_MS = 60000;
+/**
+ * Weighted units allowed inside one window. 60/60s at `defaultWeight` 2 = 30 calls a minute —
+ * EXACTLY the kernel's undeclared fallback, because OpenAI publishes no scalar that would justify
+ * more. See the header.
+ */
+export declare const OPENAI_BUDGET_CEILING = 60;
+/** Seconds. A `retry-after` above this means the key is throttled hard — fail loudly, don't sleep. */
+export declare const OPENAI_BUDGET_MAX_RETRY_AFTER_S = 300;
+/** Per-call cost, keyed by `"<METHOD> <path>"`. See the header for what is documented vs. judged. */
+export declare const OPENAI_CALL_WEIGHTS: {
+    /** `/v1/chat/completions`, `/v1/responses`, `/v1/embeddings`, `/v1/images/*`, `/v1/audio/*` —
+     *  token/compute-metered, where TPM rather than RPM is the binding limit. */
+    readonly inference: 5;
+    /** `POST /v1/vector_stores/:id/files` — documented 300 RPM per store, and a per-file fan-out. */
+    readonly ingest: 4;
+    /** Everything else: file/batch/fine-tune/vector-store list, retrieve, create, cancel, delete. */
+    readonly other: 2;
+};
+/** THE PACK'S DECLARATION — pure data, the only OpenAI-specific thing in the whole budget. */
+export declare const OPENAI_RATE_BUDGET: RateBudgetDeclaration;
+/**
+ * Price one call. The key is `"<METHOD> <path>"` with the query string split off, so a rule can
+ * price by method (a write is not a read) without the kernel knowing anything about OpenAI. An
+ * unclassified endpoint still costs `defaultWeight` — nothing is ever free.
+ */
+export declare function openaiCallWeight(method: string, path: string): number;
+/** Where OpenAI's ledger lives. Token-keyed and cwd-independent by default (the limit is per
+ *  organization/project, i.e. per key, so a cwd-scoped ledger would hand the same key a fresh
+ *  allowance in every checkout, worktree and CI matrix leg); pass `root` for world-scoped accounting. */
+export declare function openaiBudgetPath(opts?: {
+    root?: string;
+    token?: string;
+} | string): string;
+/** Construction options for OpenAI's budget. The vendor is fixed; everything else may only TIGHTEN. */
+export type OpenAIBudgetOptions = Omit<RateBudgetOptions, 'vendor'>;
+/**
+ * OpenAI's budget — the shared kernel guard bound to this vendor's declaration. A real subclass,
+ * not an alias, so `budget instanceof OpenAIBudget` in `liveOpenAIExecute` means "a budget that
+ * accounts against OPENAI's ledger under OPENAI's ceiling": another vendor's `RateBudget` (with its
+ * own, possibly larger, ceiling) is NOT assignable there.
+ */
+export declare class OpenAIBudget extends RateBudget {
+    constructor(opts?: OpenAIBudgetOptions);
+}
+/** The typed refusal. One error class shared with every other vendor's budget; `err.vendor` says
+ *  which one refused, and `err.kind` says why. */
+export { RateBudgetError as OpenAIBudgetError } from '@volter/world-core';
+export type { RateBudgetErrorKind as OpenAIBudgetErrorKind } from '@volter/world-core';
+export type OpenAIBudgetReservation = RateBudgetReservation;
+export type OpenAIBudgetSnapshot = RateBudgetSnapshot;