@lota-sdk/shared 0.4.0 → 0.4.1

package/package.json

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

package/src/schemas/tools.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod'
 
-import { AgentPlanDraftSchema } from './agent-plan-draft'
+import { AgentPlanDraftSchema, AgentPlanEdgeDraftSchema } from './agent-plan-draft'
 import { baseChatMessageSchema } from './chat-api'
 import type { AnyChatMessage } from './chat-message'
 import {
@@ -87,34 +87,123 @@ const targetThreadIdSchema = z
 const runIdSchema = z.string().trim().min(1)
 const replaceReasonSchema = z.string().trim().min(1).max(1000)
 
-const ExecutionPlanCreateArgsSchema = AgentPlanDraftSchema.extend({
+export const ExecutionPlanCreateArgsSchema = AgentPlanDraftSchema.extend({
   action: z.literal('create'),
   targetThreadId: targetThreadIdSchema.optional(),
 }).strict()
 
-const ExecutionPlanCreateProjectArgsSchema = AgentPlanDraftSchema.extend({
+export const ExecutionPlanCreateProjectArgsSchema = AgentPlanDraftSchema.extend({
   action: z.literal('create-project'),
   projectTitle: projectTitleSchema.optional(),
   targetThreadId: targetThreadIdSchema.optional(),
 }).strict()
 
-const ExecutionPlanReplaceArgsSchema = AgentPlanDraftSchema.extend({
+export const ExecutionPlanReplaceArgsSchema = AgentPlanDraftSchema.extend({
   action: z.literal('replace'),
   runId: runIdSchema.describe('Required for replace and resume.'),
   reason: replaceReasonSchema.describe('Required for replace.'),
 }).strict()
 
-const ExecutionPlanResumeArgsSchema = z
+export const ExecutionPlanResumeArgsSchema = z
   .object({ action: z.literal('resume'), runId: runIdSchema.describe('Required for replace and resume.') })
   .strict()
 
-export const ExecutionPlanArgsSchema = z.discriminatedUnion('action', [
-  ExecutionPlanCreateArgsSchema,
-  ExecutionPlanCreateProjectArgsSchema,
-  ExecutionPlanReplaceArgsSchema,
-  ExecutionPlanResumeArgsSchema,
-])
-export type ExecutionPlanArgs = z.infer<typeof ExecutionPlanArgsSchema>
+const ExecutionPlanBaseArgsSchema = z
+  .object({
+    action: ExecutionPlanActionSchema,
+    title: AgentPlanDraftSchema.shape.title.optional(),
+    objective: AgentPlanDraftSchema.shape.objective.optional(),
+    nodes: AgentPlanDraftSchema.shape.nodes.optional(),
+    edges: z.array(AgentPlanEdgeDraftSchema).optional(),
+    projectTitle: projectTitleSchema.optional(),
+    targetThreadId: targetThreadIdSchema.optional(),
+    runId: runIdSchema.describe('Required for replace and resume.').optional(),
+    reason: replaceReasonSchema.describe('Required for replace.').optional(),
+  })
+  .strict()
+
+function addMissingExecutionPlanFieldIssue(ctx: z.RefinementCtx, path: string, message: string) {
+  ctx.addIssue({ code: z.ZodIssueCode.custom, path: [path], message })
+}
+
+function addUnexpectedExecutionPlanFieldIssue(ctx: z.RefinementCtx, path: string, message: string) {
+  ctx.addIssue({ code: z.ZodIssueCode.custom, path: [path], message })
+}
+
+export const ExecutionPlanArgsSchema = ExecutionPlanBaseArgsSchema.superRefine((value, ctx) => {
+  const requiresDraft = value.action === 'create' || value.action === 'create-project' || value.action === 'replace'
+
+  if (requiresDraft) {
+    if (value.title === undefined) {
+      addMissingExecutionPlanFieldIssue(ctx, 'title', 'title is required for create, create-project, and replace.')
+    }
+    if (value.objective === undefined) {
+      addMissingExecutionPlanFieldIssue(
+        ctx,
+        'objective',
+        'objective is required for create, create-project, and replace.',
+      )
+    }
+    if (value.nodes === undefined) {
+      addMissingExecutionPlanFieldIssue(ctx, 'nodes', 'nodes is required for create, create-project, and replace.')
+    }
+  }
+
+  if (value.action === 'replace') {
+    if (value.runId === undefined) {
+      addMissingExecutionPlanFieldIssue(ctx, 'runId', 'runId is required for replace.')
+    }
+    if (value.reason === undefined) {
+      addMissingExecutionPlanFieldIssue(ctx, 'reason', 'reason is required for replace.')
+    }
+  }
+
+  if (value.action === 'resume') {
+    if (value.runId === undefined) {
+      addMissingExecutionPlanFieldIssue(ctx, 'runId', 'runId is required for resume.')
+    }
+
+    for (const path of ['title', 'objective', 'nodes', 'edges', 'projectTitle', 'targetThreadId', 'reason'] as const) {
+      if (value[path] !== undefined) {
+        addUnexpectedExecutionPlanFieldIssue(
+          ctx,
+          path,
+          `${path} is not allowed when action is "resume". Use only action and runId.`,
+        )
+      }
+    }
+  }
+
+  if (value.action === 'create') {
+    for (const path of ['projectTitle', 'runId', 'reason'] as const) {
+      if (value[path] !== undefined) {
+        addUnexpectedExecutionPlanFieldIssue(ctx, path, `${path} is not allowed when action is "create".`)
+      }
+    }
+  }
+
+  if (value.action === 'create-project') {
+    for (const path of ['runId', 'reason'] as const) {
+      if (value[path] !== undefined) {
+        addUnexpectedExecutionPlanFieldIssue(ctx, path, `${path} is not allowed when action is "create-project".`)
+      }
+    }
+  }
+
+  if (value.action === 'replace') {
+    for (const path of ['projectTitle', 'targetThreadId'] as const) {
+      if (value[path] !== undefined) {
+        addUnexpectedExecutionPlanFieldIssue(ctx, path, `${path} is not allowed when action is "replace".`)
+      }
+    }
+  }
+})
+
+export type ExecutionPlanArgs =
+  | z.infer<typeof ExecutionPlanCreateArgsSchema>
+  | z.infer<typeof ExecutionPlanCreateProjectArgsSchema>
+  | z.infer<typeof ExecutionPlanReplaceArgsSchema>
+  | z.infer<typeof ExecutionPlanResumeArgsSchema>
 
 export const ExecutionPlanQueryArgsSchema = z
   .object({