@vertesia/common 1.6.0-dev.20260918.115658Z → 1.6.0-dev.20261004.085740Z

package/src/api-schemas/cost-analytics.ts

@@ -47,8 +47,14 @@ export const CostAnalyticsQuerySchema = z
                 'service_tier',
                 'interaction',
                 'workflow',
+                'agent_run',
+                'workflow_run',
             ])
-            .meta({ description: 'Group results by this dimension' })
+            .meta({
+                description:
+                    'Group results by this dimension. `agent_run` groups by root agent run, including the calls of ' +
+                    'its sub-agents; `workflow_run` groups by Temporal workflow run, which separates each sub-agent.',
+            })
             .optional(),
         resolution: z.enum(['hour', 'day', 'week', 'month']).meta({ description: 'Time series resolution' }).optional(),
         model: z.string().meta({ description: 'Filter by model pattern' }).optional(),
@@ -141,11 +147,25 @@ export const ModelPricingSchema = z
         provider: z.string().optional(),
         provider_account_id: z.string().optional(),
         service_tier: z.string().meta({ description: 'Processing tier this price applies to' }).optional(),
+        min_prompt_tokens: z
+            .number()
+            .int()
+            .nonnegative()
+            .meta({
+                description:
+                    'When set, these prices apply to calls whose prompt (input, cached and cache-write tokens) is ' +
+                    'longer than this many tokens, in place of the prices without it.',
+            })
+            .optional(),
         input_price_per_m_tokens: z.number(),
         cached_input_price_per_m_tokens: z.number().optional(),
         cache_write_input_price_per_m_tokens: z.number().optional(),
         output_price_per_m_tokens: z.number(),
-        source: z.enum(['billing_export', 'model_pricing_daily', 'unavailable']),
+        source: z.enum(['billing_export', 'model_pricing_daily', 'run_time_estimate', 'unavailable']).meta({
+            description:
+                'Where the rates come from. `run_time_estimate` rates are the ones recorded on the calls when their ' +
+                'cost was estimated; the others come from the pricing catalog.',
+        }),
     })
     .meta({ id: 'ModelPricing' });
 
@@ -222,6 +242,18 @@ const PricingCoverageSchema = z.strictObject({
             calls: z.number(),
         }),
     ),
+    cost_by_source: z
+        .strictObject({
+            provider_billed: z.number().meta({ description: 'USD the provider reported billing for the calls.' }),
+            run_time_estimate: z.number().meta({
+                description: 'USD estimated from list prices when the calls ran, for calls with no billed amount.',
+            }),
+            price_table: z.number().meta({
+                description: 'USD computed from the pricing table, for calls with no cost recorded when they ran.',
+            }),
+        })
+        .optional()
+        .meta({ description: "How the total cost splits by where each call's cost came from." }),
 });
 
 export const ModelPriceComparisonResponseSchema = z

package/src/api-schemas/environment.ts

@@ -48,7 +48,6 @@ export const MediatorEnvConfigSchema = z
  */
 export const ExecutionEnvironmentSettingsSchema = z
     .object({
-        bucket_access_principal: z.string().optional(),
         default_headers: StringValueMapSchema.meta({
             description: 'Custom HTTP headers sent by OpenAI-compatible environments.',
         }).optional(),

package/src/api-schemas/group.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import type * as Wire from '../wire-types.generated.js';
 
 /**
  * Runtime API schemas for the IAM user-group endpoints.
@@ -162,4 +163,4 @@ export const UserGroupRefSchema = UserGroupSchema.pick({
  * The array components have no public alias of their own — `UserGroup[]` is what the client sees —
  * so this exists only for the gate in `./group.contract.test.ts` to assert that equivalence.
  */
-export type UserGroupArrayFromSchema = z.infer<typeof UserGroupArraySchema>;
+export type UserGroupArrayFromSchema = Wire.UserGroupArrayFromSchema;

package/src/api-schemas/index.ts

@@ -34,6 +34,7 @@ export * from './process.js';
 export * from './process-agent-policy.js';
 export * from './quota.js';
 export * from './registry.js';
+export * from './run-budget.js';
 export * from './secrets.js';
 export { CreateContentObjectTypePayloadSchema, InteractionExecutionConfigurationSchema } from './store.js';
 export * from './view-execution.js';

package/src/api-schemas/inference-profile.ts

@@ -0,0 +1,151 @@
+import { ModelOptionsSchema } from '@llumiverse/common/schemas';
+import { z } from 'zod';
+import { AgentBudgetConfigurationSchema } from './agent-budget.js';
+
+export const InferenceProfileIdSchema = z
+    .string()
+    .regex(/^[a-fA-F0-9]{24}$/)
+    .meta({
+        id: 'InferenceProfileId',
+        description: 'MongoDB ObjectId of the inference profile.',
+    });
+
+export const InferenceProfileNameSchema = z
+    .string()
+    .min(1)
+    .max(80)
+    .regex(/\S/)
+    .meta({ id: 'InferenceProfileName', description: 'Editable display name, independent of the stable profile ID.' });
+
+export const InferenceProfileSchema = z
+    .strictObject({
+        name: InferenceProfileNameSchema.optional().meta({
+            description: 'Editable display name.',
+        }),
+        description: z.string().max(1000).optional(),
+        environment: z.string().regex(/^[a-fA-F0-9]{24}$/),
+        model: z.string().min(1).optional(),
+        model_options: ModelOptionsSchema.optional(),
+    })
+    .meta({
+        id: 'InferenceProfile',
+        description:
+            'A reusable environment, model and inference parameter preset. Credentials remain in the environment.',
+    });
+
+export const ProjectInferenceProfilesSchema = z
+    .strictObject({
+        default_profile: InferenceProfileIdSchema.optional(),
+        modality: z
+            .strictObject({
+                image: InferenceProfileIdSchema.optional(),
+                video: InferenceProfileIdSchema.optional(),
+            })
+            .optional(),
+        system: z
+            .strictObject({
+                content_type: InferenceProfileIdSchema.optional(),
+                intake: InferenceProfileIdSchema.optional(),
+                analysis: InferenceProfileIdSchema.optional(),
+                agent: InferenceProfileIdSchema.optional(),
+                non_applicable: InferenceProfileIdSchema.optional(),
+            })
+            .optional(),
+    })
+    .meta({
+        id: 'ProjectInferenceProfiles',
+        description:
+            'Project defaults reference profile MongoDB IDs. Profile definitions are managed through the inference profiles API.',
+    });
+
+export const InferenceProfileSnapshotSchema = z
+    .strictObject({
+        id: InferenceProfileIdSchema.optional(),
+        name: InferenceProfileNameSchema,
+        revision: z.string(),
+        source: z.enum(['request', 'binding', 'interaction', 'project']),
+        profile: InferenceProfileSchema,
+    })
+    .meta({
+        id: 'InferenceProfileSnapshot',
+        description:
+            'The selected profile and content revision at execution creation. Effective overrides are recorded in the execution config.',
+    });
+
+export const CreateInferenceProfilePayloadSchema = InferenceProfileSchema.extend({
+    name: InferenceProfileNameSchema,
+}).meta({
+    id: 'CreateInferenceProfilePayload',
+    description: 'Create a profile in the current project. The server assigns its MongoDB ID.',
+});
+
+export const UpdateInferenceProfilePayloadSchema = CreateInferenceProfilePayloadSchema.extend({}).meta({
+    id: 'UpdateInferenceProfilePayload',
+    description: 'Replace editable profile fields, preserving its ID and references.',
+});
+
+export const InferenceProfileRecordSchema = CreateInferenceProfilePayloadSchema.extend({
+    id: z.string().regex(/^[a-fA-F0-9]{24}$/),
+    project: z.string(),
+    created_at: z.string().datetime(),
+    updated_at: z.string().datetime(),
+}).meta({
+    id: 'InferenceProfileRecord',
+    description: 'A project-scoped inference profile stored as a MongoDB document.',
+});
+
+export const InferenceProfileRecordArraySchema = z
+    .array(InferenceProfileRecordSchema)
+    .meta({ id: 'InferenceProfileRecordArray' });
+
+export const UpdateInteractionConfigurationPayloadSchema = z
+    .strictObject({
+        inference_profile: InferenceProfileIdSchema.nullable(),
+        budget: AgentBudgetConfigurationSchema.nullable().optional().meta({
+            description:
+                'Project-scoped agent budget override. Null restores the code-defined or project default; omission preserves the saved budget.',
+        }),
+    })
+    .meta({ id: 'UpdateInteractionConfigurationPayload' });
+export const InteractionConfigurationRecordSchema = UpdateInteractionConfigurationPayloadSchema.extend({
+    id: z.string().regex(/^[a-fA-F0-9]{24}$/),
+    project: z.string(),
+    interaction: z.string(),
+    created_at: z.string().datetime(),
+    updated_at: z.string().datetime(),
+}).meta({ id: 'InteractionConfigurationRecord' });
+export const InteractionConfigurationResultSchema = z
+    .strictObject({
+        configuration: InteractionConfigurationRecordSchema.nullable(),
+    })
+    .meta({ id: 'InteractionConfigurationResult' });
+
+export const InferenceProfileUsageQuerySchema = z
+    .strictObject({
+        search: z.string().max(200).optional(),
+        kind: z.enum(['stored', 'system', 'app']).optional(),
+        offset: z.coerce.number().int().min(0).optional(),
+        limit: z.coerce.number().int().min(1).max(100).optional(),
+    })
+    .meta({ id: 'InferenceProfileUsageQuery' });
+
+export const InferenceProfileUsageEntrySchema = z
+    .strictObject({
+        id: z.string(),
+        name: z.string(),
+        kind: z.enum(['stored', 'system', 'app']),
+        version: z.number().optional(),
+        status: z.string().optional(),
+    })
+    .meta({ id: 'InferenceProfileUsageEntry' });
+
+export const InferenceProfileUsageSchema = z
+    .strictObject({
+        interactions: z.array(InferenceProfileUsageEntrySchema),
+        total: z.number().int().nonnegative(),
+        defaults: z.array(z.string()).meta({ description: 'Project default slots directly referencing this profile.' }),
+    })
+    .meta({
+        id: 'InferenceProfileUsage',
+        description: 'Persisted direct assignments; runtime overrides and inherited usage are not enumerated.',
+    });

package/src/api-schemas/interaction.ts

@@ -24,9 +24,10 @@ import { AgentToolApprovalModes } from '../store/agent-approval.js';
 import { LlmCallType } from '../workflow-analytics.js';
 import { ProjectRefSchema } from './apikey.js';
 import { ExecutionEnvironmentRefSchema } from './environment.js';
+import { InferenceProfileIdSchema, InferenceProfileSnapshotSchema } from './inference-profile.js';
 import { AccountRefSchema } from './invites.js';
 import { ProcessAgentExecutionPolicySchema } from './process-agent-policy.js';
-import { AgentCheckpointConfigurationSchema } from './project-configuration.js';
+import { AgentBudgetConfigurationSchema, AgentCheckpointConfigurationSchema } from './project-configuration.js';
 import { EditRevisionSchema, ExpectedEditRevisionSchema } from './schema-primitives.js';
 import { InteractionExecutionConfigurationSchema, RunDataStorageLevelSchema } from './store.js';
 
@@ -488,6 +489,7 @@ export const InteractionPublishPayloadSchema = z
 
 export const InteractionForkPayloadSchema = z
     .strictObject({
+        newName: z.string().optional(),
         keepTags: z.boolean().optional(),
         forkPrompts: z.boolean().optional(),
         targetProject: z.string().optional(),
@@ -743,6 +745,8 @@ export const ResolvedRuntimeConfigSchema = z
         environment: ResolvedEnvironmentInfoSchema,
         model: z.string().optional(),
         model_source: ModelSourceSchema,
+        inference_profile: InferenceProfileSnapshotSchema.optional(),
+        model_options: ModelOptionsSchema.optional(),
     })
     .meta({ id: 'ResolvedRuntimeConfig', description: 'Resolved runtime configuration for an interaction' });
 
@@ -802,6 +806,10 @@ export const AgentRunnerOptionsSchema = z
             description:
                 "Per-agent context checkpoint configuration. Field-wise it overrides the project's `configuration.agent.checkpoint`; a per-run `checkpoint_tokens` override still wins over both.",
         }).optional(),
+        budget: AgentBudgetConfigurationSchema.meta({
+            description:
+                "Per-agent token budget. Field-wise it overrides the project's `configuration.agent.budget`; the per-run `budget` wins over both.",
+        }).optional(),
     })
     .meta({
         id: 'AgentRunnerOptions',
@@ -882,6 +890,8 @@ export const RateLimitRequestPayloadSchema = z
     .strictObject({
         interaction: z.string(),
         environment_id: z.string().optional(),
+        inference_profile: InferenceProfileIdSchema.nullable().optional(),
+        inherit_model_config: z.boolean().optional(),
         model_id: z.string().optional(),
         workflow_run_id: z
             .string()
@@ -984,6 +994,7 @@ export const InteractionCreatePayloadSchema = z
         environment: z.union([z.string(), ExecutionEnvironmentRefSchema]).optional(),
         model: z.string().optional(),
         model_options: ModelOptionsSchema.optional(),
+        inference_profile: InferenceProfileIdSchema.nullable().optional(),
         store_media_results: z.boolean().optional(),
         restriction: RunDataStorageLevelSchema.optional(),
         output_modality: ModalitiesSchema.meta({
@@ -1010,6 +1021,7 @@ export const InteractionSchema = z
         environment: z.union([z.string(), ExecutionEnvironmentRefSchema]).optional(),
         model: z.string().optional(),
         model_options: ModelOptionsSchema.optional(),
+        inference_profile: InferenceProfileIdSchema.nullable().optional(),
         store_media_results: z.boolean().optional(),
         restriction: RunDataStorageLevelSchema.optional(),
         output_modality: ModalitiesSchema.meta({
@@ -1098,6 +1110,7 @@ export const InCodeInteractionSchema = z
         tags: z.array(z.string()).optional(),
         agent_runner_options: AgentRunnerOptionsSchema.optional(),
         model_options: ModelOptionsSchema.optional(),
+        inference_profile: InferenceProfileIdSchema.nullable().optional(),
         prompts: z.array(InCodePromptSchema),
         externalId: z.string().optional(),
         runtime: z
@@ -1231,6 +1244,7 @@ export const InteractionUpdatePayloadSchema = z
         environment: z.union([z.string(), ExecutionEnvironmentRefSchema]).optional(),
         model: z.string().optional(),
         model_options: ModelOptionsSchema.optional(),
+        inference_profile: InferenceProfileIdSchema.nullable().optional(),
         store_media_results: z.boolean().optional(),
         restriction: RunDataStorageLevelSchema.optional(),
         output_modality: ModalitiesSchema.meta({
@@ -1454,6 +1468,7 @@ export const ExecutionRunSchema: z.ZodType = z
         account: AccountRefSchema,
         project: ProjectRefSchema,
         config: InteractionExecutionConfigurationSchema,
+        inference_profile: InferenceProfileSnapshotSchema.optional(),
         error: InteractionExecutionErrorSchema.optional(),
         source: RunSourceSchema,
         output_modality: ModalitiesSchema.meta({
@@ -1511,6 +1526,7 @@ export const InteractionExecutionResultSchema = z
         created_at: z.string().meta({ format: 'date-time' }),
         updated_at: z.string().meta({ format: 'date-time' }),
         config: InteractionExecutionConfigurationSchema,
+        inference_profile: InferenceProfileSnapshotSchema.optional(),
         error: InteractionExecutionErrorSchema.optional(),
         source: RunSourceSchema,
         output_modality: ModalitiesSchema.meta({
@@ -1646,6 +1662,7 @@ export const ExecutionRunRefSchema = z
         account: AccountRefSchema,
         project: ProjectRefSchema,
         config: InteractionExecutionConfigurationSchema,
+        inference_profile: InferenceProfileSnapshotSchema.optional(),
         error: InteractionExecutionErrorSchema.optional(),
         source: RunSourceSchema,
         output_modality: ModalitiesSchema.meta({
@@ -1754,6 +1771,10 @@ export const ConversationStateSchema = z
                     'Project-configured checkpoint hard cap in tokens (cached from project.configuration.agent_checkpoint_tokens at conversation start). The workflow resolves the effective threshold from these, the per-run checkpoint_tokens override, and the model-based default.',
             })
             .optional(),
+        budget: AgentBudgetConfigurationSchema.meta({
+            description:
+                "Project-configured agent token budget (cached from project.configuration.agent.budget at conversation start). The workflow resolves the effective budget field-wise from this, the interaction's agent_runner_options.budget, and the per-run budget override.",
+        }).optional(),
         user_channels: z
             .array(UserChannelSchema)
             .meta({
@@ -2105,6 +2126,11 @@ export const AsyncInteractionExecutionPayloadSchema = z
     })
     .meta({ id: 'AsyncInteractionExecutionPayload' });
 
+export const AgentEvaluateRequestSchema = z.boolean().optional().meta({
+    description:
+        'Request LLM evaluation when the project evaluation policy is opt_in. Defaults to false. Cannot override disabled or opt out of always_on.',
+});
+
 export const ConversationEnrichmentFields = {
     title: z.string().min(1).meta({ description: 'Caller-provided conversation title.' }).optional(),
     topic: z
@@ -2135,6 +2161,7 @@ export const AsyncConversationExecutionPayloadSchema = z
                 'The interaction name and suffixed by an optional tag or version separated from the name using a @ character If no version/tag part is specified then the latest version is used. Example: ReviewContract, ReviewContract@draft, ReviewContract@1, ReviewContract@some-tag',
         }),
         ...ConversationEnrichmentFields,
+        evaluate: AgentEvaluateRequestSchema,
         app_version: z
             .string()
             .meta({
@@ -2267,6 +2294,10 @@ export const AsyncConversationExecutionPayloadSchema = z
             description:
                 "Structured per-run checkpoint override. Field-wise it takes precedence over the interaction's `agent_runner_options.checkpoint` and the project's `configuration.agent.checkpoint`. The legacy absolute `checkpoint_tokens` above still wins over everything when set.",
         }).optional(),
+        budget: AgentBudgetConfigurationSchema.meta({
+            description:
+                "Per-run token budget override. Field-wise it takes precedence over the interaction's `agent_runner_options.budget` and the project's `configuration.agent.budget`. Subagent workstreams receive the remaining budget of their parent here.",
+        }).optional(),
         strip_options: ConversationStripOptionsSchema.meta({
             description:
                 'Configuration for stripping large data (images, text) from conversation history to prevent JSON serialization issues and reduce storage bloat.',
@@ -2291,6 +2322,13 @@ export const AsyncConversationExecutionPayloadSchema = z
                     "Metadata inherited from parent workflow. Used to propagate context (e.g., apiKey, session info) to child workflows/workstreams. When a workstream is spawned, the parent's `data` is preserved here so that child tools can access it via metadata.parent_metadata.",
             })
             .optional(),
+        final_verification: z
+            .boolean()
+            .meta({
+                description:
+                    'When true, a non-interactive free-form run takes one extra turn after its answer to check that the task is complete. Off by default, and never applied to workstreams: their parent reviews the result and can message the workstream to continue.',
+            })
+            .optional(),
         non_blocking_subagents: z
             .boolean()
             .meta({
@@ -2422,6 +2460,8 @@ export const ResolveInteractionQuerySchema = z
     .strictObject({
         environment: z.string().optional(),
         model: z.string().optional(),
+        inference_profile: InferenceProfileIdSchema.optional(),
+        inherit_model_config: InteractionExecutionConfigurationSchema.shape.inherit_model_config,
         hasImage: z.boolean().optional(),
         hasVideo: z.boolean().optional(),
     })

package/src/api-schemas/invites.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 // From the values module, for the reason `./apikey.js` gives.
 import { TransientTokenType } from '../transient-tokens-values.js';
+import type * as Wire from '../wire-types.generated.js';
 import { AccountSchema } from './account.js';
 import { ProjectRefSchema, SystemRolesSchema } from './apikey.js';
 import { UserRefSchema } from './user.js';
@@ -116,12 +117,12 @@ export const AccountProjectsResponseSchema = z
     })
     .meta({ id: 'AccountProjectsResponse' });
 
-export type UserInviteTokenDataFromSchema = z.infer<typeof UserInviteTokenDataSchema>;
-export type UserInviteTokenFromSchema = z.infer<typeof UserInviteTokenSchema>;
-export type UserInviteTokenArrayFromSchema = z.infer<typeof UserInviteTokenArraySchema>;
-export type InviteUserRequestPayloadFromSchema = z.infer<typeof InviteUserRequestPayloadSchema>;
-export type InviteUserResponsePayloadFromSchema = z.infer<typeof InviteUserResponsePayloadSchema>;
-export type InviteAcceptanceResponseFromSchema = z.infer<typeof InviteAcceptanceResponseSchema>;
-export type InviteDeclineResponseFromSchema = z.infer<typeof InviteDeclineResponseSchema>;
-export type OnboardingProgressFromSchema = z.infer<typeof OnboardingProgressSchema>;
-export type AccountProjectsResponseFromSchema = z.infer<typeof AccountProjectsResponseSchema>;
+export type UserInviteTokenDataFromSchema = Wire.UserInviteTokenDataFromSchema;
+export type UserInviteTokenFromSchema = Wire.UserInviteTokenFromSchema;
+export type UserInviteTokenArrayFromSchema = Wire.UserInviteTokenArrayFromSchema;
+export type InviteUserRequestPayloadFromSchema = Wire.InviteUserRequestPayloadFromSchema;
+export type InviteUserResponsePayloadFromSchema = Wire.InviteUserResponsePayloadFromSchema;
+export type InviteAcceptanceResponseFromSchema = Wire.InviteAcceptanceResponseFromSchema;
+export type InviteDeclineResponseFromSchema = Wire.InviteDeclineResponseFromSchema;
+export type OnboardingProgressFromSchema = Wire.OnboardingProgressFromSchema;
+export type AccountProjectsResponseFromSchema = Wire.AccountProjectsResponseFromSchema;

package/src/api-schemas/oauth-server.ts

@@ -83,6 +83,7 @@ const oauthAuthorizeQueryFields = {
     state: z.string().optional(),
     code_challenge: z.string(),
     code_challenge_method: z.literal('S256'),
+    account_id: z.string().optional(),
     project_id: z.string().optional(),
 };
 
@@ -92,9 +93,21 @@ export const CreateOAuthAuthorizationRequestPayloadSchema = z
     .strictObject(oauthAuthorizeQueryFields)
     .meta({ id: 'CreateOAuthAuthorizationRequestPayload' });
 
+export const OAuthAuthorizationRequestGeneratedAppSchema = z
+    .strictObject({
+        tenant_id: z.string(),
+        app_name: z.string(),
+        version_id: z.string().optional(),
+    })
+    .meta({ id: 'OAuthAuthorizationRequestGeneratedApp' });
+
 export const OAuthAuthorizationRequestSchema = z
     .strictObject({
         request_id: z.string(),
+        user_code: z.string().optional().meta({
+            description:
+                'User-visible device code to compare with the terminal before approving. Never the secret device_code.',
+        }),
         client_id: z.string(),
         client_name: z.string(),
         client_metadata: OAuthClientDisplayMetadataSchema.optional(),
@@ -104,7 +117,9 @@ export const OAuthAuthorizationRequestSchema = z
         resource: z.string().optional(),
         requested_scopes: z.array(z.string()),
         optional_scopes: z.array(z.string()).optional(),
+        requested_account_id: z.string().optional(),
         requested_project_id: z.string().optional(),
+        generated_app: OAuthAuthorizationRequestGeneratedAppSchema.optional(),
         project_binding_mode: OAuthProjectBindingModeSchema,
         fixed_project_id: z.string().optional(),
         restrict_to_owner_account: z.boolean().optional().meta({
@@ -370,3 +385,24 @@ export const OAuthGrantRevokeResponseSchema = z
         revoked_consents: z.number(),
     })
     .meta({ id: 'OAuthGrantRevokeResponse' });
+
+export const OAuthLoginPayloadSchema = z
+    .strictObject({
+        id_token: z.string().min(1),
+        account_id: z.string().optional(),
+        project_id: z.string().optional(),
+    })
+    .meta({ id: 'OAuthLoginPayload' });
+export const OAuthLoginDecisionResponseSchema = z
+    .strictObject({
+        redirect_url: z.string().optional(),
+        consent_url: z.string().optional(),
+    })
+    .meta({ id: 'OAuthLoginDecisionResponse' });
+
+export const OAuthLoginUserNotFoundResponseSchema = z
+    .strictObject({
+        error: z.literal('user_not_found'),
+        ensure_user_url: z.string(),
+    })
+    .meta({ id: 'OAuthLoginUserNotFoundResponse' });

package/src/api-schemas/process.ts

@@ -1,19 +1,21 @@
+import { InferenceProfileIdSchema } from './inference-profile.js';
 // Runtime schemas for the process API domain.
 
 import { JSONObjectSchema, JSONSchemaSchema, ModelOptionsSchema } from '@llumiverse/common/schemas';
-import type { StringValue } from 'ms';
 import { z } from 'zod';
+import type { DurationString } from '../store/duration.js';
 import { PermissionSchema } from './access-control.js';
 import { AgentRunTypeSchema } from './app-lifecycle.js';
 import { StringValueMapSchema } from './files.js';
 import { ConversationVisibilitySchema, RunSourceSchema } from './interaction.js';
 import { ProcessAgentExecutionPolicySchema } from './process-agent-policy.js';
+import { AgentBudgetConfigurationSchema } from './project-configuration.js';
 import { EditRevisionSchema, ExpectedEditRevisionSchema } from './schema-primitives.js';
 import { TaskFieldSchema } from './task.js';
 
 export const DurationValueSchema = z
     .union([z.string(), z.number()])
-    .meta({ id: 'DurationValue', anyOf: undefined, type: ['string', 'number'] }) as z.ZodType<StringValue | number>;
+    .meta({ id: 'DurationValue', anyOf: undefined, type: ['string', 'number'] }) as z.ZodType<DurationString | number>;
 
 export const JsonLogicRuleSchema = z.looseObject({}).meta({ id: 'JsonLogicRule' });
 
@@ -178,6 +180,10 @@ export const ProcessDefinitionRevisionInfoSchema = z
 
 export const ProcessRunConfigSchema = z
     .strictObject({
+        inference_profile: InferenceProfileIdSchema.nullable().optional().meta({
+            description:
+                'Run-level inference profile ID for process LLM nodes and the supervisor. Explicit model settings retain precedence.',
+        }),
         environment: z
             .string()
             .meta({ description: 'Execution environment id used by Process LLM nodes and the supervisor.' })
@@ -193,6 +199,10 @@ export const ProcessRunConfigSchema = z
                     'Free-form message from the user when starting a run. Passed to the orchestrator LLM in supervised mode; stored on the run regardless so programmatic runs retain the intent that triggered them.',
             })
             .optional(),
+        budget: AgentBudgetConfigurationSchema.meta({
+            description:
+                'Token budget shared by the whole run: agent nodes, interaction nodes, nested processes and, when the run is managed by an agent run, that agent run. Agent nodes and nested processes start with what is left of it. When it runs out the process stops scheduling nodes and lets running agent nodes write a final summary. A run managed by an interactive agent run then pauses (`budget.awaiting_allocation`) until more budget is added through that agent run, and retries the interrupted node; any other run ends failed with `terminal_reason` `token_budget_exhausted`. This is a soft limit, not a spending cap.',
+        }).optional(),
         process_workstream_monitor: z
             .strictObject({
                 monitor_workflow_id: z.string(),
@@ -358,6 +368,68 @@ export const TransitionDefinitionSchema = z
 
 export const ProcessScriptSourceSchema = ProcessScriptInlineSourceSchema.meta({ id: 'ProcessScriptSource' });
 
+export const ProcessTerminalReasonSchema = z.enum(['token_budget_exhausted']).meta({
+    id: 'ProcessTerminalReason',
+    description:
+        'Why a process run ended other than by reaching a final node. `token_budget_exhausted`: the run spent its token budget; it ends with status `failed`.',
+});
+
+export const ProcessBudgetSummarySchema = z
+    .strictObject({
+        node_id: z.string(),
+        attempt: z.number(),
+        status: z.enum(['token_budget_exhausted', 'cancelled_at_deadline']).meta({
+            description:
+                '`token_budget_exhausted`: the node ended with a final summary turn. `cancelled_at_deadline`: the node was still running at the wrap-up deadline and was cancelled without a summary.',
+        }),
+        summary: z
+            .string()
+            .meta({ description: "The node's final summary, truncated to 2,000 characters." })
+            .optional(),
+        summary_truncated: z.boolean().optional(),
+        artifact: z
+            .string()
+            .meta({
+                description:
+                    "Path of the node's conversation among the process run's artifacts, which holds the full summary.",
+            })
+            .optional(),
+        child_run_id: z.string().optional(),
+        usage_incomplete: z
+            .boolean()
+            .meta({
+                description:
+                    "True when the node's final token usage never arrived; the run total counts its last reported usage.",
+            })
+            .optional(),
+    })
+    .meta({ id: 'ProcessBudgetSummary' });
+
+export const ProcessBudgetStateSchema = z
+    .strictObject({
+        mode: z.enum(['token', 'dollar']).optional().meta({ description: 'Absent on historical token-only status.' }),
+        limit_usd: z.number().nonnegative().optional(),
+        reported_usd: z.number().nonnegative().optional(),
+        estimated_usd: z.number().nonnegative().optional(),
+        accounting_status: z.enum(['current', 'incomplete']).optional(),
+        unmeasured_calls: z.number().int().nonnegative().optional(),
+        limit_tokens: z.number(),
+        used_units: z.number().meta({ description: 'Weighted tokens used by the run and everything it launched.' }),
+        exhausted: z.boolean(),
+        awaiting_allocation: z
+            .boolean()
+            .meta({
+                description:
+                    'True while the run is paused because its budget ran out, waiting for more budget. Only a run managed by an interactive agent run pauses; the run then shows status `running`.',
+            })
+            .optional(),
+        summaries: z
+            .array(ProcessBudgetSummarySchema)
+            .meta({ description: 'One entry per node the budget stopped: at most the latest attempt, 50 entries.' })
+            .optional(),
+    })
+    .meta({ id: 'ProcessBudgetState' });
+
 export const ProcessStateSchema = z
     .strictObject({
         context: z.looseObject({}),
@@ -365,6 +437,10 @@ export const ProcessStateSchema = z
         node_history: z.array(NodeHistoryEntrySchema),
         node_history_ref: ProcessHistoryRefSchema.optional(),
         sequence: z.number(),
+        terminal_reason: ProcessTerminalReasonSchema.optional(),
+        budget: ProcessBudgetStateSchema.meta({
+            description: 'Run budget status, including dollar consumption when configured.',
+        }).optional(),
     })
     .meta({ id: 'ProcessState' });