@lota-sdk/core 0.1.31 → 0.1.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/core",
-  "version": "0.1.31",
+  "version": "0.1.33",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -32,7 +32,7 @@
     "@chat-adapter/slack": "^4.23.0",
     "@chat-adapter/state-ioredis": "^4.23.0",
     "@logtape/logtape": "^2.0.5",
-    "@lota-sdk/shared": "0.1.31",
+    "@lota-sdk/shared": "0.1.33",
     "@mendable/firecrawl-js": "^4.18.0",
     "@surrealdb/node": "^3.0.3",
     "ai": "^6.0.141",

package/src/runtime/agent-runtime-policy.ts

@@ -18,7 +18,6 @@ export interface AgentRuntimeConfig<TAgent extends string> {
 }
 
 export interface AgentRuntimeRuleOptions {
-  includeExecutionPlanRule?: boolean
   includeMemr3Rule?: boolean
   includeDomainReasoningFallbackRule?: boolean
 }
@@ -36,17 +35,14 @@ export interface AgentToolPolicy<TSkill extends PropertyKey> {
   includeProceedInOnboarding: boolean
   includeGithubIntegration: boolean
   includeIndexRepositoryByURL: boolean
+  includeExecutionPlanTools: boolean
   includeIndexedRepository: boolean
 }
 
 export const OWNERSHIP_DISPATCH_BLOCKED_TOOL_NAMES = Object.freeze([
   'conversationSearch',
-  'createExecutionPlan',
-  'replaceExecutionPlan',
-  'submitExecutionNodeResult',
-  'listExecutionPlans',
-  'getExecutionPlanDetails',
-  'resumeExecutionPlanRun',
+  'executionPlan',
+  'executionPlanQuery',
   'consultSpecialist',
   'consultTeam',
   'teamThink',
@@ -184,12 +180,13 @@ export function buildWorkstreamAgentToolPolicy<TAgent extends string, TSkill ext
   return {
     resolvedMode,
     skills,
-    includeMemorySearch: true,
-    includeConversationSearch: true,
-    includeMemoryRemember: true,
-    includeOrgActionSearch: true,
+    includeMemorySearch: !params.onboardingActive,
+    includeConversationSearch: !params.onboardingActive,
+    includeMemoryRemember: !params.onboardingActive,
+    includeOrgActionSearch: !params.onboardingActive,
     includeMemoryBlockAppend: true,
-    includeReadFileParts: true,
+    includeReadFileParts: !params.onboardingActive,
+    includeExecutionPlanTools: !params.onboardingActive,
     includeInspectWebsite: params.onboardingActive && params.agentId === onboardingOwnerAgentId,
     includeProceedInOnboarding: params.onboardingActive && params.agentId === onboardingOwnerAgentId,
     includeGithubIntegration: params.agentId === onboardingOwnerAgentId,
@@ -216,6 +213,7 @@ export function buildTeamConsultationAgentToolPolicy({
     includeOrgActionSearch: false,
     includeMemoryBlockAppend: false,
     includeReadFileParts: false,
+    includeExecutionPlanTools: false,
     includeInspectWebsite: false,
     includeProceedInOnboarding: false,
     includeGithubIntegration: false,

package/src/runtime/approval-continuation.ts

@@ -60,14 +60,7 @@ export function isApprovalContinuationRequest(messages: ChatMessage[]): boolean
   return hasApprovalRespondedParts(messages[lastAssistantIndex])
 }
 
-const PLAN_TOOL_NAMES = new Set([
-  'createExecutionPlan',
-  'replaceExecutionPlan',
-  'submitExecutionNodeResult',
-  'listExecutionPlans',
-  'getExecutionPlanDetails',
-  'resumeExecutionPlanRun',
-])
+const PLAN_TOOL_NAMES = new Set(['executionPlan', 'executionPlanQuery'])
 
 function isPlanApprovalId(value: unknown): value is string {
   return typeof value === 'string' && value.startsWith(`${TABLES.PLAN_APPROVAL}:`)

package/src/runtime/social-chat-agent-runner.ts

@@ -85,7 +85,6 @@ export async function runSocialAgentTurn(params: {
     learnedSkillsSection: params.learnedSkillsSection,
     userMessageText: params.userMessageText,
     ruleOptions: {
-      includeExecutionPlanRule: false,
       includeMemr3Rule: SOCIAL_CHAT_RETRIEVAL_TOOL_NAMES.some((toolName) => toolName in params.tools),
       includeDomainReasoningFallbackRule: params.agentId === 'cpo' || params.agentId === 'mentor',
     },

package/src/services/workstream-turn-preparation.service.ts

@@ -342,11 +342,7 @@ async function streamAgentResponse(
     workstreamStateSection,
     learnedSkillsSection,
     userMessageText: latestUserMessageText,
-    ruleOptions: {
-      includeExecutionPlanRule: streamParams.includeExecutionPlanTools,
-      includeMemr3Rule: hasRetrievalTools,
-      includeDomainReasoningFallbackRule: hasDomainRoutingSkills,
-    },
+    ruleOptions: { includeMemr3Rule: hasRetrievalTools, includeDomainReasoningFallbackRule: hasDomainRoutingSkills },
     additionalInstructionSections: mergeInstructionSections(
       executionPlanInstructionSections,
       streamParams.additionalInstructionSections,
@@ -363,6 +359,7 @@ async function streamAgentResponse(
     mode: streamParams.mode,
     tools: streamParams.tools,
     extraInstructions: config.extraInstructions,
+    maxRetries: 3,
     stopWhen: (agentResolution?.stopWhen as StopCondition<ToolSet> | Array<StopCondition<ToolSet>> | undefined) ??
       streamParams.stopWhen ?? [stepCountIs(config.maxSteps as number)],
     prepareStep: (agentResolution?.prepareStep as PrepareStepFunction<ToolSet> | undefined) ?? streamParams.prepareStep,
@@ -370,19 +367,32 @@ async function streamAgentResponse(
   const agentAbortSignal = streamParams.abortSignal ?? ctx.runAbortSignal
   agentTimer.step('agent-construction')
 
+  const MAX_STREAM_RETRIES = 3
   let result: unknown
-  try {
-    result = await streamParams.observer.run(() =>
-      agent.stream({ messages: modelMessages, abortSignal: agentAbortSignal }),
-    )
-    agentTimer.step('agent.stream()-resolved')
-  } catch (error) {
-    if (agentAbortSignal.aborted) {
-      streamParams.observer.recordAbort(error)
-    } else {
-      streamParams.observer.recordError(error)
+  for (let attempt = 0; ; attempt++) {
+    try {
+      result = await streamParams.observer.run(() =>
+        agent.stream({ messages: modelMessages, abortSignal: agentAbortSignal }),
+      )
+      agentTimer.step('agent.stream()-resolved')
+      break
+    } catch (error) {
+      if (agentAbortSignal.aborted) {
+        streamParams.observer.recordAbort(error)
+        throw error
+      }
+      const errorMessage = error instanceof Error ? error.message : String(error)
+      const isTransient =
+        errorMessage.includes('client disconnected') ||
+        errorMessage.includes('ECONNRESET') ||
+        errorMessage.includes('socket hang up') ||
+        errorMessage.includes('fetch failed')
+      if (!isTransient || attempt >= MAX_STREAM_RETRIES - 1) {
+        streamParams.observer.recordError(error)
+        throw error
+      }
+      aiLogger.warn`Transient stream error (attempt ${attempt + 1}/${MAX_STREAM_RETRIES}): ${errorMessage} — retrying`
     }
-    throw error
   }
   if (!hasUIMessageStream(result)) {
     throw new Error(`Agent run for ${resolvedAgentId} did not expose a UI message stream.`)

package/src/tools/execution-plan.tool.ts

@@ -1,65 +1,157 @@
 import {
-  CreateExecutionPlanArgsSchema,
-  GetActiveExecutionPlanArgsSchema,
-  ListExecutionPlansArgsSchema,
-  ResumeExecutionPlanRunArgsSchema,
-  ReplaceExecutionPlanArgsSchema,
+  ExecutionPlanArgsSchema,
+  ExecutionPlanQueryArgsSchema,
   SubmitExecutionNodeResultArgsSchema,
   expandAgentPlanDraft,
   getLatestExecutionPlanResult,
 } from '@lota-sdk/shared'
+import type { ExecutionPlanAction, ExecutionPlanArgs, CreateProjectWithPlanResultData } from '@lota-sdk/shared'
 import { tool } from 'ai'
 
 import type { RecordIdRef } from '../db/record-id'
+import { recordIdToString } from '../db/record-id'
+import { TABLES } from '../db/tables'
 import { executionPlanService } from '../services/execution-plan.service'
+import { workstreamService } from '../services/workstream.service'
 
-export function createCreateExecutionPlanTool(params: {
+type ExecutionPlanWorkstreamService = Pick<
+  typeof workstreamService,
+  'createWorkstream' | 'deleteWorkstream' | 'getWorkstream'
+>
+
+type ExecutionPlanExecutionPlanService = Pick<
+  typeof executionPlanService,
+  | 'createPlan'
+  | 'replacePlan'
+  | 'resumeRun'
+  | 'listActivePlanSummaries'
+  | 'getActivePlanToolResult'
+  | 'getActivePlansForWorkstream'
+>
+
+function extractDraft(input: ExecutionPlanArgs) {
+  const { action, projectTitle, targetWorkstreamId, runId, reason, ...draftInput } = input
+  return { action, projectTitle, targetWorkstreamId, runId, reason, draft: expandAgentPlanDraft(draftInput) }
+}
+
+export function createExecutionPlanTool(params: {
   orgId: RecordIdRef
+  userId: RecordIdRef
   workstreamId: RecordIdRef
   agentId: string
+  executionPlanService?: ExecutionPlanExecutionPlanService
+  workstreamService?: ExecutionPlanWorkstreamService
   onPlanChanged?: () => void
   validateInlinePlan?: (draft: ReturnType<typeof expandAgentPlanDraft>) => void
 }) {
+  const resolvedEpService = params.executionPlanService ?? executionPlanService
+  const resolvedWsService = params.workstreamService ?? workstreamService
+
   return tool({
     description:
-      'Create a contract-driven execution plan for this workstream. Use createProjectWithPlan instead when the work needs a dedicated project workstream or a larger 3+ node plan.',
-    inputSchema: CreateExecutionPlanArgsSchema,
+      'Manage execution plans. Actions: create (inline, 1-2 nodes), create-project (dedicated project workstream, 3+ nodes), replace (swap active plan), resume (resume interrupted plan).',
+    inputSchema: ExecutionPlanArgsSchema,
     execute: async (input) => {
-      const { targetWorkstreamId, ...draftInput } = input
-      const draft = expandAgentPlanDraft(draftInput)
-      params.validateInlinePlan?.(draft)
-      const result = await executionPlanService.createPlan({
-        organizationId: params.orgId,
-        workstreamId: targetWorkstreamId ?? params.workstreamId,
-        leadAgentId: params.agentId,
-        input: draft,
-      })
+      const { action, projectTitle, targetWorkstreamId, runId, reason, draft } = extractDraft(input)
+
+      const handler: Record<ExecutionPlanAction, () => Promise<unknown>> = {
+        create: async () => {
+          params.validateInlinePlan?.(draft)
+          return await resolvedEpService.createPlan({
+            organizationId: params.orgId,
+            workstreamId: targetWorkstreamId ?? params.workstreamId,
+            leadAgentId: params.agentId,
+            input: draft,
+          })
+        },
+
+        'create-project': async () => {
+          const targetWorkstream = targetWorkstreamId
+            ? await resolvedWsService.getWorkstream(targetWorkstreamId)
+            : await resolvedWsService.createWorkstream(params.userId, params.orgId, {
+                title: projectTitle!,
+                mode: 'group',
+              })
+
+          if (targetWorkstream.organizationId !== recordIdToString(params.orgId, TABLES.ORGANIZATION)) {
+            throw new Error('Target workstream belongs to a different organization.')
+          }
+          if (targetWorkstream.userId !== recordIdToString(params.userId, TABLES.USER)) {
+            throw new Error('Target workstream belongs to a different user.')
+          }
+
+          const existingPlans = await resolvedEpService.getActivePlansForWorkstream(targetWorkstream.id)
+          if (!targetWorkstream.core && existingPlans.length > 0) {
+            throw new Error(
+              'This workstream already has an active execution plan. Use action "replace" or target a core workstream.',
+            )
+          }
+
+          const createdWorkstream = !targetWorkstreamId
+          try {
+            const result = await resolvedEpService.createPlan({
+              organizationId: params.orgId,
+              workstreamId: targetWorkstream.id,
+              leadAgentId: params.agentId,
+              input: draft,
+            })
+            return {
+              ...result,
+              workstreamId: targetWorkstream.id,
+              workstreamTitle: targetWorkstream.title,
+              createdWorkstream,
+            } satisfies CreateProjectWithPlanResultData
+          } catch (error) {
+            if (createdWorkstream) {
+              await resolvedWsService.deleteWorkstream(targetWorkstream.id).catch(() => {})
+            }
+            throw error
+          }
+        },
+
+        replace: async () => {
+          return await resolvedEpService.replacePlan({
+            organizationId: params.orgId,
+            workstreamId: params.workstreamId,
+            leadAgentId: params.agentId,
+            input: { runId: runId!, reason: reason!, ...draft },
+          })
+        },
+
+        resume: async () => {
+          return await resolvedEpService.resumeRun({
+            workstreamId: params.workstreamId,
+            emittedBy: params.agentId,
+            input: { runId: runId! },
+          })
+        },
+      }
+
+      const result = await handler[action]()
       params.onPlanChanged?.()
       return result
     },
   })
 }
 
-export function createReplaceExecutionPlanTool(params: {
-  orgId: RecordIdRef
-  workstreamId: RecordIdRef
-  agentId: string
-  onPlanChanged?: () => void
-}) {
+export function createExecutionPlanQueryTool(params: { workstreamId: RecordIdRef }) {
   return tool({
     description:
-      'Replace the active execution run with a new contract-driven plan when the graph, contracts, or approach materially change.',
-    inputSchema: ReplaceExecutionPlanArgsSchema,
+      'Query execution plans. Omit runId to list all active plans. Provide runId to load a specific plan run.',
+    inputSchema: ExecutionPlanQueryArgsSchema,
     execute: async (input) => {
-      const { runId, reason, ...draftInput } = input
-      const result = await executionPlanService.replacePlan({
-        organizationId: params.orgId,
+      if (!input.runId) {
+        return await executionPlanService.listActivePlanSummaries(params.workstreamId)
+      }
+      return await executionPlanService.getActivePlanToolResult({
         workstreamId: params.workstreamId,
-        leadAgentId: params.agentId,
-        input: { runId, reason, ...expandAgentPlanDraft(draftInput) },
+        runId: input.runId,
+        includeEvents: input.includeEvents,
+        includeArtifacts: input.includeArtifacts,
+        includeApprovals: input.includeApprovals,
+        includeCheckpoints: input.includeCheckpoints,
+        includeValidationIssues: input.includeValidationIssues,
       })
-      params.onPlanChanged?.()
-      return result
     },
   })
 }
@@ -89,50 +181,3 @@ export function createSubmitExecutionNodeResultTool(params: {
     },
   })
 }
-
-export function createListExecutionPlansTool(params: { workstreamId: RecordIdRef }) {
-  return tool({
-    description:
-      'List all active execution plans for this workstream with summary info (title, status, objective, node counts). Use getExecutionPlanDetails to inspect a specific plan.',
-    inputSchema: ListExecutionPlansArgsSchema,
-    execute: async () => await executionPlanService.listActivePlanSummaries(params.workstreamId),
-  })
-}
-
-export function createGetExecutionPlanDetailsTool(params: { workstreamId: RecordIdRef }) {
-  return tool({
-    description: 'Load a plan run and its current state.',
-    inputSchema: GetActiveExecutionPlanArgsSchema,
-    execute: async (input) =>
-      await executionPlanService.getActivePlanToolResult({
-        workstreamId: params.workstreamId,
-        runId: input.runId,
-        includeEvents: input.includeEvents,
-        includeArtifacts: input.includeArtifacts,
-        includeApprovals: input.includeApprovals,
-        includeCheckpoints: input.includeCheckpoints,
-        includeValidationIssues: input.includeValidationIssues,
-      }),
-  })
-}
-
-export function createResumeExecutionPlanRunTool(params: {
-  workstreamId: RecordIdRef
-  agentId: string
-  onPlanChanged?: () => void
-}) {
-  return tool({
-    description:
-      'Resume the active execution run from its latest checkpoint after interruption. The executor reconciles state before re-activating nodes.',
-    inputSchema: ResumeExecutionPlanRunArgsSchema,
-    execute: async (input) => {
-      const result = await executionPlanService.resumeRun({
-        workstreamId: params.workstreamId,
-        emittedBy: params.agentId,
-        input,
-      })
-      params.onPlanChanged?.()
-      return result
-    },
-  })
-}

package/src/tools/index.ts

@@ -1,7 +1,6 @@
 export * from './execution-plan.tool'
 export * from './fetch-webpage.tool'
 export * from './memory-block.tool'
-export * from './project-with-plan.tool'
 export * from './read-file-parts.tool'
 export * from './remember-memory.tool'
 export * from './research-topic.tool'

package/src/tools/project-with-plan.tool.ts

@@ -1,87 +0,0 @@
-import type { CreateProjectWithPlanResultData } from '@lota-sdk/shared'
-import { CreateProjectWithPlanArgsSchema, expandAgentPlanDraft } from '@lota-sdk/shared'
-import { tool } from 'ai'
-
-import type { RecordIdRef } from '../db/record-id'
-import { recordIdToString } from '../db/record-id'
-import { TABLES } from '../db/tables'
-import { executionPlanService } from '../services/execution-plan.service'
-import { workstreamService } from '../services/workstream.service'
-
-type ProjectWithPlanWorkstreamService = Pick<
-  typeof workstreamService,
-  'createWorkstream' | 'deleteWorkstream' | 'getWorkstream'
->
-
-type ProjectWithPlanExecutionPlanService = Pick<
-  typeof executionPlanService,
-  'createPlan' | 'getActivePlansForWorkstream'
->
-
-export function createCreateProjectWithPlanTool(params: {
-  orgId: RecordIdRef
-  userId: RecordIdRef
-  agentId: string
-  workstreamService?: ProjectWithPlanWorkstreamService
-  executionPlanService?: ProjectWithPlanExecutionPlanService
-  onPlanChanged?: () => void
-}) {
-  const resolvedWorkstreamService = params.workstreamService ?? workstreamService
-  const resolvedExecutionPlanService = params.executionPlanService ?? executionPlanService
-
-  return tool({
-    description:
-      'Create a dedicated project workstream with an execution plan, or add a simplified agent-authored plan to an existing target workstream.',
-    inputSchema: CreateProjectWithPlanArgsSchema,
-    execute: async (input): Promise<CreateProjectWithPlanResultData> => {
-      const { projectTitle, targetWorkstreamId, ...draftInput } = input
-      const expandedDraft = expandAgentPlanDraft(draftInput)
-
-      const targetWorkstream = targetWorkstreamId
-        ? await resolvedWorkstreamService.getWorkstream(targetWorkstreamId)
-        : await resolvedWorkstreamService.createWorkstream(params.userId, params.orgId, {
-            title: projectTitle,
-            mode: 'group',
-          })
-
-      if (targetWorkstream.organizationId !== recordIdToString(params.orgId, TABLES.ORGANIZATION)) {
-        throw new Error('Target workstream belongs to a different organization.')
-      }
-      if (targetWorkstream.userId !== recordIdToString(params.userId, TABLES.USER)) {
-        throw new Error('Target workstream belongs to a different user.')
-      }
-
-      const existingPlans = await resolvedExecutionPlanService.getActivePlansForWorkstream(targetWorkstream.id)
-      if (!targetWorkstream.core && existingPlans.length > 0) {
-        throw new Error(
-          'This workstream already has an active execution plan. Use replaceExecutionPlan or target a core workstream.',
-        )
-      }
-
-      const createdWorkstream = !targetWorkstreamId
-
-      try {
-        const result = await resolvedExecutionPlanService.createPlan({
-          organizationId: params.orgId,
-          workstreamId: targetWorkstream.id,
-          leadAgentId: params.agentId,
-          input: expandedDraft,
-        })
-
-        params.onPlanChanged?.()
-
-        return {
-          ...result,
-          workstreamId: targetWorkstream.id,
-          workstreamTitle: targetWorkstream.title,
-          createdWorkstream,
-        }
-      } catch (error) {
-        if (createdWorkstream) {
-          await resolvedWorkstreamService.deleteWorkstream(targetWorkstream.id).catch(() => {})
-        }
-        throw error
-      }
-    },
-  })
-}