@lota-sdk/shared 0.2.2 → 0.3.0

package/package.json

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

package/src/constants/execution-plan.ts

@@ -5,8 +5,8 @@ export const HUMAN_NODE_TYPES = ['human-input', 'human-approval', 'human-review-
 export const STRUCTURAL_NODE_TYPES = ['switch', 'join', 'deliberation-fork'] as const
 
 export const PROJECT_PLAN_ROUTING_PROMPT = `<project-plan-routing>
-- Use createExecutionPlan for small inline work inside the current workstream.
-- Use createProjectWithPlan when the work needs a dedicated project workstream, should stay visible in the sidebar or board, or needs 3 or more meaningful execution nodes.
+- Use createExecutionPlan for small inline work inside the current thread.
+- Use createProjectWithPlan when the work needs a dedicated project thread, should stay visible in the sidebar or board, or needs 3 or more meaningful execution nodes.
 - If createExecutionPlan rejects a larger draft, immediately retry with createProjectWithPlan instead of forcing the plan inline.
 </project-plan-routing>`
 

package/src/constants/{workstream.ts → thread.ts}

@@ -1,5 +1,5 @@
-export const WORKSTREAM = {
-  DEFAULT_TITLE: 'New Workstream',
+export const THREAD = {
+  DEFAULT_TITLE: 'New Thread',
   DEFAULT_PAGE_LIMIT: 15,
   DEFAULT_MESSAGE_PAGE_LIMIT: 6,
   MAX_MESSAGES_PER_PAGE: 100,

package/src/index.ts

@@ -1,6 +1,6 @@
 export * from './constants/attachments'
 export * from './constants/execution-plan'
-export * from './constants/workstream'
+export * from './constants/thread'
 export * from './runtime/agent-types'
 export * from './runtime/chat-message-metadata'
 export * from './runtime/execution-plan-result'
@@ -25,8 +25,8 @@ export * from './schemas/repository-structure'
 export * from './schemas/tools'
 export * from './schemas/user'
 export * from './schemas/user-api'
-export * from './schemas/workstream'
-export * from './schemas/workstream-api'
+export * from './schemas/thread'
+export * from './schemas/thread-api'
 export * from './constants/model'
 export * from './constants/search'
 export * from './utils/assistant-text'

package/src/runtime/agent-types.ts

@@ -7,7 +7,7 @@ import type {
   ToolSet,
 } from 'ai'
 
-export type ChatMode = 'direct' | 'workstreamMode' | 'fixedWorkstreamMode'
+export type ChatMode = 'direct' | 'threadMode' | 'fixedThreadMode'
 
 export interface CreateRoutedAgentOptions<TTools extends ToolSet = ToolSet> {
   mode: ChatMode

package/src/schemas/agent-plan-draft.ts

@@ -1,16 +1,22 @@
 import { z } from 'zod'
 
 import { HUMAN_NODE_TYPES, STRUCTURAL_NODE_TYPES } from '../constants/execution-plan'
-import type { PlanArtifactSpec, PlanCompletionCheck, PlanDraft, PlanNodeOwner, PlanNodeType } from './execution-plan'
+import type {
+  DeliberationForkConfig,
+  MonitoringWindowConfig,
+  PlanArtifactSpec,
+  PlanCompletionCheck,
+  PlanDraft,
+  PlanNodeOwner,
+  PlanNodeType,
+} from './execution-plan'
 import {
-  ExecutionModeSchema,
   PlanArtifactSpecSchema,
   PlanCompletionCheckSchema,
   PlanCompletionCheckTypeSchema,
   PlanContextPolicySchema,
   PlanEdgeSpecSchema,
   PlanExecutionVisibilitySchema,
-  PlanNodeOwnerSchema,
   PlanNodeTypeSchema,
   PlanRetryPolicySchema,
   PlanToolPolicySchema,
@@ -19,8 +25,6 @@ import {
 const STRUCTURAL_NODE_TYPE_SET = new Set<PlanNodeType>(STRUCTURAL_NODE_TYPES)
 const HUMAN_NODE_TYPE_SET = new Set<PlanNodeType>(HUMAN_NODE_TYPES)
 
-const agentPlanOwnerStringSchema = z.string().trim().min(1).max(200)
-
 const AgentPlanDeliverableDraftSchema = z.union([z.string().trim().min(1).max(1000), PlanArtifactSpecSchema])
 
 const SimplifiedCompletionCheckSchema = z.object({
@@ -36,12 +40,14 @@ export const AgentPlanNodeDraftSchema = z.object({
   id: z.string().trim().min(1).max(200),
   type: PlanNodeTypeSchema,
   label: z.string().trim().min(1).max(300),
-  owner: z.union([PlanNodeOwnerSchema, agentPlanOwnerStringSchema]),
-  objective: z.string().trim().min(1).max(2000),
-  instructions: z.string().trim().min(1).max(4000),
-  successCriteria: z.array(z.string().trim().min(1).max(1000)).min(1),
-  deliverables: z.array(AgentPlanDeliverableDraftSchema).min(1).optional(),
-  completionChecks: z.array(AgentPlanCompletionCheckDraftSchema).min(1).optional(),
+  owner: z.string().trim().min(1).max(200).optional(),
+  objective: z.string().trim().max(2000).optional(),
+  instructions: z.string().trim().max(4000).optional(),
+  successCriteria: z.array(z.string().trim().min(1).max(1000)).optional(),
+  deliverables: z.array(AgentPlanDeliverableDraftSchema).optional(),
+  completionChecks: z.array(AgentPlanCompletionCheckDraftSchema).optional(),
+  monitoringConfig: z.record(z.string(), z.unknown()).optional(),
+  deliberationConfig: z.record(z.string(), z.unknown()).optional(),
 })
 export type AgentPlanNodeDraft = z.infer<typeof AgentPlanNodeDraftSchema>
 
@@ -58,8 +64,6 @@ export const AgentPlanDraftSchema = z.object({
   objective: z.string().trim().min(1).max(2000),
   nodes: z.array(AgentPlanNodeDraftSchema).min(1).max(32),
   edges: z.array(AgentPlanEdgeDraftSchema).default([]),
-  entryNodeIds: z.array(z.string().trim().min(1).max(200)).min(1).optional(),
-  executionMode: ExecutionModeSchema.optional(),
 })
 export type AgentPlanDraft = z.infer<typeof AgentPlanDraftSchema>
 
@@ -76,6 +80,16 @@ export function normalizeOwner(owner: string | PlanNodeOwner): PlanNodeOwner {
   return { executorType: 'agent', ref: normalized }
 }
 
+function resolveOwner(node: AgentPlanNodeDraft): PlanNodeOwner {
+  if (HUMAN_NODE_TYPE_SET.has(node.type)) {
+    return { executorType: 'user', ref: 'user' }
+  }
+  if (node.owner) {
+    return normalizeOwner(node.owner)
+  }
+  return { executorType: 'agent', ref: 'lead' }
+}
+
 function toDeliverableName(value: string, fallback: string): string {
   const normalized = value
     .trim()
@@ -193,22 +207,32 @@ function expandCompletionChecks(node: AgentPlanNodeDraft, deliverables: PlanArti
   })
 }
 
+function inferEntryNodeIds(draft: AgentPlanDraft): string[] {
+  const targets = new Set(draft.edges.map((e) => e.target))
+  const entryIds = draft.nodes.filter((n) => !targets.has(n.id)).map((n) => n.id)
+  return entryIds.length > 0 ? entryIds : [draft.nodes[0].id]
+}
+
 export function expandAgentPlanDraft(draft: AgentPlanDraft): PlanDraft {
   const expandedNodes = draft.nodes.map((node) => {
     const deliverables = expandDeliverables(node)
     const completionChecks = expandCompletionChecks(node, deliverables)
+    const isStructural = isStructuralNodeType(node.type)
 
     return {
       id: node.id,
       type: node.type,
       label: node.label,
-      owner: HUMAN_NODE_TYPE_SET.has(node.type)
-        ? ({ executorType: 'user', ref: 'user' } as const)
-        : normalizeOwner(node.owner),
-      objective: node.objective,
-      instructions: node.instructions,
+      owner: resolveOwner(node),
+      objective: node.objective || node.label,
+      instructions: node.instructions || (isStructural ? node.label : ''),
       deliverables,
-      successCriteria: [...node.successCriteria],
+      successCriteria:
+        node.successCriteria && node.successCriteria.length > 0
+          ? [...node.successCriteria]
+          : isStructural
+            ? []
+            : ['Completed successfully'],
       completionChecks,
       retryPolicy: PlanRetryPolicySchema.parse({ maxAttempts: 0, retryOn: [] }),
       failurePolicy: [],
@@ -219,6 +243,8 @@ export function expandAgentPlanDraft(draft: AgentPlanDraft): PlanDraft {
         webPolicy: 'allowed',
       }),
       executionVisibility: PlanExecutionVisibilitySchema.parse('auto'),
+      ...(node.monitoringConfig ? { monitoringConfig: node.monitoringConfig as MonitoringWindowConfig } : {}),
+      ...(node.deliberationConfig ? { deliberationConfig: node.deliberationConfig as DeliberationForkConfig } : {}),
     }
   })
 
@@ -229,7 +255,7 @@ export function expandAgentPlanDraft(draft: AgentPlanDraft): PlanDraft {
     defaultExecutionVisibility: 'auto',
     nodes: expandedNodes,
     edges: draft.edges.map((edge) => PlanEdgeSpecSchema.parse({ ...edge, map: {} })),
-    entryNodeIds: draft.entryNodeIds ? [...draft.entryNodeIds] : undefined,
-    executionMode: draft.executionMode,
+    entryNodeIds: inferEntryNodeIds(draft),
+    executionMode: 'linear',
   }
 }

package/src/schemas/autonomous-job.ts

@@ -35,7 +35,7 @@ export const AutonomousJobSchema = z
     organizationId: z.string(),
     ownerUserId: z.string(),
     ownerUserName: z.string().optional(),
-    workstreamId: z.string(),
+    threadId: z.string(),
     agentId: z.string(),
     title: z.string(),
     prompt: z.string(),
@@ -59,7 +59,7 @@ export const AutonomousJobRunSchema = z
   .object({
     id: z.string(),
     autonomousJobId: z.string(),
-    workstreamId: z.string(),
+    threadId: z.string(),
     queueJobId: z.string().optional(),
     status: AutonomousJobRunStatusSchema,
     inputMessageId: z.string().optional(),
@@ -86,7 +86,7 @@ export const CreateAutonomousJobInputSchema = z
     prompt: z.string().trim().min(1).max(10_000),
     schedule: AutonomousJobScheduleSchema,
     autoPauseThreshold: z.number().int().positive().default(3),
-    workstreamTitle: z.string().trim().min(1).max(300).optional(),
+    threadTitle: z.string().trim().min(1).max(300).optional(),
   })
   .strict()
 export type CreateAutonomousJobInput = z.infer<typeof CreateAutonomousJobInputSchema>

package/src/schemas/common.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod'
 
-import { WORKSTREAM } from '../constants/workstream'
+import { THREAD } from '../constants/thread'
 
 const SURREALDB_RECORD_ID_CLASSES = new Set(['RecordId', 'StringRecordId'])
 
@@ -47,14 +47,14 @@ export const recordIdSchema = z.preprocess(
 
 export const recordIdStringSchema = z.preprocess(coerceRecordIdToString, z.string())
 
-export const paginationTakeSchema = z.coerce.number().int().min(1).max(WORKSTREAM.MAX_MESSAGES_PER_PAGE)
+export const paginationTakeSchema = z.coerce.number().int().min(1).max(THREAD.MAX_MESSAGES_PER_PAGE)
 export const paginationPageSchema = z.coerce.number().int().min(1)
 export const paginationCursorSchema = z.preprocess((value) => value, recordIdSchema)
 
 export const paginationSchemaBase = z.object({
   page: paginationPageSchema.optional(),
   cursor: paginationCursorSchema.optional(),
-  take: paginationTakeSchema.default(WORKSTREAM.DEFAULT_PAGE_LIMIT),
+  take: paginationTakeSchema.default(THREAD.DEFAULT_PAGE_LIMIT),
 })
 
 export const paginationSchema = paginationSchemaBase.refine(

package/src/schemas/execution-plan.ts

@@ -324,7 +324,7 @@ export type PlanScheduleStatus = ActiveRecordStatus
 export const PlanScheduleRecordSchema = z.object({
   id: recordIdSchema,
   organizationId: recordIdSchema,
-  workstreamId: recordIdSchema,
+  threadId: recordIdSchema,
   planSpecId: recordIdSchema.optional(),
   runId: recordIdSchema.optional(),
   nodeId: z.string().optional(),
@@ -402,21 +402,6 @@ export const NodeWorkspaceEntrySchema = z
   .strict()
 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]),
 )
@@ -433,9 +418,7 @@ export const PlanArtifactSubmissionSchema = z
   .object({
     name: z.string().trim().min(1).max(200),
     kind: PlanArtifactKindSchema,
-    pointer: z.string().trim().min(1).max(500),
-    schemaRef: z.string().trim().min(1).max(200).optional(),
-    description: z.string().trim().min(1).max(1000).optional(),
+    description: z.string().trim().max(1000).optional(),
     payload: planStructuredPayloadSchema.optional(),
   })
   .strict()
@@ -443,11 +426,9 @@ export type PlanArtifactSubmission = z.infer<typeof PlanArtifactSubmissionSchema
 
 export const PlanNodeResultSubmissionSchema = z
   .object({
+    notes: z.string().trim().min(1).max(4000),
     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>
@@ -459,14 +440,14 @@ export const UpstreamHandoffSchema = z
     label: z.string().trim().min(1).max(300),
     ownerRef: z.string().trim().min(1).max(200),
     ownerType: PlanNodeExecutorTypeSchema,
-    handoffContext: PlanNodeHandoffContextSchema,
+    summary: z.string().optional(),
   })
   .strict()
 export type UpstreamHandoff = z.infer<typeof UpstreamHandoffSchema>
 
 export interface OwnershipDispatchContext {
   organizationId: string
-  workstreamId: string
+  threadId: string
   planId: string
   nodeId: string
   leadAgentId: string
@@ -601,7 +582,7 @@ export type ContextEnrichmentEntry = z.infer<typeof ContextEnrichmentEntrySchema
 export const PlanSpecSchema = z.object({
   id: recordIdSchema,
   organizationId: recordIdSchema,
-  workstreamId: recordIdSchema,
+  threadId: recordIdSchema,
   title: z.string(),
   objective: z.string(),
   version: z.number().int().positive(),
@@ -638,7 +619,7 @@ export const PlanRunSchema = z.object({
   id: recordIdSchema,
   planSpecId: recordIdSchema,
   organizationId: recordIdSchema,
-  workstreamId: recordIdSchema,
+  threadId: recordIdSchema,
   leadAgentId: z.string(),
   status: PlanRunStatusSchema,
   currentNodeId: z.string().optional(),
@@ -667,7 +648,6 @@ 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(),
@@ -799,7 +779,6 @@ export const SerializablePlanNodeSchema = PlanNodeSpecRecordSchema.omit({
   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(),
   readyAt: z.iso.datetime().nullish(),
@@ -898,7 +877,7 @@ export type SerializableExecutionPlanProgress = z.infer<typeof SerializableExecu
 export const SerializableExecutionPlanSchema = z.object({
   specId: z.string(),
   runId: z.string(),
-  workstreamId: z.string(),
+  threadId: z.string(),
   organizationId: z.string(),
   title: z.string(),
   objective: z.string(),
@@ -946,7 +925,7 @@ export type PlanTemplateRecord = z.infer<typeof PlanTemplateRecordSchema>
 export const PlanCycleRecordSchema = z.object({
   id: recordIdSchema,
   organizationId: recordIdSchema,
-  workstreamId: recordIdSchema,
+  threadId: recordIdSchema,
   templateId: recordIdSchema,
   name: z.string(),
   schedule: CycleScheduleSchema,

package/src/schemas/organization.ts

@@ -5,8 +5,8 @@ import { recordIdSchema, recordIdStringSchema } from './common'
 export const sdkOrganizationSchema = z.object({
   id: recordIdStringSchema,
   name: z.string(),
-  regularChatDigestLastWorkstreamCursorCreatedAt: z.iso.datetime().nullable().optional(),
-  regularChatDigestLastWorkstreamCursorId: z.string().nullable().optional(),
+  regularChatDigestLastThreadCursorCreatedAt: z.iso.datetime().nullable().optional(),
+  regularChatDigestLastThreadCursorId: z.string().nullable().optional(),
   skillExtractionLastCursorId: z.string().nullable().optional(),
   skillExtractionLastCursorCreatedAt: z.iso.datetime().nullable().optional(),
   createdAt: z.iso.datetime(),
@@ -16,8 +16,8 @@ export const sdkOrganizationSchema = z.object({
 export const sdkOrganizationRecordSchema = z.object({
   id: recordIdSchema,
   name: z.string(),
-  regularChatDigestLastWorkstreamCursorCreatedAt: z.coerce.date().optional(),
-  regularChatDigestLastWorkstreamCursorId: z.string().optional(),
+  regularChatDigestLastThreadCursorCreatedAt: z.coerce.date().optional(),
+  regularChatDigestLastThreadCursorId: z.string().optional(),
   skillExtractionLastCursorId: z.string().optional(),
   skillExtractionLastCursorCreatedAt: z.coerce.date().optional(),
   createdAt: z.coerce.date(),

package/src/schemas/plan-board.ts

@@ -10,8 +10,8 @@ export const PlanNodeCardSchema = z
     ownerRef: z.string().trim().min(1),
     planRunId: z.string().trim().min(1),
     planTitle: z.string().trim().min(1),
-    workstreamId: z.string().trim().min(1),
-    workstreamTitle: z.string().trim().min(1),
+    threadId: z.string().trim().min(1),
+    threadTitle: z.string().trim().min(1),
     nodeType: z.string().trim().min(1),
     artifactCount: z.number().int().nonnegative(),
     hasApproval: z.boolean(),
@@ -74,8 +74,8 @@ export type MyTasksResponse = z.infer<typeof MyTasksResponseSchema>
 
 export const AgentProjectEntrySchema = z
   .object({
-    workstreamId: z.string().trim().min(1),
-    workstreamTitle: z.string().trim().min(1),
+    threadId: z.string().trim().min(1),
+    threadTitle: z.string().trim().min(1),
     planRunId: z.string().trim().min(1),
     planTitle: z.string().trim().min(1),
     status: z.string().trim().min(1),

package/src/schemas/recent-activity.ts

@@ -1,13 +1,13 @@
 import { z } from 'zod'
 
 export const RecentActivityEventKindSchema = z.enum([
-  'workstream.opened',
+  'thread.opened',
   'document.opened',
   'website-intelligence.viewed',
   'chat.turn.completed',
 ])
 
-export const RecentActivityTargetKindSchema = z.enum(['workstream', 'document', 'website-intelligence', 'chat-turn'])
+export const RecentActivityTargetKindSchema = z.enum(['thread', 'document', 'website-intelligence', 'chat-turn'])
 
 export const RecentActivityTitleSourceSchema = z.enum(['system', 'agent'])
 
@@ -24,9 +24,9 @@ export const RecentActivityMetadataSchema = z
   .object({
     agentId: z.string().optional(),
     agentName: z.string().optional(),
-    workstreamId: z.string().optional(),
-    workstreamTitle: z.string().optional(),
-    workstreamMode: z.string().optional(),
+    threadId: z.string().optional(),
+    threadTitle: z.string().optional(),
+    threadType: z.string().optional(),
     coreType: z.string().optional(),
     documentTitle: z.string().optional(),
     documentFolder: z.string().optional(),

package/src/schemas/thread-api.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod'
+
+import { baseChatMessageSchema } from './chat-api'
+import { paginationPageSchema, paginationTakeSchema, recordIdSchema } from './common'
+import { sdkThreadSchema, sdkThreadTypeSchema } from './thread'
+
+export const listSdkThreadsRequestSchema = z.object({
+  userId: recordIdSchema,
+  organizationId: recordIdSchema,
+  type: sdkThreadTypeSchema.optional(),
+  page: paginationPageSchema.optional(),
+  take: paginationTakeSchema.optional(),
+  includeArchived: z.boolean().default(false),
+})
+
+export const createSdkThreadRequestSchema = z.object({
+  userId: recordIdSchema,
+  organizationId: recordIdSchema,
+  title: z.string().trim().min(1).max(200).optional(),
+  type: sdkThreadTypeSchema.default('default'),
+  agentId: z.string().trim().min(1).optional(),
+  threadType: z.string().trim().min(1).optional(),
+})
+
+export const updateSdkThreadRequestSchema = z.object({ title: z.string().trim().min(1).max(200) })
+
+export const listSdkThreadsResponseSchema = z.object({
+  threads: z.array(sdkThreadSchema),
+  hasMore: z.boolean(),
+  page: z.number().optional(),
+})
+
+export const getSdkThreadResponseSchema = sdkThreadSchema
+
+export const listSdkThreadMessagesRequestSchema = z.object({
+  before: z.string().trim().min(1).optional(),
+  after: z.string().trim().min(1).optional(),
+  limit: paginationTakeSchema.optional(),
+})
+
+export const listSdkThreadMessagesResponseSchema = z.object({
+  messages: z.array(baseChatMessageSchema),
+  hasMore: z.boolean(),
+  prevCursor: z.string().nullable().optional(),
+  nextCursor: z.string().nullable().optional(),
+})
+
+export const sdkThreadMessageLookupSchema = z.object({ threadId: recordIdSchema, messageId: z.string().trim().min(1) })
+
+export const sdkThreadSendMessageRequestSchema = z.object({
+  threadId: recordIdSchema,
+  organizationId: recordIdSchema,
+  userId: recordIdSchema,
+  userName: z.string().trim().min(1),
+  messages: z.array(baseChatMessageSchema).min(1),
+})
+
+export type ListSdkThreadsRequest = z.infer<typeof listSdkThreadsRequestSchema>
+export type CreateSdkThreadRequest = z.infer<typeof createSdkThreadRequestSchema>
+export type UpdateSdkThreadRequest = z.infer<typeof updateSdkThreadRequestSchema>
+export type ListSdkThreadsResponse = z.infer<typeof listSdkThreadsResponseSchema>
+export type GetSdkThreadResponse = z.infer<typeof getSdkThreadResponseSchema>
+export type ListSdkThreadMessagesRequest = z.infer<typeof listSdkThreadMessagesRequestSchema>
+export type ListSdkThreadMessagesResponse = z.infer<typeof listSdkThreadMessagesResponseSchema>
+export type SdkThreadMessageLookup = z.infer<typeof sdkThreadMessageLookupSchema>
+export type SdkThreadSendMessageRequest = z.infer<typeof sdkThreadSendMessageRequestSchema>

package/src/schemas/{workstream.ts → thread.ts}

@@ -2,19 +2,20 @@ import { z } from 'zod'
 
 import { recordIdSchema, recordIdStringSchema } from './common'
 
-export const sdkWorkstreamModeSchema = z.enum(['direct', 'group'])
-export const sdkWorkstreamStatusSchema = z.enum(['regular', 'archived'])
+export const sdkThreadTypeSchema = z.enum(['default', 'topic', 'thread', 'group'])
+export type SdkThreadType = z.infer<typeof sdkThreadTypeSchema>
 
-export const sdkWorkstreamRecordSchema = z.object({
+export const sdkThreadStatusSchema = z.enum(['active', 'archived'])
+
+export const sdkThreadRecordSchema = z.object({
   id: recordIdSchema,
   organizationId: recordIdSchema,
   userId: recordIdSchema,
   agentId: z.string().nullish(),
-  mode: sdkWorkstreamModeSchema,
-  core: z.boolean(),
-  coreType: z.string().nullish(),
+  type: sdkThreadTypeSchema,
+  threadType: z.string().nullish(),
   title: z.string().nullish(),
-  status: sdkWorkstreamStatusSchema,
+  status: sdkThreadStatusSchema,
   members: z.array(z.string()).default([]),
   memoryBlock: z.string().nullish(),
   memoryBlockSummary: z.string().nullish(),
@@ -29,8 +30,8 @@ export const sdkWorkstreamRecordSchema = z.object({
   updatedAt: z.coerce.date(),
 })
 
-export const sdkWorkstreamSchema = sdkWorkstreamRecordSchema
-  .pick({ agentId: true, mode: true, core: true, coreType: true, status: true, nameGenerated: true, members: true })
+export const sdkThreadSchema = sdkThreadRecordSchema
+  .pick({ agentId: true, type: true, threadType: true, status: true, nameGenerated: true, members: true })
   .extend({
     id: recordIdStringSchema,
     organizationId: recordIdStringSchema,
@@ -43,15 +44,11 @@ export const sdkWorkstreamSchema = sdkWorkstreamRecordSchema
     updatedAt: z.iso.datetime(),
   })
 
-export const sdkPublicWorkstreamSchema = sdkWorkstreamSchema.omit({
-  organizationId: true,
-  userId: true,
-  memoryBlock: true,
-})
+export const sdkPublicThreadSchema = sdkThreadSchema.omit({ organizationId: true, userId: true, memoryBlock: true })
 
-export const sdkWorkstreamMessageSchema = z.object({
+export const sdkThreadMessageSchema = z.object({
   id: recordIdStringSchema,
-  workstreamId: recordIdStringSchema,
+  threadId: recordIdStringSchema,
   messageId: z.string(),
   role: z.enum(['system', 'user', 'assistant']),
   parts: z.array(z.record(z.string(), z.unknown())),
@@ -60,7 +57,7 @@ export const sdkWorkstreamMessageSchema = z.object({
   updatedAt: z.iso.datetime().optional(),
 })
 
-export const sdkWorkstreamAttachmentSchema = z.object({
+export const sdkThreadAttachmentSchema = z.object({
   id: recordIdStringSchema,
   attachmentType: z.string(),
   name: z.string(),
@@ -69,13 +66,13 @@ export const sdkWorkstreamAttachmentSchema = z.object({
   sizeBytes: z.number().nullable().optional(),
   url: z.string().nullable().optional(),
   messageId: recordIdStringSchema,
-  workstreamId: recordIdStringSchema,
+  threadId: recordIdStringSchema,
   createdAt: z.iso.datetime(),
   updatedAt: z.iso.datetime(),
 })
 
-export type SdkWorkstreamRecord = z.infer<typeof sdkWorkstreamRecordSchema>
-export type SdkWorkstream = z.infer<typeof sdkWorkstreamSchema>
-export type SdkPublicWorkstream = z.infer<typeof sdkPublicWorkstreamSchema>
-export type SdkWorkstreamMessage = z.infer<typeof sdkWorkstreamMessageSchema>
-export type SdkWorkstreamAttachment = z.infer<typeof sdkWorkstreamAttachmentSchema>
+export type SdkThreadRecord = z.infer<typeof sdkThreadRecordSchema>
+export type SdkThread = z.infer<typeof sdkThreadSchema>
+export type SdkPublicThread = z.infer<typeof sdkPublicThreadSchema>
+export type SdkThreadMessage = z.infer<typeof sdkThreadMessageSchema>
+export type SdkThreadAttachment = z.infer<typeof sdkThreadAttachmentSchema>

package/src/schemas/tools.ts

@@ -3,7 +3,12 @@ import { z } from 'zod'
 import { AgentPlanDraftSchema } from './agent-plan-draft'
 import { baseChatMessageSchema } from './chat-api'
 import type { AnyChatMessage } from './chat-message'
-import { PlanNodeResultSubmissionSchema, PlanRunStatusSchema, SerializableExecutionPlanSchema } from './execution-plan'
+import {
+  PlanNodeResultSubmissionSchema,
+  PlanNodeRunStatusSchema,
+  PlanNodeTypeSchema,
+  PlanRunStatusSchema,
+} from './execution-plan'
 
 export const USER_QUESTIONS_TOOL_NAME = 'userQuestions' as const
 export const CONSULT_SPECIALIST_TOOL_NAME = 'consultSpecialist' as const
@@ -11,23 +16,7 @@ export const CONSULT_TEAM_TOOL_NAME = 'consultTeam' as const
 export const EXECUTION_PLAN_TOOL_NAME = 'executionPlan' as const
 export const EXECUTION_PLAN_QUERY_TOOL_NAME = 'executionPlanQuery' as const
 export const SUBMIT_PLAN_TURN_RESULT_TOOL_NAME = 'submitPlanTurnResult' as const
-
-/** @deprecated Use EXECUTION_PLAN_TOOL_NAME */
-export const CREATE_EXECUTION_PLAN_TOOL_NAME = 'createExecutionPlan' as const
-/** @deprecated Use EXECUTION_PLAN_TOOL_NAME */
-export const CREATE_PROJECT_WITH_PLAN_TOOL_NAME = 'createProjectWithPlan' as const
-/** @deprecated Use EXECUTION_PLAN_TOOL_NAME */
-export const REPLACE_EXECUTION_PLAN_TOOL_NAME = 'replaceExecutionPlan' as const
-/** @deprecated Use EXECUTION_PLAN_TOOL_NAME */
 export const SUBMIT_EXECUTION_NODE_RESULT_TOOL_NAME = 'submitExecutionNodeResult' as const
-/** @deprecated Use EXECUTION_PLAN_QUERY_TOOL_NAME */
-export const LIST_EXECUTION_PLANS_TOOL_NAME = 'listExecutionPlans' as const
-/** @deprecated Use EXECUTION_PLAN_QUERY_TOOL_NAME */
-export const GET_EXECUTION_PLAN_DETAILS_TOOL_NAME = 'getExecutionPlanDetails' as const
-/** @deprecated Use EXECUTION_PLAN_QUERY_TOOL_NAME */
-export const GET_ACTIVE_EXECUTION_PLAN_TOOL_NAME = 'getActiveExecutionPlan' as const
-/** @deprecated Use EXECUTION_PLAN_TOOL_NAME */
-export const RESUME_EXECUTION_PLAN_RUN_TOOL_NAME = 'resumeExecutionPlanRun' as const
 
 const UserQuestionItemSchema = z
   .object({
@@ -68,53 +57,17 @@ const ExecutionPlanToolActionSchema = z.enum([
   'none',
 ])
 
-export const CreateExecutionPlanArgsSchema = AgentPlanDraftSchema.extend({
-  targetWorkstreamId: z
-    .string()
-    .trim()
-    .min(1)
-    .optional()
-    .describe('Target workstream ID. Defaults to the current workstream.'),
-}).strict()
-
-export const CreateProjectWithPlanArgsSchema = AgentPlanDraftSchema.extend({
-  projectTitle: z.string().trim().min(1).max(200).optional(),
-  targetWorkstreamId: z.string().trim().min(1).optional(),
-}).refine((value) => Boolean(value.projectTitle) !== Boolean(value.targetWorkstreamId), {
-  message: 'Provide exactly one of projectTitle or targetWorkstreamId.',
-  path: ['projectTitle'],
-})
-
-export const ReplaceExecutionPlanArgsSchema = AgentPlanDraftSchema.extend({
-  runId: z.string().trim().min(1).describe('ID of the plan run to replace.'),
-  reason: z.string().trim().min(1).max(1000).describe('Why the plan is being replaced.'),
+export const SubmitExecutionNodeResultArgsSchema = PlanNodeResultSubmissionSchema.extend({
+  runId: z.string().trim().min(1),
+  nodeId: z.string().trim().min(1),
 }).strict()
 
-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
-  .object({
-    runId: z.string().trim().min(1).optional(),
-    includeEvents: z.boolean().default(true).describe('Include events'),
-    includeArtifacts: z.boolean().default(true).describe('Include artifacts'),
-    includeApprovals: z.boolean().default(true).describe('Include approvals'),
-    includeCheckpoints: z.boolean().default(false).describe('Include checkpoints'),
-    includeValidationIssues: z.boolean().default(true).describe('Include validation issues'),
-  })
-  .strict()
-
-export const ResumeExecutionPlanRunArgsSchema = z.object({ runId: z.string().trim().min(1) }).strict()
-
 export const ExecutionPlanActionSchema = z
   .enum(['create', 'create-project', 'replace', 'resume'])
   .describe(
-    'create: inline plan (1-2 nodes). create-project: plan in a dedicated project workstream (3+ nodes). replace: replace active plan. resume: resume interrupted plan.',
+    'create: inline plan (1-2 nodes). create-project: plan in a dedicated project thread (3+ nodes). replace: replace active plan. resume: resume interrupted plan.',
   )
 export type ExecutionPlanAction = z.infer<typeof ExecutionPlanActionSchema>
 
@@ -126,13 +79,13 @@ export const ExecutionPlanArgsSchema = AgentPlanDraftSchema.extend({
     .min(1)
     .max(200)
     .optional()
-    .describe('Required for create-project when creating a new workstream.'),
-  targetWorkstreamId: z
+    .describe('Required for create-project when creating a new thread.'),
+  targetThreadId: z
     .string()
     .trim()
     .min(1)
     .optional()
-    .describe('Target existing workstream. For create-project, provide either this or projectTitle.'),
+    .describe('Target existing thread. For create-project, provide either this or projectTitle.'),
   runId: z.string().trim().min(1).optional().describe('Required for replace and resume.'),
   reason: z.string().trim().min(1).max(1000).optional().describe('Required for replace.'),
 }).strict()
@@ -150,10 +103,6 @@ export const ExecutionPlanQueryArgsSchema = z
   .strict()
 export type ExecutionPlanQueryArgs = z.infer<typeof ExecutionPlanQueryArgsSchema>
 
-export const PlanSummarySchema = z
-  .object({ runId: z.string(), title: z.string(), status: PlanRunStatusSchema })
-  .strict()
-
 export const ListExecutionPlansSummarySchema = z
   .object({
     runId: z.string(),
@@ -170,23 +119,44 @@ export const ListExecutionPlansToolResultDataSchema = z
   .object({ plans: z.array(ListExecutionPlansSummarySchema), totalCount: z.number().int().nonnegative() })
   .strict()
 
+export const ExecutionPlanProgressSchema = z.object({
+  completed: z.number().int().nonnegative(),
+  total: z.number().int().nonnegative(),
+})
+
+export const ExecutionPlanNodeSummarySchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  type: PlanNodeTypeSchema,
+  status: PlanNodeRunStatusSchema,
+  ownerRef: z.string(),
+})
+
 export const ExecutionPlanToolResultDataSchema = z
   .object({
     action: ExecutionPlanToolActionSchema,
-    message: z.string().trim().min(1).optional(),
-    changedNodeId: z.string().nullish(),
-    plan: SerializableExecutionPlanSchema.nullish(),
+    message: z.string().optional(),
     hasPlan: z.boolean(),
     status: PlanRunStatusSchema.nullish(),
-    planCount: z.number().int().nonnegative().optional(),
-    planSummaries: z.array(PlanSummarySchema).optional(),
+    plan: z
+      .object({
+        runId: z.string(),
+        title: z.string(),
+        objective: z.string(),
+        status: PlanRunStatusSchema,
+        progress: ExecutionPlanProgressSchema,
+        nodes: z.array(ExecutionPlanNodeSummarySchema),
+        activeNodeIds: z.array(z.string()),
+        readyNodeIds: z.array(z.string()),
+      })
+      .nullish(),
   })
   .strict()
 
 export const CreateProjectWithPlanResultDataSchema = ExecutionPlanToolResultDataSchema.extend({
-  workstreamId: z.string().trim().min(1),
-  workstreamTitle: z.string().trim().min(1),
-  createdWorkstream: z.boolean(),
+  threadId: z.string().trim().min(1),
+  threadTitle: z.string().trim().min(1),
+  createdThread: z.boolean(),
 }).strict()
 
 export const ConsultTeamResultDataSchema = z.object({ responses: z.array(ConsultTeamResponseSchema) }).strict()
@@ -200,16 +170,12 @@ export type ConsultTeamResponseData = Omit<z.infer<typeof ConsultTeamResponseSch
   message?: AnyChatMessage
 }
 export type ConsultTeamResultData = { responses: ConsultTeamResponseData[] }
-export type CreateExecutionPlanArgs = z.infer<typeof CreateExecutionPlanArgsSchema>
-export type CreateProjectWithPlanArgs = z.infer<typeof CreateProjectWithPlanArgsSchema>
-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>
-export type GetActiveExecutionPlanArgs = z.infer<typeof GetActiveExecutionPlanArgsSchema>
-export type ResumeExecutionPlanRunArgs = z.infer<typeof ResumeExecutionPlanRunArgsSchema>
+export type ExecutionPlanProgress = z.infer<typeof ExecutionPlanProgressSchema>
+export type ExecutionPlanNodeSummary = z.infer<typeof ExecutionPlanNodeSummarySchema>
 export type ExecutionPlanToolResultData = z.infer<typeof ExecutionPlanToolResultDataSchema>
 export type CreateProjectWithPlanResultData = z.infer<typeof CreateProjectWithPlanResultDataSchema>
 export type CoreChatTools = {

package/src/schemas/workstream-api.ts

@@ -1,71 +0,0 @@
-import { z } from 'zod'
-
-import { baseChatMessageSchema } from './chat-api'
-import { paginationPageSchema, paginationTakeSchema, recordIdSchema } from './common'
-import { sdkWorkstreamSchema } from './workstream'
-
-export const listSdkWorkstreamsRequestSchema = z.object({
-  userId: recordIdSchema,
-  organizationId: recordIdSchema,
-  mode: z.enum(['direct', 'group']),
-  core: z.boolean().optional(),
-  page: paginationPageSchema.optional(),
-  take: paginationTakeSchema.optional(),
-  includeArchived: z.boolean().default(false),
-})
-
-export const createSdkWorkstreamRequestSchema = z.object({
-  userId: recordIdSchema,
-  organizationId: recordIdSchema,
-  title: z.string().trim().min(1).max(200).optional(),
-  mode: z.enum(['direct', 'group']).default('group'),
-  agentId: z.string().trim().min(1).optional(),
-  core: z.boolean().optional(),
-  coreType: z.string().trim().min(1).optional(),
-})
-
-export const updateSdkWorkstreamRequestSchema = z.object({ title: z.string().trim().min(1).max(200) })
-
-export const listSdkWorkstreamsResponseSchema = z.object({
-  workstreams: z.array(sdkWorkstreamSchema),
-  hasMore: z.boolean(),
-  page: z.number().optional(),
-})
-
-export const getSdkWorkstreamResponseSchema = sdkWorkstreamSchema
-
-export const listSdkWorkstreamMessagesRequestSchema = z.object({
-  before: z.string().trim().min(1).optional(),
-  after: z.string().trim().min(1).optional(),
-  limit: paginationTakeSchema.optional(),
-})
-
-export const listSdkWorkstreamMessagesResponseSchema = z.object({
-  messages: z.array(baseChatMessageSchema),
-  hasMore: z.boolean(),
-  prevCursor: z.string().nullable().optional(),
-  nextCursor: z.string().nullable().optional(),
-})
-
-export const sdkWorkstreamMessageLookupSchema = z.object({
-  workstreamId: recordIdSchema,
-  messageId: z.string().trim().min(1),
-})
-
-export const sdkWorkstreamSendMessageRequestSchema = z.object({
-  workstreamId: recordIdSchema,
-  organizationId: recordIdSchema,
-  userId: recordIdSchema,
-  userName: z.string().trim().min(1),
-  messages: z.array(baseChatMessageSchema).min(1),
-})
-
-export type ListSdkWorkstreamsRequest = z.infer<typeof listSdkWorkstreamsRequestSchema>
-export type CreateSdkWorkstreamRequest = z.infer<typeof createSdkWorkstreamRequestSchema>
-export type UpdateSdkWorkstreamRequest = z.infer<typeof updateSdkWorkstreamRequestSchema>
-export type ListSdkWorkstreamsResponse = z.infer<typeof listSdkWorkstreamsResponseSchema>
-export type GetSdkWorkstreamResponse = z.infer<typeof getSdkWorkstreamResponseSchema>
-export type ListSdkWorkstreamMessagesRequest = z.infer<typeof listSdkWorkstreamMessagesRequestSchema>
-export type ListSdkWorkstreamMessagesResponse = z.infer<typeof listSdkWorkstreamMessagesResponseSchema>
-export type SdkWorkstreamMessageLookup = z.infer<typeof sdkWorkstreamMessageLookupSchema>
-export type SdkWorkstreamSendMessageRequest = z.infer<typeof sdkWorkstreamSendMessageRequestSchema>