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

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;