@lota-sdk/core 0.4.8 → 0.4.10

package/src/tools/team-think.tool.ts

@@ -1,37 +1,58 @@
 import type { ChatMessage } from '@lota-sdk/shared'
 import { stepCountIs } from 'ai'
 import type { ToolSet } from 'ai'
+import { Schema, Effect } from 'effect'
 
-import { createAgent, getAgentRuntimeConfig } from '../config/agent-defaults'
+import { getAgentRuntimeConfig, getResolvedAgentFactoryConfig } from '../config/agent-defaults'
 import { aiLogger } from '../config/logger'
 import type { RecordIdRef } from '../db/record-id'
 import { recordIdToString } from '../db/record-id'
 import { TABLES } from '../db/tables'
+import { effectTryMaybeAsync as effectTryMaybeAsyncShared } from '../effect/helpers'
 import { readRuntimeAgentIdentityOverrides } from '../runtime/agent-identity-overrides'
 import { mergeInstructionSections } from '../runtime/instruction-sections'
 import { getRuntimeAdapters, getTurnHooks } from '../runtime/runtime-extensions'
 import type { LotaRuntimeTeamThinkToolsParams } from '../runtime/runtime-extensions'
-import { createConsultTeamTool as createConsultTeamToolSdk } from '../runtime/team-consultation-orchestrator'
-import type { DefaultRepoSections, TeamConsultationParticipantRunner } from '../runtime/team-consultation-orchestrator'
-import { buildTeamConsultationResponseGuard } from '../runtime/team-consultation-prompts'
+import { createConsultTeamTool as createConsultTeamToolSdk } from '../runtime/team-consultation/team-consultation-orchestrator'
+import type {
+  DefaultRepoSections,
+  TeamConsultationParticipantRunner,
+} from '../runtime/team-consultation/team-consultation-orchestrator'
+import { buildTeamConsultationResponseGuard } from '../runtime/team-consultation/team-consultation-prompts'
 import { asRecord, readInstructionSections, readOptionalString } from '../runtime/thread-chat-helpers'
 import type { ReadableUploadMetadata } from '../services/attachment.service'
 
-async function buildTeamThinkAgentTools(
+function buildTeamThinkAgentToolsEffect(
   params: LotaRuntimeTeamThinkToolsParams,
-): Promise<{ tools: Record<string, unknown> }> {
+): Effect.Effect<{ tools: ToolSet }, TeamThinkRuntimeError> {
   const builder = getRuntimeAdapters().buildTeamThinkAgentTools
   if (!builder) {
-    return { tools: {} }
+    return Effect.succeed({ tools: {} })
   }
 
-  const result = await builder(params)
-  return { tools: result.tools as Record<string, unknown> }
+  return effectTryMaybeAsync(() => builder(params), 'Failed to build team-think agent tools.')
 }
 
 const TEAM_THINK_AGENT_MAX_RETRIES = 1
 const TEAM_THINK_AGENT_MAX_STEPS = 3
 
+class TeamThinkAgentFactoryNotConfiguredError extends Schema.TaggedErrorClass<TeamThinkAgentFactoryNotConfiguredError>()(
+  'TeamThinkAgentFactoryNotConfiguredError',
+  { agentId: Schema.String },
+) {}
+
+class TeamThinkRuntimeError extends Schema.TaggedErrorClass<TeamThinkRuntimeError>()('TeamThinkRuntimeError', {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect),
+}) {}
+
+function effectTryMaybeAsync<A>(
+  evaluate: () => A | PromiseLike<A>,
+  message: string,
+): Effect.Effect<A, TeamThinkRuntimeError> {
+  return effectTryMaybeAsyncShared(evaluate, (error) => new TeamThinkRuntimeError({ message, cause: error }))
+}
+
 export function createTeamThinkTool(params: {
   historyMessages: ChatMessage[]
   latestUserMessageId: string
@@ -55,82 +76,102 @@ export function createTeamThinkTool(params: {
     (params.context as Record<string, unknown> | null | undefined) ?? null,
   )
   const participantRunner: TeamConsultationParticipantRunner = {
-    async buildParticipantAgent(agentId, runParams) {
-      const dynamicInstructionSections = await params.getAdditionalInstructionSections?.()
-      const agentResolution = asRecord(
-        await getTurnHooks().resolveAgent?.({
-          agentId,
-          mode: 'fixedThreadMode',
-          thread: null,
-          threadRef: params.threadId,
-          orgRef: params.orgId,
-          userRef: params.userId,
-          onboardingActive: false,
-          linearInstalled: false,
-          githubInstalled: params.githubInstalled,
-          additionalInstructionSections: mergeInstructionSections(
-            dynamicInstructionSections,
-            params.additionalInstructionSections,
-          ),
-          context: (params.context as Record<string, unknown> | null | undefined) ?? null,
-        }),
+    buildParticipantAgent(agentId, runParams) {
+      return Effect.runPromise(
+        Effect.gen(function* () {
+          const currentContext = yield* Effect.context()
+          const runPromiseWithCurrentContext = Effect.runPromiseWith(currentContext)
+          const dynamicInstructionSections = yield* effectTryMaybeAsync(
+            () => params.getAdditionalInstructionSections?.(),
+            'Failed to load dynamic team-think instruction sections.',
+          )
+          const agentResolution = asRecord(
+            yield* effectTryMaybeAsync(
+              () =>
+                getTurnHooks().resolveAgent?.({
+                  agentId,
+                  mode: 'fixedThreadMode',
+                  thread: null,
+                  threadRef: params.threadId,
+                  orgRef: params.orgId,
+                  userRef: params.userId,
+                  onboardingActive: false,
+                  linearInstalled: false,
+                  githubInstalled: params.githubInstalled,
+                  additionalInstructionSections: mergeInstructionSections(
+                    dynamicInstructionSections,
+                    params.additionalInstructionSections,
+                  ),
+                  context: (params.context as Record<string, unknown> | null | undefined) ?? null,
+                }),
+              'Failed to resolve team-think participant agent.',
+            ),
+          )
+          const resolvedAgentId = readOptionalString(agentResolution?.agentId) ?? agentId
+          const config = getAgentRuntimeConfig({
+            agentId: resolvedAgentId,
+            threadType: 'group' as const,
+            mode: 'fixedThreadMode',
+            onboardingActive: false,
+            linearInstalled: false,
+            systemWorkspaceDetails: runParams.systemWorkspaceDetails,
+            preSeededMemoriesSection: runParams.preSeededMemoriesSection,
+            retrievedKnowledgeSection: runParams.retrievedKnowledgeSection,
+            additionalInstructionSections: mergeInstructionSections(
+              dynamicInstructionSections,
+              params.additionalInstructionSections,
+              readInstructionSections(agentResolution?.additionalInstructionSections),
+            ),
+            responseGuardSection: buildTeamConsultationResponseGuard({
+              agentId: resolvedAgentId,
+              task: runParams.task,
+            }),
+          })
+          const { tools } = yield* buildTeamThinkAgentToolsEffect({
+            agentId: resolvedAgentId,
+            workspaceId: params.orgId,
+            userId: params.userId,
+            workspaceIdString: recordIdToString(params.orgId, TABLES.ORGANIZATION),
+            threadId: params.threadId,
+            githubInstalled: params.githubInstalled,
+            provideRepoTool: resolvedAgentId !== 'mentor' && params.provideRepoTool,
+            availableUploads: params.availableUploads,
+            defaultRepoSections: params.defaultRepoSectionsByAgent[resolvedAgentId],
+            context: params.context,
+            toolProviders: params.toolProviders,
+          })
+          const agentId_ = config.id || resolvedAgentId
+          const configuredMaxSteps = config.maxSteps
+          const maxSteps = Math.min(configuredMaxSteps, TEAM_THINK_AGENT_MAX_STEPS)
+          const agentFactory = getResolvedAgentFactoryConfig().createAgent[agentId_]
+          if (!agentFactory) {
+            return yield* new TeamThinkAgentFactoryNotConfiguredError({ agentId: agentId_ })
+          }
+          const agent = agentFactory({
+            mode: 'fixedThreadMode',
+            tools,
+            extraInstructions: config.extraInstructions,
+            maxRetries: TEAM_THINK_AGENT_MAX_RETRIES,
+            stopWhen: [stepCountIs(maxSteps)],
+          })
+          const observer = {
+            run: <T>(fn: () => T | Promise<T>): Promise<T> =>
+              runPromiseWithCurrentContext(effectTryMaybeAsync(fn, `Team-think participant run failed (${agentId}).`)),
+            recordError: (error: unknown) => {
+              aiLogger.error`Team-think participant failed (${agentId}): ${error}`
+            },
+            recordAbort: (error: unknown) => {
+              aiLogger.debug`Team-think participant aborted (${agentId}): ${
+                error instanceof Error ? error.message : String(error)
+              }`
+            },
+          }
+          return {
+            agent: agent as Awaited<ReturnType<TeamConsultationParticipantRunner['buildParticipantAgent']>>['agent'],
+            observer,
+          }
+        }).pipe(Effect.withSpan('tool.teamThink.buildParticipantAgent')),
       )
-      const resolvedAgentId = readOptionalString(agentResolution?.agentId) ?? agentId
-      const config = getAgentRuntimeConfig({
-        agentId: resolvedAgentId,
-        threadType: 'group' as const,
-        mode: 'fixedThreadMode',
-        onboardingActive: false,
-        linearInstalled: false,
-        systemWorkspaceDetails: runParams.systemWorkspaceDetails,
-        preSeededMemoriesSection: runParams.preSeededMemoriesSection,
-        retrievedKnowledgeSection: runParams.retrievedKnowledgeSection,
-        additionalInstructionSections: mergeInstructionSections(
-          dynamicInstructionSections,
-          params.additionalInstructionSections,
-          readInstructionSections(agentResolution?.additionalInstructionSections),
-        ),
-        responseGuardSection: buildTeamConsultationResponseGuard({ agentId: resolvedAgentId, task: runParams.task }),
-      })
-      const { tools } = await buildTeamThinkAgentTools({
-        agentId: resolvedAgentId,
-        workspaceId: params.orgId,
-        userId: params.userId,
-        workspaceIdString: recordIdToString(params.orgId, TABLES.ORGANIZATION),
-        threadId: params.threadId,
-        githubInstalled: params.githubInstalled,
-        provideRepoTool: resolvedAgentId !== 'mentor' && params.provideRepoTool,
-        availableUploads: params.availableUploads,
-        defaultRepoSections: params.defaultRepoSectionsByAgent[resolvedAgentId],
-        context: params.context,
-        toolProviders: params.toolProviders,
-      })
-      const agentConfig = config as Record<string, unknown>
-      const agentId_ = typeof agentConfig.id === 'string' ? agentConfig.id : resolvedAgentId
-      const configuredMaxSteps = typeof agentConfig.maxSteps === 'number' ? agentConfig.maxSteps : 10
-      const maxSteps = Math.min(configuredMaxSteps, TEAM_THINK_AGENT_MAX_STEPS)
-      const agent = createAgent[agentId_]({
-        mode: 'fixedThreadMode',
-        tools,
-        extraInstructions: agentConfig.extraInstructions,
-        maxRetries: TEAM_THINK_AGENT_MAX_RETRIES,
-        stopWhen: [stepCountIs(maxSteps)],
-      })
-      const observer = {
-        run: async <T>(fn: () => T | Promise<T>): Promise<T> => fn(),
-        recordError: (error: unknown) => {
-          aiLogger.error`Team-think participant failed (${agentId}): ${error}`
-        },
-        recordAbort: (error: unknown) => {
-          aiLogger.info`Team-think participant aborted (${agentId}): ${
-            error instanceof Error ? error.message : String(error)
-          }`
-        },
-      }
-      return {
-        agent: agent as Awaited<ReturnType<TeamConsultationParticipantRunner['buildParticipantAgent']>>['agent'],
-        observer,
-      }
     },
   }
 

package/src/tools/user-questions.tool.ts

@@ -11,8 +11,9 @@ export const userQuestionsTool = {
       description:
         'Ask the user structured questions. UI renders them; do not repeat them in text. Turn ends after this call.',
       inputSchema: UserQuestionsArgsSchema,
-      execute: async (_args: UserQuestionsArgs) => {
-        return 'Questions have been presented to the user in the chat UI. Do NOT restate them in text, and do NOT generate further text or tool calls. Your turn is complete.'
-      },
+      execute: (_args: UserQuestionsArgs) =>
+        Promise.resolve(
+          'Questions have been presented to the user in the chat UI. Do NOT restate them in text, and do NOT generate further text or tool calls. Your turn is complete.',
+        ),
     }),
 } as const satisfies ToolDefinition<void>

package/src/tools/web-tool-shared.ts

@@ -0,0 +1,6 @@
+export const WEB_TOOL_TIMEOUT_MS = 30_000
+
+export function toRecord(value: unknown): Record<string, unknown> | null {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null
+  return value as Record<string, unknown>
+}

package/src/utils/async.ts

@@ -1,30 +1,33 @@
+import { Cause, Duration, Effect, Exit, Schema } from 'effect'
+
 import { serverLogger } from '../config/logger'
-import { getErrorMessage } from './errors'
+import { TimeoutError } from '../effect/errors'
+import { getErrorMessage, toError } from './errors'
 
-class TimeoutError extends Error {
-  constructor(operation: string, ms: number) {
-    super(`${operation} timed out after ${ms}ms`)
-    this.name = 'TimeoutError'
-  }
+class TimedOperationError extends Schema.TaggedErrorClass<TimedOperationError>()('TimedOperationError', {
+  operation: Schema.String,
+  cause: Schema.Defect,
+}) {}
+
+function isTimedOperationError(error: unknown): error is TimedOperationError {
+  return typeof error === 'object' && error !== null && '_tag' in error && error._tag === 'TimedOperationError'
 }
 
-export async function withTimeout<T>(promise: Promise<T>, ms: number, operation: string): Promise<T> {
-  let timeoutId: ReturnType<typeof setTimeout> | undefined
-
-  try {
-    return await Promise.race([
-      promise,
-      new Promise<never>((_, reject) => {
-        timeoutId = setTimeout(() => {
-          reject(new TimeoutError(operation, ms))
-        }, ms)
-      }),
-    ])
-  } finally {
-    if (timeoutId) {
-      clearTimeout(timeoutId)
+export function withTimeout<T>(promise: Promise<T>, ms: number, operation: string): Promise<T> {
+  return Effect.runPromise(
+    Effect.tryPromise({ try: () => promise, catch: (cause) => new TimedOperationError({ operation, cause }) }).pipe(
+      Effect.timeout(Duration.millis(ms)),
+      Effect.catchTag('TimeoutError', () => Effect.fail(new TimeoutError({ operation, ms }))),
+      Effect.exit,
+    ),
+  ).then((exit) => {
+    if (Exit.isSuccess(exit)) {
+      return exit.value
     }
-  }
+
+    const error = Cause.squash(exit.cause)
+    throw isTimedOperationError(error) ? toError(error.cause) : error
+  })
 }
 
 export function createSafeEnqueue(logger: { warn: (message: string) => void }) {

package/src/utils/crypto.ts

@@ -0,0 +1,21 @@
+import { RecordId } from 'surrealdb'
+
+export function createSha256Hasher(): Bun.CryptoHasher {
+  return new Bun.CryptoHasher('sha256')
+}
+
+export function sha256Hex(value: string): string {
+  return createSha256Hasher().update(value).digest('hex')
+}
+
+export function sha256HexFromParts(parts: Iterable<string>): string {
+  const hasher = createSha256Hasher()
+  for (const part of parts) {
+    hasher.update(part)
+  }
+  return hasher.digest('hex')
+}
+
+export function createDeterministicRecordId(table: string, key: string): RecordId {
+  return new RecordId(table, sha256Hex(key))
+}

package/src/utils/date-time.ts

@@ -1,3 +1,5 @@
+import { DateTime } from 'effect'
+
 export { toIsoDateTimeString, toOptionalIsoDateTimeString } from '@lota-sdk/shared'
 
 const PROMPT_DATE_FORMATTER = new Intl.DateTimeFormat('en-US', {
@@ -9,9 +11,46 @@ const PROMPT_DATE_FORMATTER = new Intl.DateTimeFormat('en-US', {
 
 export function toDatabaseDateTime(value: string | Date | null | undefined): Date | undefined {
   if (value === null || value === undefined) return undefined
-  return value instanceof Date ? value : new Date(value)
+  return value instanceof Date ? value : DateTime.toDateUtc(DateTime.makeUnsafe(value))
 }
 
 export function formatUtcPromptDate(value: Date): string {
   return PROMPT_DATE_FORMATTER.format(value)
 }
+
+export function nowDateTime(): DateTime.Utc {
+  return DateTime.nowUnsafe()
+}
+
+export function nowEpochMillis(): number {
+  return nowDateTime().epochMilliseconds
+}
+
+export function nowDate(): Date {
+  return DateTime.toDateUtc(nowDateTime())
+}
+
+export function nowIsoDateTimeString(): string {
+  return DateTime.formatIso(nowDateTime())
+}
+
+export function unsafeDateFrom(value: string | number | Date): Date {
+  if (value instanceof Date) {
+    return value
+  }
+
+  const normalized = typeof value === 'number' && value < 1_000_000_000_000 ? value * 1000 : value
+  return DateTime.toDateUtc(DateTime.makeUnsafe(normalized))
+}
+
+export function unsafeDateFromUnknown(value: unknown): Date {
+  if (value instanceof Date) {
+    return value
+  }
+
+  if (typeof value === 'number') {
+    return unsafeDateFrom(value)
+  }
+
+  return DateTime.toDateUtc(DateTime.makeUnsafe(String(value)))
+}

package/src/utils/errors.ts

@@ -1,35 +1,50 @@
 export { getErrorMessage } from '@lota-sdk/shared'
+import { Data, Match } from 'effect'
+
+import type { EffectError, ValidationIssue } from '../effect/errors'
+import { BaseServicePersistenceError, isEffectError } from '../effect/errors'
 
 export function toError(value: unknown): Error {
   return value instanceof Error ? value : new Error(String(value))
 }
 
-export class AppError extends Error {
-  public readonly code: string
-  public readonly statusCode: number
+export interface HttpError {
+  statusCode: number
+  code: string
+  message: string
+}
+
+export interface AppErrorResponse {
+  status: number
+  body: { error: { code: string; message: string } }
+}
+
+export type AppErrorLike = Error & { code: string; statusCode: number; toResponse?: () => unknown }
 
+export class AppError extends Data.Error<{
+  readonly message: string
+  readonly code: string
+  readonly statusCode: number
+}> {
   constructor(message: string, code: string, statusCode: number) {
-    super(message)
-    this.name = this.constructor.name
-    this.code = code
-    this.statusCode = statusCode
-    Error.captureStackTrace(this, this.constructor)
+    super({ message, code, statusCode })
+    this.name = new.target.name
   }
 
-  public toResponse() {
+  toResponse(): AppErrorResponse {
     return { status: this.statusCode, body: { error: { code: this.code, message: this.message } } }
   }
 }
 
-export class NotFoundError extends AppError {
-  constructor(message = 'Resource not found') {
-    super(message, 'NOT_FOUND', 404)
+export class BadRequestError extends AppError {
+  constructor(message: string) {
+    super(message, 'BAD_REQUEST', 400)
   }
 }
 
-export class BadRequestError extends AppError {
-  constructor(message = 'Bad request') {
-    super(message, 'BAD_REQUEST', 400)
+export class NotFoundError extends AppError {
+  constructor(message: string) {
+    super(message, 'NOT_FOUND', 404)
   }
 }
 
@@ -44,11 +59,6 @@ type ErrorCode =
   | 'HTTP_ERROR'
   | 'TOO_MANY_REQUESTS'
 
-interface ValidationIssue {
-  path: string
-  message: string
-}
-
 export interface ErrorBody {
   error: { code: ErrorCode; message: string; issues?: ValidationIssue[] }
 }
@@ -73,3 +83,84 @@ export const errorResponses = {
     createValidationErrorResponse(message, issues),
   httpError: (message: string) => createErrorResponse('HTTP_ERROR', message),
 } as const
+
+function httpError(message: string, code: string, statusCode: number): HttpError {
+  return { message, code, statusCode }
+}
+
+export function isAppErrorLike(error: unknown): error is AppErrorLike {
+  if (!(error instanceof Error)) {
+    return false
+  }
+
+  const candidate = error as Partial<AppErrorLike>
+  return typeof candidate.code === 'string' && typeof candidate.statusCode === 'number'
+}
+
+function isAppErrorResponse(value: unknown): value is AppErrorResponse {
+  if (typeof value !== 'object' || value === null) {
+    return false
+  }
+
+  const candidate = value as {
+    status?: unknown
+    body?: { error?: { code?: unknown; message?: unknown } | null } | null
+  }
+  return (
+    typeof candidate.status === 'number' &&
+    typeof candidate.body === 'object' &&
+    candidate.body !== null &&
+    typeof candidate.body.error === 'object' &&
+    candidate.body.error !== null &&
+    typeof candidate.body.error.code === 'string' &&
+    typeof candidate.body.error.message === 'string'
+  )
+}
+
+export function toAppErrorResponse(error: AppErrorLike): AppErrorResponse {
+  if (typeof error.toResponse === 'function') {
+    const response = error.toResponse()
+    if (isAppErrorResponse(response)) {
+      return response
+    }
+  }
+
+  return { status: error.statusCode, body: { error: { code: error.code, message: error.message } } }
+}
+
+function isBaseServicePersistenceError(error: EffectError): error is BaseServicePersistenceError {
+  return error._tag === BaseServicePersistenceError.name
+}
+
+const toHttpErrorMatch = Match.type<Exclude<EffectError, BaseServicePersistenceError>>().pipe(
+  Match.tag('NotFoundError', (e) => httpError(e.message, 'NOT_FOUND', 404)),
+  Match.tag('BadRequestError', (e) => httpError(e.message, 'BAD_REQUEST', 400)),
+  Match.tag('ValidationError', (e) => httpError(e.message, 'VALIDATION_ERROR', 400)),
+  Match.tag('ConflictError', (e) => httpError(e.message, 'CONFLICT', 409)),
+  Match.tag('ForbiddenError', (e) => httpError(e.message, 'FORBIDDEN', 403)),
+  Match.tag('ThreadTurnError', (e) =>
+    httpError(e.message, e.reason === 'conflict' ? 'CONFLICT' : 'BAD_REQUEST', e.reason === 'conflict' ? 409 : 400),
+  ),
+  Match.tag('ActiveThreadRunConflictError', (e) => httpError(e.message, 'CONFLICT', 409)),
+  Match.tag('ConfigurationError', (e) => httpError(e.message, 'INTERNAL_SERVER_ERROR', 500)),
+  Match.tag('DatabaseError', () => httpError('Internal server error', 'INTERNAL_SERVER_ERROR', 500)),
+  Match.tag('RedisError', () => httpError('Internal server error', 'INTERNAL_SERVER_ERROR', 500)),
+  Match.tag('TimeoutError', (e) =>
+    httpError(`Operation "${e.operation}" timed out after ${e.ms}ms`, 'INTERNAL_SERVER_ERROR', 500),
+  ),
+  Match.tag('LockAcquisitionError', () => httpError('Internal server error', 'INTERNAL_SERVER_ERROR', 500)),
+  Match.tag('LockLostError', () => httpError('Internal server error', 'INTERNAL_SERVER_ERROR', 500)),
+  Match.tag('AiGenerationError', (e) => httpError(e.message, 'INTERNAL_SERVER_ERROR', 500)),
+  Match.tag('ServiceError', () => httpError('Internal server error', 'INTERNAL_SERVER_ERROR', 500)),
+  Match.exhaustive,
+)
+
+export function toHttpError(error: EffectError): HttpError {
+  if (isBaseServicePersistenceError(error)) {
+    return httpError('Internal server error', 'INTERNAL_SERVER_ERROR', 500)
+  }
+
+  return toHttpErrorMatch(error)
+}
+
+export { isEffectError }

package/src/utils/hono-error-handler.ts

@@ -2,69 +2,54 @@ import type { ErrorHandler } from 'hono'
 import { HTTPException } from 'hono/http-exception'
 import { ZodError } from 'zod'
 
-import { AppError, getErrorMessage } from './errors'
-
-type AppErrorLike = Pick<AppError, 'code' | 'message' | 'statusCode' | 'toResponse'> & { name?: string }
+import { toValidationIssues } from '../effect/zod'
+import { getErrorMessage, isAppErrorLike, isEffectError, toAppErrorResponse, toHttpError } from './errors'
 
 type HonoErrorLogger = Pick<Console, 'warn' | 'error'>
 
-function isAppErrorLike(error: unknown): error is AppErrorLike {
-  if (!error || typeof error !== 'object') {
-    return false
-  }
-
-  const candidate = error as Partial<AppErrorLike>
-  return (
-    typeof candidate.code === 'string' &&
-    typeof candidate.message === 'string' &&
-    typeof candidate.statusCode === 'number' &&
-    typeof candidate.toResponse === 'function'
-  )
+function createErrorResponse(code: string, message: string) {
+  return { error: { code, message } }
 }
 
 function createValidationErrorResponse(issues: Array<{ path: string; message: string }>) {
   return { error: { code: 'VALIDATION_ERROR', message: 'Validation failed', issues } }
 }
 
-function createHttpErrorResponse(message: string) {
-  return { error: { code: 'HTTP_ERROR', message } }
-}
-
-function createServerErrorResponse(message: string) {
-  return { error: { code: 'INTERNAL_SERVER_ERROR', message } }
-}
-
 export function createHonoErrorHandler(logger: HonoErrorLogger): ErrorHandler {
   return (error, c) => {
-    const appError = error instanceof AppError || isAppErrorLike(error) ? error : null
-
-    if (appError) {
-      const log = appError.statusCode >= 500 ? logger.error : logger.warn
-      const errorName = typeof appError.name === 'string' && appError.name.length > 0 ? appError.name : 'AppError'
-      log(`Request failed: ${errorName} (${appError.code}) ${appError.message}`)
-      const { status, body } = appError.toResponse()
-      const typedStatus = status as Parameters<typeof c.json>[1]
-      return c.json(body, typedStatus)
-    }
-
     if (error instanceof HTTPException) {
       const log = error.status >= 500 ? logger.error : logger.warn
       log(`Request failed: HTTPException ${error.status} ${error.message}`)
-      return error.res ?? c.json(createHttpErrorResponse(error.message), error.status)
+      return error.res ?? c.json(createErrorResponse('HTTP_ERROR', error.message), error.status)
     }
 
     if (error instanceof ZodError) {
       logger.warn(`Request failed: ZodError ${error.message}`)
-      const issues = error.issues.map((issue) => ({ path: issue.path.join('.'), message: issue.message }))
-      return c.json(createValidationErrorResponse(issues), 400)
+      return c.json(createValidationErrorResponse([...toValidationIssues(error)]), 400)
+    }
+
+    if (isAppErrorLike(error)) {
+      const response = toAppErrorResponse(error)
+      const log = response.status >= 500 ? logger.error : logger.warn
+      log(`Request failed: ${error.name} ${error.message}`)
+      const typedStatus = response.status as Parameters<typeof c.json>[1]
+      return c.json(response.body, typedStatus)
+    }
+
+    if (isEffectError(error)) {
+      const httpError = toHttpError(error)
+      const log = httpError.statusCode >= 500 ? logger.error : logger.warn
+      log(`Request failed: ${error._tag} ${error.message}`)
+      const typedStatus = httpError.statusCode as Parameters<typeof c.json>[1]
+      return c.json(createErrorResponse(httpError.code, httpError.message), typedStatus)
     }
 
     if (error instanceof Error) {
       logger.error(`Server error: ${error.name} ${error.message}\n${error.stack ?? ''}`)
-      return c.json(createServerErrorResponse('Internal Server Error'), 500)
+      return c.json(createErrorResponse('INTERNAL_SERVER_ERROR', 'Internal Server Error'), 500)
     }
 
     logger.error(`Server error: ${getErrorMessage(error)}`)
-    return c.json(createServerErrorResponse('Internal Server Error'), 500)
+    return c.json(createErrorResponse('INTERNAL_SERVER_ERROR', 'Internal Server Error'), 500)
   }
 }

package/src/utils/index.ts

@@ -1,8 +1,9 @@
 export * from './async'
+export * from './crypto'
 export * from './date-time'
-export * from './env'
 export * from './errors'
 export * from './hono-error-handler'
+export * from './null-proto-record'
 export * from './sse-keepalive'
 export {
   CHARS_PER_TOKEN_ESTIMATE,