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

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';
 
@@ -744,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' });
 
@@ -803,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',
@@ -883,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()
@@ -985,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({
@@ -1011,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({
@@ -1099,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
@@ -1232,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({
@@ -1455,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({
@@ -1512,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({
@@ -1647,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({
@@ -1755,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({
@@ -2106,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
@@ -2136,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({
@@ -2268,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.',
@@ -2292,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({
@@ -2423,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/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' });
 

package/src/api-schemas/project-configuration.ts

@@ -1,6 +1,11 @@
 import { z } from 'zod';
+import { AgentBudgetConfigurationSchema } from './agent-budget.js';
+
+export { AgentBudgetConfigurationSchema } from './agent-budget.js';
+
 // From the values module, for the reason `./apikey.js` gives.
 import { ResourceVisibility } from '../project-values.js';
+import { ProjectInferenceProfilesSchema } from './inference-profile.js';
 import { ContentTypeIntakePolicySchema } from './store.js';
 
 /**
@@ -145,9 +150,18 @@ export const AgentCheckpointConfigurationSchema = z
 
 export const AgentProjectConfigurationSchema = z
     .strictObject({
+        evaluation_policy: z.enum(['disabled', 'opt_in', 'always_on']).optional().meta({
+            description:
+                'LLM evaluation policy. Defaults to always_on when omitted. disabled prevents evaluation even when requested; opt_in requires evaluate=true on the run; always_on evaluates every eligible run without sampling. Deterministic diagnostics are unaffected.',
+        }),
         checkpoint: AgentCheckpointConfigurationSchema.optional().meta({
             description: 'Conversation checkpoint (context compaction) tuning.',
         }),
+        budget: AgentBudgetConfigurationSchema.optional().meta({
+            description:
+                'Default token budget for agent runs in this project. Field-wise overridden by the ' +
+                "interaction's `agent_runner_options.budget` and the per-run `budget`.",
+        }),
     })
     .meta({
         id: 'AgentProjectConfiguration',
@@ -422,7 +436,11 @@ export const ProjectConfigurationSchema = z
         default_environment: z.string().optional(),
         default_model: z.string().optional(),
         human_context: z.string().optional(),
-        defaults: ProjectModelDefaultsSchema.optional(),
+        defaults: ProjectModelDefaultsSchema.optional().meta({
+            deprecated: true,
+            description: 'Legacy model defaults, replaced by inference profile assignments after migration.',
+        }),
+        inference: ProjectInferenceProfilesSchema.optional(),
         default_visibility: ResourceVisibilitySchema.optional(),
         sync_content_properties: z.boolean().optional(),
         embeddings: z.strictObject({

package/src/api-schemas/project.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 // From the values module, for the reason `./apikey.js` gives.
 import { SupportedIntegrations } from '../integrations.js';
+import type * as Wire from '../wire-types.generated.js';
 import { ProjectConfigurationSchema } from './project-configuration.js';
 
 /**
@@ -103,15 +104,15 @@ export const ProjectToolInfoSchema = z
 
 export const ProjectToolInfoArraySchema = z.array(ProjectToolInfoSchema).meta({ id: 'ProjectToolInfoArray' });
 
-export type ListProjectsQueryFromSchema = z.infer<typeof ListProjectsQuerySchema>;
-export type ProjectTagQueryFromSchema = z.infer<typeof ProjectTagQuerySchema>;
-export type CreateProjectPayloadFromSchema = z.infer<typeof CreateProjectPayloadSchema>;
-export type ProjectPluginsUpdatePayloadFromSchema = z.infer<typeof ProjectPluginsUpdatePayloadSchema>;
-export type CountResultFromSchema = z.infer<typeof CountResultSchema>;
-export type ProjectIntegrationListEntryFromSchema = z.infer<typeof ProjectIntegrationListEntrySchema>;
-export type ProjectIntegrationListResponseFromSchema = z.infer<typeof ProjectIntegrationListResponseSchema>;
-export type ProjectToolInfoFromSchema = z.infer<typeof ProjectToolInfoSchema>;
-export type ProjectToolInfoArrayFromSchema = z.infer<typeof ProjectToolInfoArraySchema>;
+export type ListProjectsQueryFromSchema = Wire.ListProjectsQueryFromSchema;
+export type ProjectTagQueryFromSchema = Wire.ProjectTagQueryFromSchema;
+export type CreateProjectPayloadFromSchema = Wire.CreateProjectPayloadFromSchema;
+export type ProjectPluginsUpdatePayloadFromSchema = Wire.ProjectPluginsUpdatePayloadFromSchema;
+export type CountResultFromSchema = Wire.CountResultFromSchema;
+export type ProjectIntegrationListEntryFromSchema = Wire.ProjectIntegrationListEntryFromSchema;
+export type ProjectIntegrationListResponseFromSchema = Wire.ProjectIntegrationListResponseFromSchema;
+export type ProjectToolInfoFromSchema = Wire.ProjectToolInfoFromSchema;
+export type ProjectToolInfoArrayFromSchema = Wire.ProjectToolInfoArrayFromSchema;
 
 /**
  * The rendering templates an app ships, and the reference form the manifest embeds.
@@ -194,6 +195,11 @@ export const ProjectSchema = z
         configuration: ProjectConfigurationSchema,
         integrations: z.record(z.string(), z.unknown()).optional(),
         plugins: z.array(z.string()),
+        annotations: z.array(z.string()).meta({ description: 'Classification annotations' }).optional(),
+        last_activity_at: z
+            .string()
+            .meta({ format: 'date-time', description: 'When the project last saw activity. Not yet populated.' })
+            .optional(),
         created_by: z.string(),
         updated_by: z.string(),
         created_at: z.string().meta({ format: 'date-time' }),
@@ -206,8 +212,11 @@ export const ProjectSchema = z
  *
  * `.partial()` keeps both update contracts tied to the corresponding response contract, so a field
  * added to either source schema is available to its update payload without a hand-written twin.
+ * `annotations` and `last_activity_at` are vertesia-managed, so they are read-only.
  */
-export const UpdateProjectPayloadSchema = ProjectSchema.partial().meta({ id: 'UpdateProjectPayload' });
+export const UpdateProjectPayloadSchema = ProjectSchema.omit({ annotations: true, last_activity_at: true })
+    .partial()
+    .meta({ id: 'UpdateProjectPayload' });
 
 export const UpdateProjectConfigurationPayloadSchema = ProjectConfigurationSchema.partial().meta({
     id: 'UpdateProjectConfigurationPayload',

package/src/api-schemas/quota.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import type * as Wire from '../wire-types.generated.js';
 
 /**
  * Runtime API schemas for quota standing and tier endpoints.
@@ -114,9 +115,9 @@ export const QuotaTierResponseSchema = z
  * definitions of one contract, only one of which OpenAPI publishes and AJV compiles.
  * `../rate-limiter.ts` re-exports these under their public names.
  */
-export type QuotaEffectiveTierFromSchema = z.infer<typeof QuotaEffectiveTierSchema>;
-export type QuotaStandingWindowFromSchema = z.infer<typeof QuotaStandingWindowSchema>;
-export type QuotaStandingResourceFromSchema = z.infer<typeof QuotaStandingResourceSchema>;
-export type QuotaStandingAdmissionClassFromSchema = z.infer<typeof QuotaStandingAdmissionClassSchema>;
-export type QuotaStandingResponseFromSchema = z.infer<typeof QuotaStandingResponseSchema>;
-export type QuotaTierResponseFromSchema = z.infer<typeof QuotaTierResponseSchema>;
+export type QuotaEffectiveTierFromSchema = Wire.QuotaEffectiveTierFromSchema;
+export type QuotaStandingWindowFromSchema = Wire.QuotaStandingWindowFromSchema;
+export type QuotaStandingResourceFromSchema = Wire.QuotaStandingResourceFromSchema;
+export type QuotaStandingAdmissionClassFromSchema = Wire.QuotaStandingAdmissionClassFromSchema;
+export type QuotaStandingResponseFromSchema = Wire.QuotaStandingResponseFromSchema;
+export type QuotaTierResponseFromSchema = Wire.QuotaTierResponseFromSchema;