@lota-sdk/core 0.4.8 → 0.4.10

package/src/runtime/domain-layer.ts

@@ -0,0 +1,192 @@
+/**
+ * Builds the domain-service Layer tree for `createLotaRuntime`.
+ *
+ * The services form a 9-tier dependency graph on top of the infrastructure
+ * layer (config, logging, database, redis, agents, threads, extensions).
+ * Each tier is provided with the accumulated context of earlier tiers so
+ * every service resolves cleanly when the ManagedRuntime eagerly loads them.
+ */
+
+import type { Layer as LayerType } from 'effect'
+import { Layer } from 'effect'
+
+import { AiGatewayLive } from '../ai-gateway/ai-gateway'
+import { EmbeddingCacheLive } from '../ai/embedding-cache'
+import type { buildInfrastructureLayer } from '../effect/layers'
+import { SharedThreadStreamSubscriberLive } from '../redis/stream-context'
+import { AgentActivityServiceLive } from '../services/agent-activity.service'
+import { AgentExecutorServiceLive } from '../services/agent-executor.service'
+import { ArtifactServiceLive } from '../services/artifact.service'
+import { AttachmentServiceLive } from '../services/attachment.service'
+import { AutonomousJobServiceLive } from '../services/autonomous-job.service'
+import { BackgroundWorkServiceLive } from '../services/background-work.service'
+import { ChatRunRegistryLive } from '../services/chat-run-registry.service'
+import { ContextCompactionServiceLive } from '../services/context-compaction.service'
+import { DocumentChunkServiceLive } from '../services/document-chunk.service'
+import { ExecutionPlanServiceLive } from '../services/execution-plan/execution-plan.service'
+import { FeedbackLoopServiceLive } from '../services/feedback-loop.service'
+import { GlobalOrchestratorServiceLive } from '../services/global-orchestrator.service'
+import { InstitutionalMemoryServiceLive } from '../services/institutional-memory.service'
+import { LearnedSkillServiceLive } from '../services/learned-skill.service'
+import { MemoryServiceLive } from '../services/memory/memory.service'
+import { RerankServiceLive } from '../services/memory/rerank.service'
+import { MonitoringWindowServiceLive } from '../services/monitoring-window.service'
+import { MutatingApprovalServiceLive } from '../services/mutating-approval.service'
+import { NodeWorkspaceServiceLive } from '../services/node-workspace.service'
+import { NotificationServiceLive } from '../services/notification.service'
+import { OrganizationMemberServiceLive } from '../services/organization-member.service'
+import { OrganizationServiceLive } from '../services/organization.service'
+import { OwnershipDispatcherServiceLive } from '../services/ownership-dispatcher.service'
+import { PlanAgentHeartbeatServiceLive } from '../services/plan/plan-agent-heartbeat.service'
+import { PlanAgentQueryServiceLive } from '../services/plan/plan-agent-query.service'
+import { PlanApprovalServiceLive } from '../services/plan/plan-approval.service'
+import { PlanArtifactServiceLive } from '../services/plan/plan-artifact.service'
+import { PlanBuilderServiceLive } from '../services/plan/plan-builder.service'
+import { PlanCheckpointServiceLive } from '../services/plan/plan-checkpoint.service'
+import { PlanCompilerServiceLive } from '../services/plan/plan-compiler.service'
+import { PlanCoordinationServiceLive } from '../services/plan/plan-coordination.service'
+import { PlanCycleServiceLive } from '../services/plan/plan-cycle.service'
+import { PlanDeadlineServiceLive } from '../services/plan/plan-deadline.service'
+import { PlanEventDeliveryServiceLive } from '../services/plan/plan-event-delivery.service'
+import { PlanExecutorServiceLive } from '../services/plan/plan-executor.service'
+import { PlanRunServiceLive } from '../services/plan/plan-run.service'
+import { PlanSchedulerServiceLive } from '../services/plan/plan-scheduler.service'
+import { PlanTemplateServiceLive } from '../services/plan/plan-template.service'
+import { PlanValidatorServiceLive } from '../services/plan/plan-validator.service'
+import { PlanWorkspaceServiceLive } from '../services/plan/plan-workspace.service'
+import { PluginExecutorServiceLive } from '../services/plugin-executor.service'
+import { QualityMetricsServiceLive } from '../services/quality-metrics.service'
+import { QueueJobServiceLive } from '../services/queue-job.service'
+import { RecentActivityTitleServiceLive } from '../services/recent-activity-title.service'
+import { RecentActivityServiceLive } from '../services/recent-activity.service'
+import { SkillResolverServiceLive } from '../services/skill-resolver.service'
+import { SocialChatHistoryServiceLive } from '../services/social-chat-history.service'
+import { SystemExecutorServiceLive } from '../services/system-executor.service'
+import { ThreadMessageServiceLive } from '../services/thread/thread-message.service'
+import { ThreadTitleServiceLive } from '../services/thread/thread-title.service'
+import { ThreadTurnServiceLive } from '../services/thread/thread-turn'
+import { ThreadTurnPreparationServiceLive } from '../services/thread/thread-turn-preparation.service'
+import { ThreadServiceLive } from '../services/thread/thread.service'
+import { UserServiceLive } from '../services/user.service'
+import { WriteIntentValidatorServiceLive } from '../services/write-intent-validator.service'
+import { AttachmentStorageServiceLive } from '../storage/attachment-storage.service'
+import { GeneratedDocumentStorageServiceLive } from '../storage/generated-document-storage.service'
+import { FirecrawlLive } from '../tools/firecrawl-client'
+import { CompactionCoordinationLive } from './chat-run-orchestration'
+import { HelperModelLive } from './helper-model'
+
+function provide<A, E, R extends RCtx, RCtx, E2>(
+  layer: LayerType.Layer<A, E, R>,
+  ctx: LayerType.Layer<RCtx, E2, never>,
+): LayerType.Layer<A, E | E2, never> {
+  return Layer.provideMerge(ctx)(layer)
+}
+
+type InfrastructureLayer = ReturnType<typeof buildInfrastructureLayer>
+
+/**
+ * Compose the domain service layer tree on top of the supplied infrastructure
+ * layer. The returned layer has no remaining requirements and can be fed
+ * straight into `ManagedRuntime.make`.
+ */
+export function buildDomainServiceLayer(infrastructureLayer: InfrastructureLayer) {
+  const tier0 = provide(
+    Layer.mergeAll(
+      BackgroundWorkServiceLive,
+      ChatRunRegistryLive,
+      CompactionCoordinationLive,
+      DocumentChunkServiceLive,
+      NodeWorkspaceServiceLive,
+      NotificationServiceLive,
+      PlanArtifactServiceLive,
+      PlanBuilderServiceLive,
+      WriteIntentValidatorServiceLive,
+    ),
+    infrastructureLayer,
+  )
+  const ctx0 = Layer.mergeAll(
+    infrastructureLayer,
+    provide(Layer.mergeAll(AiGatewayLive, EmbeddingCacheLive, FirecrawlLive, HelperModelLive), infrastructureLayer),
+    tier0,
+  )
+
+  const tier1 = provide(
+    Layer.mergeAll(
+      SharedThreadStreamSubscriberLive,
+      AgentExecutorServiceLive,
+      AttachmentStorageServiceLive,
+      GeneratedDocumentStorageServiceLive,
+      LearnedSkillServiceLive,
+      OrganizationServiceLive,
+      OrganizationMemberServiceLive,
+      PlanApprovalServiceLive,
+      PlanRunServiceLive,
+      PlanSchedulerServiceLive,
+      PlanWorkspaceServiceLive,
+      PluginExecutorServiceLive,
+      QualityMetricsServiceLive,
+      QueueJobServiceLive,
+      RecentActivityServiceLive,
+      RerankServiceLive,
+      SocialChatHistoryServiceLive,
+      SystemExecutorServiceLive,
+      ThreadMessageServiceLive,
+      UserServiceLive,
+    ),
+    ctx0,
+  )
+  const ctx1 = Layer.mergeAll(ctx0, tier1)
+
+  const tier2 = provide(
+    Layer.mergeAll(
+      ArtifactServiceLive,
+      AttachmentServiceLive,
+      ContextCompactionServiceLive,
+      FeedbackLoopServiceLive,
+      InstitutionalMemoryServiceLive,
+      MemoryServiceLive,
+      MonitoringWindowServiceLive,
+      MutatingApprovalServiceLive,
+      PlanAgentQueryServiceLive,
+      PlanCheckpointServiceLive,
+      PlanCoordinationServiceLive,
+      PlanEventDeliveryServiceLive,
+      SkillResolverServiceLive,
+      RecentActivityTitleServiceLive,
+    ),
+    ctx1,
+  )
+  const ctx2 = Layer.mergeAll(ctx1, tier2)
+
+  const tier3 = provide(Layer.mergeAll(PlanValidatorServiceLive, ThreadServiceLive), ctx2)
+  const ctx3 = Layer.mergeAll(ctx2, tier3)
+
+  const tier4 = provide(Layer.mergeAll(PlanCompilerServiceLive, ThreadTitleServiceLive), ctx3)
+  const ctx4 = Layer.mergeAll(ctx3, tier4)
+
+  const tier5 = provide(PlanExecutorServiceLive, ctx4)
+  const ctx5 = Layer.mergeAll(ctx4, tier5)
+
+  const tier6 = provide(
+    Layer.mergeAll(OwnershipDispatcherServiceLive, PlanAgentHeartbeatServiceLive, PlanDeadlineServiceLive),
+    ctx5,
+  )
+  const ctx6 = Layer.mergeAll(ctx5, tier6)
+
+  const tier7 = provide(Layer.mergeAll(ExecutionPlanServiceLive, GlobalOrchestratorServiceLive), ctx6)
+  const ctx7 = Layer.mergeAll(ctx6, tier7)
+
+  const tier8 = provide(
+    Layer.mergeAll(
+      PlanTemplateServiceLive,
+      AutonomousJobServiceLive,
+      AgentActivityServiceLive,
+      ThreadTurnPreparationServiceLive,
+    ),
+    ctx7,
+  )
+  const ctx8 = Layer.mergeAll(ctx7, tier8)
+
+  const tier9 = provide(Layer.mergeAll(PlanCycleServiceLive, ThreadTurnServiceLive), ctx8)
+  return Layer.mergeAll(ctx8, tier9)
+}

package/src/runtime/execution-plan-visibility.ts

@@ -1,6 +1,6 @@
 import type { PlanExecutionVisibility, PlanNodeSpecRecord, PlanSpecRecord } from '@lota-sdk/shared'
 
-import { agentRoster } from '../config/agent-defaults'
+import { isAgentName } from '../config/agent-defaults'
 
 export function resolvePlanNodeExecutionVisibility(
   plan: Pick<PlanSpecRecord, 'defaultExecutionVisibility'>,
@@ -12,7 +12,7 @@ export function resolvePlanNodeExecutionVisibility(
     return configuredVisibility
   }
 
-  return node.owner.executorType === 'agent' && agentRoster.includes(node.owner.ref) ? 'visible' : 'silent'
+  return node.owner.executorType === 'agent' && isAgentName(node.owner.ref) ? 'visible' : 'silent'
 }
 
 export function shouldPlanNodeUseVisibleTurn(

package/src/runtime/execution-plan.ts

@@ -1,4 +1,5 @@
 import type { SerializableExecutionPlan } from '@lota-sdk/shared'
+import { Schema, Duration, Effect } from 'effect'
 
 type ExecutionPlanPromptSummary = Pick<SerializableExecutionPlan, 'runId' | 'title'>
 
@@ -24,6 +25,15 @@ function formatExecutionPlansForPrompt(plans: SerializableExecutionPlan[]): stri
   return ['<execution-plan-state>', JSON.stringify(payload, null, 2), '</execution-plan-state>'].join('\n')
 }
 
+export class ExecutionPlanCacheError extends Schema.TaggedErrorClass<ExecutionPlanCacheError>()(
+  'ExecutionPlanCacheError',
+  { message: Schema.String, cause: Schema.Defect },
+) {}
+
+export function toExecutionPlanCacheError(cause: unknown): ExecutionPlanCacheError {
+  return new ExecutionPlanCacheError({ message: cause instanceof Error ? cause.message : String(cause), cause })
+}
+
 export function buildExecutionPlanInstructionSections(plans: SerializableExecutionPlan[] | null | undefined): string[] {
   const normalized = plans ?? []
   return [EXECUTION_PLAN_AGENT_PROTOCOL_PROMPT, formatExecutionPlansForPrompt(normalized)]
@@ -31,27 +41,44 @@ export function buildExecutionPlanInstructionSections(plans: SerializableExecuti
 
 export function createExecutionPlanInstructionSectionCache(params: {
   disabled?: boolean
-  loadPlans: () => Promise<SerializableExecutionPlan[]>
+  loadPlansEffect: () => Effect.Effect<SerializableExecutionPlan[], ExecutionPlanCacheError>
 }) {
-  let plansPromise: Promise<SerializableExecutionPlan[]> | null = null
-  let sectionsPromise: Promise<string[] | undefined> | null = null
+  const [getPlansCachedEffect, invalidatePlansEffect] = Effect.runSync(
+    Effect.cachedInvalidateWithTTL(
+      Effect.suspend(() => (params.disabled ? Effect.succeed([]) : params.loadPlansEffect())),
+      Duration.infinity,
+    ),
+  )
+  const [getSectionsCachedEffect, invalidateSectionsEffect] = Effect.runSync(
+    Effect.cachedInvalidateWithTTL(
+      Effect.gen(function* () {
+        if (params.disabled) {
+          return undefined
+        }
+
+        const plans = yield* getPlansCachedEffect
+        return buildExecutionPlanInstructionSections(plans)
+      }),
+      Duration.infinity,
+    ),
+  )
+
+  const getPlansEffect = (): Effect.Effect<SerializableExecutionPlan[], ExecutionPlanCacheError> => getPlansCachedEffect
+
+  const getSectionsEffect = (): Effect.Effect<string[] | undefined, ExecutionPlanCacheError> => getSectionsCachedEffect
 
   return {
     invalidate() {
-      plansPromise = null
-      sectionsPromise = null
+      Effect.runSync(invalidatePlansEffect)
+      Effect.runSync(invalidateSectionsEffect)
     },
-    async getPlans(): Promise<SerializableExecutionPlan[]> {
-      if (params.disabled) return []
-
-      plansPromise ??= params.loadPlans()
-      return plansPromise
+    getPlansEffect,
+    getSectionsEffect,
+    getPlans() {
+      return Effect.runPromise(getPlansEffect())
     },
-    async getSections(): Promise<string[] | undefined> {
-      if (params.disabled) return undefined
-
-      sectionsPromise ??= this.getPlans().then((plans) => buildExecutionPlanInstructionSections(plans))
-      return sectionsPromise
+    getSections() {
+      return Effect.runPromise(getSectionsEffect())
     },
   }
 }

package/src/runtime/graph-designer.ts

@@ -1,15 +1,27 @@
 import type { GraphDesignRequest, GraphDesignResponse } from '@lota-sdk/shared'
 
+import { resolveOptionalLotaService } from '../effect/runtime'
+import { RuntimeConfigServiceTag } from '../effect/services'
+
 export interface GraphDesigner {
   designGraph(request: GraphDesignRequest): Promise<GraphDesignResponse>
 }
 
-let _graphDesigner: GraphDesigner | null = null
+let currentGraphDesigner: GraphDesigner | null = null
+
+export function configureGraphDesigner(graphDesigner: GraphDesigner | null | undefined): void {
+  currentGraphDesigner = graphDesigner ?? null
+}
 
-export function configureGraphDesigner(designer: GraphDesigner): void {
-  _graphDesigner = designer
+export function clearGraphDesigner(): void {
+  currentGraphDesigner = null
 }
 
 export function getGraphDesigner(): GraphDesigner | null {
-  return _graphDesigner
+  if (currentGraphDesigner) {
+    return currentGraphDesigner
+  }
+
+  const runtimeConfig = resolveOptionalLotaService(RuntimeConfigServiceTag)
+  return runtimeConfig?.graphDesigner ?? null
 }

package/src/runtime/helper-model.ts

@@ -5,8 +5,13 @@ import type {
   ToolLoopAgentOnStepFinishCallback,
   ToolSet,
 } from 'ai'
+import { Context, Duration, Effect, Layer, Metric } from 'effect'
 import type { ZodSchema } from 'zod'
 
+import type { ValidationError } from '../effect/errors'
+import { AiGenerationError, BadRequestError } from '../effect/errors'
+import { summarizeZodIssues, toValidationError } from '../effect/zod'
+import { nowEpochMillis } from '../utils/date-time'
 import { isRecord, stringifyUnknown } from '../utils/string'
 
 export interface HelperToolLoopAgentOptions {
@@ -70,7 +75,7 @@ function isRateLimitError(error: unknown): boolean {
   return getErrorStatus(error) === 429
 }
 
-function formatError(tag: string, error: unknown): Error {
+function formatGenerationError(tag: string, error: unknown): AiGenerationError {
   const status = getErrorStatus(error)
   const rateLimited = isRateLimitError(error)
   const message = error instanceof Error ? error.message : String(error)
@@ -87,7 +92,73 @@ function formatError(tag: string, error: unknown): Error {
   if (responseBody) parts.push(`response_body=${responseBody}`)
   if (requestUrl) parts.push(`url=${requestUrl}`)
 
-  return new Error(parts.join(' '))
+  return new AiGenerationError({
+    source: tag,
+    message: parts.join(' '),
+    ...(status !== null ? { status } : {}),
+    ...(rateLimited ? { rateLimited: true } : {}),
+    ...(responseData ? { providerData: responseData } : {}),
+    ...(responseBody ? { responseBody } : {}),
+    ...(requestUrl ? { url: requestUrl } : {}),
+  })
+}
+
+function emptyHelperMessagesError(tag: string): BadRequestError {
+  return new BadRequestError({ message: `[${tag}] Empty helper messages` })
+}
+
+function parseStructuredRootCandidate<T>(params: {
+  tag: string
+  schema: ZodSchema<T>
+  candidate: unknown
+}): { data: T } | { error: ValidationError } {
+  const directParsed = params.schema.safeParse(params.candidate)
+  if (directParsed.success) {
+    return { data: directParsed.data }
+  }
+
+  return {
+    error: toValidationError(
+      directParsed.error,
+      `[${params.tag}] Structured output failed schema validation: ${summarizeZodIssues(directParsed.error.issues)}`,
+    ),
+  }
+}
+
+function createHelperAgent(params: {
+  tag: string
+  createAgent: CreateHelperAgentFn
+  systemPrompt?: string
+  temperature?: number
+  maxOutputTokens?: number
+  output?: Output.Output
+}): Effect.Effect<HelperAgent, AiGenerationError> {
+  return Effect.try({
+    try: () =>
+      params.createAgent({
+        ...(params.systemPrompt ? { instructions: params.systemPrompt } : {}),
+        ...(params.output ? { output: params.output } : {}),
+        ...(typeof params.temperature === 'number' ? { temperature: params.temperature } : {}),
+        ...(typeof params.maxOutputTokens === 'number' ? { maxOutputTokens: params.maxOutputTokens } : {}),
+        maxRetries: 2,
+      }),
+    catch: (error) => formatGenerationError(params.tag, error),
+  })
+}
+
+function generateWithHelperAgent(
+  tag: string,
+  agent: HelperAgent,
+  params: { messages: HelperMessage[]; timeoutMs?: number },
+): Effect.Effect<{ text?: unknown; output?: unknown }, AiGenerationError> {
+  return Effect.tryPromise({
+    try: () =>
+      agent.generate({
+        messages: toModelMessages(params.messages),
+        ...(typeof params.timeoutMs === 'number' ? { timeout: params.timeoutMs } : {}),
+      }),
+    catch: (error) => formatGenerationError(tag, error),
+  })
 }
 
 function toModelMessages(messages: HelperMessage[]): Array<{ role: 'user' | 'assistant'; content: string }> {
@@ -118,13 +189,6 @@ function resolveStructuredSystemPrompt(systemPrompt?: string): string {
   return parts.join('\n\n')
 }
 
-function formatSchemaIssueSummary(issues: Array<{ path: PropertyKey[]; message: string }>): string {
-  return issues
-    .slice(0, 5)
-    .map((issue) => `${issue.path.map((segment) => String(segment)).join('.') || 'root'}: ${issue.message}`)
-    .join('; ')
-}
-
 function parseStructuredCandidate<T>(params: {
   schema: ZodSchema<T>
   candidate: unknown
@@ -147,40 +211,54 @@ function parseStructuredCandidate<T>(params: {
   return null
 }
 
+const helperModelDuration = Metric.timer('helper_model_duration')
+
+function recordHelperModelDuration(tag: string, startedAt: number): Effect.Effect<void, never, never> {
+  return Metric.update(
+    Metric.withAttributes(helperModelDuration, { tag }),
+    Duration.millis(Math.max(0, nowEpochMillis() - startedAt)),
+  )
+}
+
 export function createHelperModelRuntime() {
-  async function generateHelperText(params: GenerateHelperTextParams): Promise<string> {
+  function generateHelperTextEffect(
+    params: GenerateHelperTextParams,
+  ): Effect.Effect<string, AiGenerationError | BadRequestError | ValidationError> {
     const systemPrompt = resolveSystemPrompt({
       explicitSystemPrompt: params.systemPrompt,
       defaultSystemPrompt: params.defaultSystemPrompt,
     })
 
     if (!systemPrompt && params.messages.length === 0) {
-      throw new Error(`[${params.tag}] Empty helper messages`)
+      return Effect.fail(emptyHelperMessagesError(params.tag))
     }
 
-    try {
-      const agent = params.createAgent({
-        ...(systemPrompt ? { instructions: systemPrompt } : {}),
-        ...(typeof params.temperature === 'number' ? { temperature: params.temperature } : {}),
-        ...(typeof params.maxOutputTokens === 'number' ? { maxOutputTokens: params.maxOutputTokens } : {}),
-        maxRetries: 2,
-      })
+    const startedAt = nowEpochMillis()
 
-      const result = await agent.generate({
-        messages: toModelMessages(params.messages),
-        ...(typeof params.timeoutMs === 'number' ? { timeout: params.timeoutMs } : {}),
+    return Effect.gen(function* () {
+      const agent = yield* createHelperAgent({
+        tag: params.tag,
+        createAgent: params.createAgent,
+        systemPrompt,
+        temperature: params.temperature,
+        maxOutputTokens: params.maxOutputTokens,
       })
+      const result = yield* generateWithHelperAgent(params.tag, agent, params)
       const text = typeof result.text === 'string' ? result.text.trim() : ''
       if (!text) {
-        throw new Error('Empty helper model output')
+        return yield* formatGenerationError(params.tag, new Error('Empty helper model output'))
       }
       return text
-    } catch (error) {
-      throw formatError(params.tag, error)
-    }
+    }).pipe(Effect.ensuring(recordHelperModelDuration(params.tag, startedAt)))
   }
 
-  async function generateHelperStructured<T>(params: GenerateHelperStructuredParams<T>): Promise<T> {
+  function generateHelperText(params: GenerateHelperTextParams): Promise<string> {
+    return Effect.runPromise(generateHelperTextEffect(params).pipe(Effect.withSpan('HelperModel.generateHelperText')))
+  }
+
+  function generateHelperStructuredEffect<T>(
+    params: GenerateHelperStructuredParams<T>,
+  ): Effect.Effect<T, AiGenerationError | BadRequestError | ValidationError> {
     const baseSystemPrompt = resolveSystemPrompt({
       explicitSystemPrompt: params.systemPrompt,
       defaultSystemPrompt: params.defaultSystemPrompt,
@@ -188,39 +266,52 @@ export function createHelperModelRuntime() {
     const systemPrompt = resolveStructuredSystemPrompt(baseSystemPrompt)
 
     if (!baseSystemPrompt && params.messages.length === 0) {
-      throw new Error(`[${params.tag}] Empty helper messages`)
+      return Effect.fail(emptyHelperMessagesError(params.tag))
     }
 
-    try {
-      const agent = params.createAgent({
-        output: Output.object({ schema: params.schema }),
-        ...(systemPrompt ? { instructions: systemPrompt } : {}),
-        ...(typeof params.temperature === 'number' ? { temperature: params.temperature } : {}),
-        ...(typeof params.maxOutputTokens === 'number' ? { maxOutputTokens: params.maxOutputTokens } : {}),
-        maxRetries: 2,
-      })
+    const startedAt = nowEpochMillis()
 
-      const result = await agent.generate({
-        messages: toModelMessages(params.messages),
-        ...(typeof params.timeoutMs === 'number' ? { timeout: params.timeoutMs } : {}),
+    return Effect.gen(function* () {
+      const agent = yield* createHelperAgent({
+        tag: params.tag,
+        createAgent: params.createAgent,
+        systemPrompt,
+        temperature: params.temperature,
+        maxOutputTokens: params.maxOutputTokens,
+        output: Output.object({ schema: params.schema }),
       })
+      const result = yield* generateWithHelperAgent(params.tag, agent, params)
       const parsed = parseStructuredCandidate({ schema: params.schema, candidate: result.output })
       if (parsed) {
         return parsed.data
       }
 
-      const directParsed = params.schema.safeParse(result.output)
-      if (!directParsed.success) {
-        throw new Error(
-          `Structured output failed schema validation: ${formatSchemaIssueSummary(directParsed.error.issues)}`,
-        )
+      const validated = parseStructuredRootCandidate({
+        tag: params.tag,
+        schema: params.schema,
+        candidate: result.output,
+      })
+      if ('error' in validated) {
+        return yield* validated.error
       }
 
-      return directParsed.data
-    } catch (error) {
-      throw formatError(params.tag, error)
-    }
+      return validated.data
+    }).pipe(Effect.ensuring(recordHelperModelDuration(params.tag, startedAt)))
+  }
+
+  function generateHelperStructured<T>(params: GenerateHelperStructuredParams<T>): Promise<T> {
+    return Effect.runPromise(
+      generateHelperStructuredEffect(params).pipe(Effect.withSpan('HelperModel.generateHelperStructured')),
+    )
   }
 
-  return { generateHelperText, generateHelperStructured }
+  return { generateHelperTextEffect, generateHelperText, generateHelperStructuredEffect, generateHelperStructured }
 }
+
+export type HelperModelRuntime = ReturnType<typeof createHelperModelRuntime>
+
+export class HelperModelTag extends Context.Service<HelperModelTag, HelperModelRuntime>()(
+  '@lota-sdk/core/HelperModel',
+) {}
+
+export const HelperModelLive = Layer.sync(HelperModelTag, () => createHelperModelRuntime())

package/src/runtime/index.ts

@@ -1,18 +1,17 @@
 export * from './approval-continuation'
 export * from './agent-runtime-policy'
 export * from './agent-stream-helpers'
-export * from './agent-types'
 export * from './chat-request-routing'
 export * from './chat-run-registry'
-export * from './context-compaction'
+export * from './context-compaction/context-compaction'
 export * from './execution-plan'
 export * from './graph-designer'
 export * from './helper-model'
 export * from './indexed-repositories-policy'
 export * from './instruction-sections'
-export * from './memory-block'
-export * from './memory-digest-policy'
-export * from './memory-scope'
+export * from './memory/memory-block'
+export * from './memory/memory-digest-policy'
+export * from './memory/memory-scope'
 export * from './llm-content'
 export * from './plugin-resolution'
 export * from './plugin-types'
@@ -20,8 +19,8 @@ export * from './runtime-config'
 export * from './runtime-extensions'
 export * from './runtime-worker-registry'
 export * from './skill-extraction-policy'
-export * from './social-chat'
-export * from './team-consultation-orchestrator'
-export * from './team-consultation-prompts'
+export * from './social-chat/social-chat'
+export * from './team-consultation/team-consultation-orchestrator'
+export * from './team-consultation/team-consultation-prompts'
 export * from './turn-lifecycle'
 export * from './thread-chat-helpers'

package/src/runtime/indexed-repositories-policy.ts

@@ -1,4 +1,4 @@
-import { agentRoster } from '../config/agent-defaults'
+import { getAgentRoster } from '../config/agent-defaults'
 
 export type IndexedRepoAgentName = string
 
@@ -16,13 +16,13 @@ export type RepoSectionName = (typeof REPO_SECTION_NAMES)[number]
 const ALL_REPO_SECTIONS: RepoSectionName[] = [...REPO_SECTION_NAMES]
 
 export function buildDefaultRepoSectionsByAgent(
-  roster: readonly IndexedRepoAgentName[] = agentRoster,
+  roster: readonly IndexedRepoAgentName[] = getAgentRoster(),
 ): Record<IndexedRepoAgentName, RepoSectionName[]> {
   return Object.fromEntries(roster.map((agentId) => [agentId, [...ALL_REPO_SECTIONS]]))
 }
 
 export function emptyAgentContextMap(
-  roster: readonly IndexedRepoAgentName[] = agentRoster,
+  roster: readonly IndexedRepoAgentName[] = getAgentRoster(),
 ): Record<IndexedRepoAgentName, string> {
   return Object.fromEntries(roster.map((agentId) => [agentId, '']))
 }