@lota-sdk/shared 0.1.21 → 0.1.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/shared",
-  "version": "0.1.21",
+  "version": "0.1.22",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/schemas/chat-message.ts

@@ -7,6 +7,9 @@ export const messageMetadataSchema = z
   .object({
     agentId: z.string().optional(),
     agentName: z.string().optional(),
+    trigger: z.enum(['user-turn', 'approval-continuation', 'plan-turn']).optional(),
+    planRunId: z.string().optional(),
+    planNodeId: z.string().optional(),
     semanticTerminationReason: z.enum(['none', 'conflict', 'cycle-detected']).optional(),
     inputTokens: z.number().optional(),
     outputTokens: z.number().optional(),

package/src/schemas/execution-plan.ts

@@ -153,7 +153,9 @@ export const PlanEventTypeSchema = z
     'plan-created',
     'plan-replaced',
     'run-status-changed',
+    'ownership-transition',
     'node-ready',
+    'node-unblocked',
     'node-running',
     'node-awaiting-human',
     'node-completed',
@@ -172,6 +174,7 @@ export const PlanEventTypeSchema = z
     'schedule-missed',
     'deadline-warning',
     'deadline-missed',
+    'escalation-triggered',
     'node-scheduled',
     'node-monitoring',
     'cycle-started',
@@ -181,6 +184,9 @@ export const PlanEventTypeSchema = z
   .meta({ id: 'PlanEventTypeSchema' })
 export type PlanEventType = z.infer<typeof PlanEventTypeSchema>
 
+export const PlanExecutionVisibilitySchema = z.enum(['visible', 'silent', 'auto'])
+export type PlanExecutionVisibility = z.infer<typeof PlanExecutionVisibilitySchema>
+
 const planOwnerRefSchema = z.string().trim().min(1).max(200)
 const planOwnerOperationSchema = z.string().trim().min(1).max(200)
 
@@ -301,6 +307,16 @@ export const DeadlineSpecSchema = z
   .strict()
 export type DeadlineSpec = z.infer<typeof DeadlineSpecSchema>
 
+export const PlanNodeEscalationSchema = z
+  .object({
+    deadlineThresholdMinutes: z.number().int().positive().optional(),
+    autoEscalateAfterMinutes: z.number().int().positive().optional(),
+    escalateToAgent: z.string().trim().min(1).max(200).optional(),
+    escalateToUser: z.boolean().default(false),
+  })
+  .strict()
+export type PlanNodeEscalation = z.infer<typeof PlanNodeEscalationSchema>
+
 export const NotificationSeveritySchema = z.enum(['info', 'warning', 'urgent', 'critical'])
 export type NotificationSeverity = z.infer<typeof NotificationSeveritySchema>
 
@@ -391,6 +407,18 @@ export type NodeWorkspaceEntry = z.infer<typeof NodeWorkspaceEntrySchema>
 export const NodeResultQualitySchema = z.enum(['full', 'partial']).default('full')
 export type NodeResultQuality = z.infer<typeof NodeResultQualitySchema>
 
+export const PlanNodeHandoffContextSchema = z
+  .object({
+    summary: z.string().trim().min(1).max(4000),
+    keyDecisions: z.array(z.string().trim().min(1).max(1000)).default([]),
+    openQuestions: z.array(z.string().trim().min(1).max(1000)).default([]),
+    risks: z.array(z.string().trim().min(1).max(1000)).default([]),
+    recommendations: z.array(z.string().trim().min(1).max(1000)).default([]),
+    references: z.array(z.string().trim().min(1).max(2000)).default([]),
+  })
+  .strict()
+export type PlanNodeHandoffContext = z.infer<typeof PlanNodeHandoffContextSchema>
+
 const planJsonValueSchema: z.ZodType<unknown> = z.lazy(() =>
   z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(planJsonValueSchema), planStructuredObjectSchema]),
 )
@@ -420,12 +448,24 @@ export const PlanNodeResultSubmissionSchema = z
     structuredOutput: planStructuredObjectSchema.optional(),
     artifacts: z.array(PlanArtifactSubmissionSchema).default([]),
     notes: z.string().trim().min(1).max(2000).optional(),
+    handoffContext: PlanNodeHandoffContextSchema.optional(),
     quality: NodeResultQualitySchema.optional(),
   })
   .strict()
 export type PlanNodeResultSubmission = z.infer<typeof PlanNodeResultSubmissionSchema>
 export type PlanNodeResult = PlanNodeResultSubmission
 
+export const UpstreamHandoffSchema = z
+  .object({
+    nodeId: z.string().trim().min(1).max(200),
+    label: z.string().trim().min(1).max(300),
+    ownerRef: z.string().trim().min(1).max(200),
+    ownerType: PlanNodeExecutorTypeSchema,
+    handoffContext: PlanNodeHandoffContextSchema,
+  })
+  .strict()
+export type UpstreamHandoff = z.infer<typeof UpstreamHandoffSchema>
+
 export interface OwnershipDispatchContext {
   organizationId: string
   workstreamId: string
@@ -434,6 +474,7 @@ export interface OwnershipDispatchContext {
   leadAgentId: string
   userId?: string
   userName?: string
+  upstreamHandoffs?: UpstreamHandoff[]
 }
 
 export const MonitoringWindowConfigSchema = z.object({
@@ -518,8 +559,10 @@ export const PlanNodeSpecSchema = z
       attachmentPolicy: 'referenced-only',
       webPolicy: 'allowed',
     }),
+    executionVisibility: PlanExecutionVisibilitySchema.default('auto'),
     schedule: PlanScheduleSpecSchema.optional(),
     deadline: DeadlineSpecSchema.optional(),
+    escalation: PlanNodeEscalationSchema.optional(),
     monitoringConfig: MonitoringWindowConfigSchema.optional(),
     delayAfterPredecessorMs: z.number().int().positive().optional(),
     deliberationConfig: DeliberationForkConfigSchema.optional(),
@@ -543,6 +586,7 @@ export const PlanDraftSchema = z
     title: z.string().trim().min(1).max(200),
     objective: z.string().trim().min(1).max(2000),
     schemas: PlanSchemaRegistrySchema.default({}),
+    defaultExecutionVisibility: PlanExecutionVisibilitySchema.default('auto'),
     nodes: z.array(PlanNodeSpecSchema).min(1).max(32),
     edges: z.array(PlanEdgeSpecSchema).default([]),
     entryNodeIds: z.array(z.string().trim().min(1).max(200)).min(1).optional(),
@@ -568,6 +612,7 @@ export const PlanSpecSchema = z.object({
   schemaRegistry: PlanSchemaRegistrySchema,
   edges: z.array(PlanEdgeSpecSchema),
   entryNodeIds: z.array(z.string()),
+  defaultExecutionVisibility: PlanExecutionVisibilitySchema.default('auto'),
   executionMode: ExecutionModeSchema,
   schedule: PlanScheduleSpecSchema.optional(),
   dependencies: z.array(PlanDependencySchema).optional(),
@@ -599,8 +644,10 @@ export const PlanNodeSpecRecordSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   toolPolicy: PlanToolPolicySchema,
   contextPolicy: PlanContextPolicySchema,
+  executionVisibility: PlanExecutionVisibilitySchema.default('auto'),
   schedule: PlanScheduleSpecSchema.optional(),
   deadline: DeadlineSpecSchema.optional(),
+  escalation: PlanNodeEscalationSchema.optional(),
   monitoringConfig: MonitoringWindowConfigSchema.optional(),
   delayAfterPredecessorMs: z.number().int().positive().optional(),
   deliberationConfig: DeliberationForkConfigSchema.optional(),
@@ -644,6 +691,7 @@ export const PlanNodeRunSchema = z.object({
   resolvedInput: z.record(z.string(), z.unknown()).optional(),
   latestStructuredOutput: z.record(z.string(), z.unknown()).optional(),
   latestNotes: z.string().optional(),
+  handoffContext: PlanNodeHandoffContextSchema.optional(),
   latestAttemptId: recordIdSchema.optional(),
   blockedReason: z.string().optional(),
   failureClass: PlanFailureClassSchema.optional(),
@@ -747,6 +795,7 @@ export const PlanEventSchema = z.object({
   detail: z.record(z.string(), z.unknown()).optional(),
   emittedBy: z.string(),
   createdAt: dbDateTimeSchema,
+  deliveredAt: dbDateTimeSchema.optional(),
 })
 export type PlanEventRecord = z.infer<typeof PlanEventSchema>
 
@@ -767,8 +816,10 @@ export const SerializablePlanNodeSchema = z.object({
   timeoutMs: z.number().int().positive().nullish(),
   toolPolicy: PlanToolPolicySchema,
   contextPolicy: PlanContextPolicySchema,
+  executionVisibility: PlanExecutionVisibilitySchema,
   schedule: PlanScheduleSpecSchema.nullish(),
   deadline: DeadlineSpecSchema.nullish(),
+  escalation: PlanNodeEscalationSchema.nullish(),
   monitoringConfig: MonitoringWindowConfigSchema.nullish(),
   delayAfterPredecessorMs: z.number().int().positive().nullish(),
   deliberationConfig: DeliberationForkConfigSchema.nullish(),
@@ -778,6 +829,7 @@ export const SerializablePlanNodeSchema = z.object({
   resolvedInput: z.record(z.string(), z.unknown()).nullish(),
   latestStructuredOutput: z.record(z.string(), z.unknown()).nullish(),
   latestNotes: z.string().nullish(),
+  handoffContext: PlanNodeHandoffContextSchema.nullish(),
   blockedReason: z.string().nullish(),
   failureClass: PlanFailureClassSchema.nullish(),
   upstreamNodeIds: z.array(z.string()),
@@ -885,6 +937,7 @@ export const SerializableExecutionPlanSchema = z.object({
   version: z.number().int().positive(),
   status: PlanRunStatusSchema,
   leadAgentId: z.string(),
+  defaultExecutionVisibility: PlanExecutionVisibilitySchema,
   executionMode: ExecutionModeSchema,
   schemaRegistry: PlanSchemaRegistrySchema,
   entryNodeIds: z.array(z.string()),

package/src/schemas/recent-activity.ts

@@ -35,6 +35,8 @@ export const RecentActivityMetadataSchema = z
     userMessageText: z.string().optional(),
     assistantSummary: z.string().optional(),
     messageId: z.string().optional(),
+    planStatus: z.enum(['awaiting-human', 'blocked', 'completed', 'failed']).optional(),
+    planTitle: z.string().optional(),
   })
   .partial()
 

package/src/schemas/tools.ts

@@ -15,6 +15,7 @@ export const CONSULT_TEAM_TOOL_NAME = 'consultTeam' as const
 export const CREATE_EXECUTION_PLAN_TOOL_NAME = 'createExecutionPlan' as const
 export const REPLACE_EXECUTION_PLAN_TOOL_NAME = 'replaceExecutionPlan' as const
 export const SUBMIT_EXECUTION_NODE_RESULT_TOOL_NAME = 'submitExecutionNodeResult' as const
+export const SUBMIT_PLAN_TURN_RESULT_TOOL_NAME = 'submitPlanTurnResult' as const
 export const LIST_EXECUTION_PLANS_TOOL_NAME = 'listExecutionPlans' as const
 export const GET_EXECUTION_PLAN_DETAILS_TOOL_NAME = 'getExecutionPlanDetails' as const
 export const GET_ACTIVE_EXECUTION_PLAN_TOOL_NAME = 'getActiveExecutionPlan' as const
@@ -70,6 +71,8 @@ export const SubmitExecutionNodeResultArgsSchema = z
   .object({ runId: z.string().trim().min(1), nodeId: z.string().trim().min(1), result: PlanNodeResultSubmissionSchema })
   .strict()
 
+export const SubmitPlanTurnResultArgsSchema = PlanNodeResultSubmissionSchema
+
 export const ListExecutionPlansArgsSchema = z.object({}).strict()
 
 export const GetActiveExecutionPlanArgsSchema = z
@@ -132,6 +135,7 @@ export type ConsultTeamResultData = { responses: ConsultTeamResponseData[] }
 export type CreateExecutionPlanArgs = z.infer<typeof CreateExecutionPlanArgsSchema>
 export type ReplaceExecutionPlanArgs = z.infer<typeof ReplaceExecutionPlanArgsSchema>
 export type SubmitExecutionNodeResultArgs = z.infer<typeof SubmitExecutionNodeResultArgsSchema>
+export type SubmitPlanTurnResultArgs = z.infer<typeof SubmitPlanTurnResultArgsSchema>
 export type ListExecutionPlansArgs = z.infer<typeof ListExecutionPlansArgsSchema>
 export type ListExecutionPlansSummary = z.infer<typeof ListExecutionPlansSummarySchema>
 export type ListExecutionPlansToolResultData = z.infer<typeof ListExecutionPlansToolResultDataSchema>
@@ -145,6 +149,7 @@ export type CoreChatTools = {
   createExecutionPlan: { input: CreateExecutionPlanArgs; output: ExecutionPlanToolResultData }
   replaceExecutionPlan: { input: ReplaceExecutionPlanArgs; output: ExecutionPlanToolResultData }
   submitExecutionNodeResult: { input: SubmitExecutionNodeResultArgs; output: ExecutionPlanToolResultData }
+  submitPlanTurnResult: { input: SubmitPlanTurnResultArgs; output: ExecutionPlanToolResultData }
   listExecutionPlans: { input: ListExecutionPlansArgs; output: ListExecutionPlansToolResultData }
   getExecutionPlanDetails: { input: GetActiveExecutionPlanArgs; output: ExecutionPlanToolResultData }
   resumeExecutionPlanRun: { input: ResumeExecutionPlanRunArgs; output: ExecutionPlanToolResultData }