@lota-sdk/core 0.1.15 → 0.1.16

package/src/storage/generated-document-storage.service.ts

@@ -1,8 +1,9 @@
 import { S3Client } from 'bun'
 
 import { getRuntimeConfig } from '../runtime/runtime-config'
+import { toSafeSegment } from './attachment-utils'
 
-function toSafeSegment(value: string): string {
+function toSafePathSegment(value: string): string {
   return value
     .trim()
     .replace(/\\/g, '/')
@@ -18,7 +19,7 @@ function buildGeneratedDocumentStorageKey(params: {
 }): string {
   const safeOrganizationId = toSafeSegment(params.organizationId)
   const safeNamespace = toSafeSegment(params.namespace)
-  const safeRelativePath = toSafeSegment(params.relativePath)
+  const safeRelativePath = toSafePathSegment(params.relativePath)
   return `${safeOrganizationId}/generated/${safeNamespace}/${safeRelativePath}`
 }
 

package/src/system-agents/delegated-agent-factory.ts

@@ -3,6 +3,7 @@ import type { ModelMessage, LanguageModel, ToolLoopAgentSettings, ToolSet } from
 import { z } from 'zod'
 
 import type { ToolDefinition } from '../ai/definitions'
+import { aiLogger } from '../config/logger'
 import { isRecord } from '../utils/string'
 import { assertSubstantiveAgentResult } from './agent-result'
 
@@ -136,6 +137,7 @@ async function generateSubstantiveDelegatedAgentResult(params: {
     try {
       return assertSubstantiveAgentResult(result.text, params.label)
     } catch (error) {
+      aiLogger.error`Delegated agent returned non-substantive result (label=${params.label}, attempt=${attempt + 1}, textLength=${result.text.length}, textPreview=${result.text.slice(0, 200)})`
       lastError = error
       if (params.abortSignal?.aborted) {
         throw error

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

@@ -1,35 +1,17 @@
 import {
   CreateExecutionPlanArgsSchema,
   GetActiveExecutionPlanArgsSchema,
+  ListExecutionPlansArgsSchema,
   ResumeExecutionPlanRunArgsSchema,
   ReplaceExecutionPlanArgsSchema,
   SubmitExecutionNodeResultArgsSchema,
+  getLatestExecutionPlanResult,
 } from '@lota-sdk/shared'
-import type { ExecutionPlanToolResultData } from '@lota-sdk/shared'
 import { tool } from 'ai'
 
 import type { RecordIdRef } from '../db/record-id'
 import { executionPlanService } from '../services/execution-plan.service'
 
-function isExecutionPlanResult(value: unknown): value is ExecutionPlanToolResultData {
-  return value !== null && value !== undefined && typeof value === 'object' && 'hasPlan' in value
-}
-
-function getLatestExecutionPlanToolResult(output: unknown): ExecutionPlanToolResultData | undefined {
-  if (isExecutionPlanResult(output)) {
-    return output
-  }
-
-  if (Array.isArray(output)) {
-    for (let index = output.length - 1; index >= 0; index -= 1) {
-      const candidate = getLatestExecutionPlanToolResult(output[index])
-      if (candidate) return candidate
-    }
-  }
-
-  return undefined
-}
-
 export function createCreateExecutionPlanTool(params: {
   orgId: RecordIdRef
   workstreamId: RecordIdRef
@@ -45,6 +27,7 @@ export function createCreateExecutionPlanTool(params: {
         organizationId: params.orgId,
         workstreamId: params.workstreamId,
         leadAgentId: params.agentId,
+        dispatchMode: 'deferred',
         input,
       })
       params.onPlanChanged?.()
@@ -68,6 +51,7 @@ export function createReplaceExecutionPlanTool(params: {
         organizationId: params.orgId,
         workstreamId: params.workstreamId,
         leadAgentId: params.agentId,
+        dispatchMode: 'deferred',
         input,
       })
       params.onPlanChanged?.()
@@ -95,21 +79,31 @@ export function createSubmitExecutionNodeResultTool(params: {
       return result
     },
     toModelOutput: ({ output }) => {
-      const result = getLatestExecutionPlanToolResult(output)
+      const result = getLatestExecutionPlanResult(output)
       const summary = result?.message?.trim()
       return { type: 'text', value: summary && summary.length > 0 ? summary : 'Execution node result submitted.' }
     },
   })
 }
 
-export function createGetActiveExecutionPlanTool(params: { workstreamId: RecordIdRef }) {
+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 the active execution run for this workstream, including graph state, node contracts, recent events, approvals, artifacts, and checkpoints when requested.',
+      'Load a specific execution run by runId, or the most recent active run if runId is omitted. Returns full graph state, node contracts, events, approvals, artifacts, and checkpoints.',
     inputSchema: GetActiveExecutionPlanArgsSchema,
     execute: async (input) =>
       await executionPlanService.getActivePlanToolResult({
         workstreamId: params.workstreamId,
+        runId: input.runId,
         includeEvents: input.includeEvents,
         includeArtifacts: input.includeArtifacts,
         includeApprovals: input.includeApprovals,

package/src/tools/index.ts

@@ -1,6 +1,5 @@
 export * from './execution-plan.tool'
 export * from './fetch-webpage.tool'
-export * from './log-hello-world.tool'
 export * from './memory-block.tool'
 export * from './read-file-parts.tool'
 export * from './remember-memory.tool'

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

@@ -27,7 +27,8 @@ async function buildTeamThinkAgentTools(
   return { tools: result.tools as Record<string, unknown> }
 }
 
-const TEAM_THINK_AGENT_MAX_RETRIES = 4
+const TEAM_THINK_AGENT_MAX_RETRIES = 1
+const TEAM_THINK_AGENT_MAX_STEPS = 3
 
 export function createTeamThinkTool(params: {
   historyMessages: ChatMessage[]
@@ -58,7 +59,7 @@ export function createTeamThinkTool(params: {
         mode: 'fixedWorkstreamMode',
         onboardingActive: false,
         linearInstalled: false,
-        reasoningProfile: runParams.reasoningProfile,
+        reasoningProfile: 'fast',
         systemWorkspaceDetails: runParams.systemWorkspaceDetails,
         preSeededMemoriesSection: runParams.preSeededMemoriesSection,
         retrievedKnowledgeSection: runParams.retrievedKnowledgeSection,
@@ -75,7 +76,7 @@ export function createTeamThinkTool(params: {
         workspaceIdString: recordIdToString(params.orgId, TABLES.ORGANIZATION),
         workstreamId: params.workstreamId,
         githubInstalled: params.githubInstalled,
-        provideRepoTool: params.provideRepoTool,
+        provideRepoTool: agentId !== 'mentor' && params.provideRepoTool,
         availableUploads: params.availableUploads,
         defaultRepoSections: params.defaultRepoSectionsByAgent[agentId],
         context: params.context,
@@ -83,7 +84,8 @@ export function createTeamThinkTool(params: {
       })
       const agentConfig = config as Record<string, unknown>
       const agentId_ = typeof agentConfig.id === 'string' ? agentConfig.id : agentId
-      const maxSteps = typeof agentConfig.maxSteps === 'number' ? agentConfig.maxSteps : 10
+      const configuredMaxSteps = typeof agentConfig.maxSteps === 'number' ? agentConfig.maxSteps : 10
+      const maxSteps = Math.min(configuredMaxSteps, TEAM_THINK_AGENT_MAX_STEPS)
       const agent = createAgent[agentId_]({
         mode: 'fixedWorkstreamMode',
         tools,

package/src/utils/async.ts

@@ -1,3 +1,4 @@
+import { serverLogger } from '../config/logger'
 import { getErrorMessage } from './errors'
 
 class TimeoutError extends Error {
@@ -41,7 +42,7 @@ export function createSafeEnqueue(logger: { warn: (message: string) => void }) {
   }
 }
 
-const _defaultSafeEnqueue = createSafeEnqueue({ warn: console.warn })
+const _defaultSafeEnqueue = createSafeEnqueue({ warn: (message: string) => serverLogger.warn`${message}` })
 export function safeEnqueue<T>(
   operation: () => T | Promise<T>,
   options: { operationName: string; onError?: (error: unknown) => void; logPrefix?: string },

package/src/utils/date-time.ts

@@ -1,34 +1,6 @@
-export function toIsoDateTimeString(value: unknown): string {
-  if (value instanceof Date) {
-    return value.toISOString()
-  }
+export { toIsoDateTimeString, toOptionalIsoDateTimeString } from '@lota-sdk/shared'
 
-  // Assume API boundaries already use ISO strings.
-  if (typeof value === 'string') {
-    return value
-  }
-
-  // Support unix timestamps (seconds or milliseconds).
-  if (typeof value === 'number') {
-    const millis = value < 1_000_000_000_000 ? value * 1000 : value
-    return new Date(millis).toISOString()
-  }
-
-  // Support objects that expose toISOString (e.g., SurrealDB temporal types).
-  if (value && typeof value === 'object') {
-    const maybeToIso = (value as { toISOString?: unknown }).toISOString
-    if (typeof maybeToIso === 'function') {
-      return (value as { toISOString: () => string }).toISOString()
-    }
-  }
-
-  return String(value)
-}
-
-export function toOptionalIsoDateTimeString(value: unknown): string | undefined {
-  if (value === null || value === undefined || value === '') {
-    return undefined
-  }
-
-  return toIsoDateTimeString(value)
+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)
 }

package/src/utils/env.ts

@@ -0,0 +1,8 @@
+/**
+ * Reads a required environment variable. Throws if the variable is missing or empty.
+ */
+export function getRequiredEnv(key: string): string {
+  const value = process.env[key]
+  if (!value) throw new Error(`Missing required env var: ${key}`)
+  return value
+}

package/src/utils/errors.ts

@@ -1,13 +1,4 @@
-export function getErrorMessage(error: unknown): string {
-  if (error instanceof Error) return error.message
-  if (typeof error === 'string') return error
-
-  try {
-    return JSON.stringify(error)
-  } catch {
-    return String(error)
-  }
-}
+export { getErrorMessage } from '@lota-sdk/shared'
 
 export function toError(value: unknown): Error {
   return value instanceof Error ? value : new Error(String(value))
@@ -41,3 +32,44 @@ export class BadRequestError extends AppError {
     super(message, 'BAD_REQUEST', 400)
   }
 }
+
+type ErrorCode =
+  | 'UNAUTHORIZED'
+  | 'FORBIDDEN'
+  | 'NOT_FOUND'
+  | 'CONFLICT'
+  | 'BAD_REQUEST'
+  | 'VALIDATION_ERROR'
+  | 'INTERNAL_SERVER_ERROR'
+  | 'HTTP_ERROR'
+  | 'TOO_MANY_REQUESTS'
+
+interface ValidationIssue {
+  path: string
+  message: string
+}
+
+export interface ErrorBody {
+  error: { code: ErrorCode; message: string; issues?: ValidationIssue[] }
+}
+
+function createErrorResponse(code: ErrorCode, message: string): ErrorBody {
+  return { error: { code, message } }
+}
+
+function createValidationErrorResponse(message: string, issues: ValidationIssue[]): ErrorBody {
+  return { error: { code: 'VALIDATION_ERROR', message, issues } }
+}
+
+export const errorResponses = {
+  unauthorized: (message = 'Invalid credentials') => createErrorResponse('UNAUTHORIZED', message),
+  forbidden: (message = 'Access denied') => createErrorResponse('FORBIDDEN', message),
+  notFound: (message: string) => createErrorResponse('NOT_FOUND', message),
+  conflict: (message: string) => createErrorResponse('CONFLICT', message),
+  badRequest: (message: string) => createErrorResponse('BAD_REQUEST', message),
+  tooManyRequests: (message = 'Too many requests') => createErrorResponse('TOO_MANY_REQUESTS', message),
+  serverError: (message = 'Internal server error') => createErrorResponse('INTERNAL_SERVER_ERROR', message),
+  validationError: (issues: ValidationIssue[], message = 'Validation failed') =>
+    createValidationErrorResponse(message, issues),
+  httpError: (message: string) => createErrorResponse('HTTP_ERROR', message),
+} as const

package/src/utils/index.ts

@@ -1,14 +1,23 @@
 export * from './async'
 export * from './date-time'
+export * from './env'
 export * from './errors'
 export * from './hono-error-handler'
 export * from './sse-keepalive'
 export {
   CHARS_PER_TOKEN_ESTIMATE,
+  clampImportance,
+  compactRecord,
   compactWhitespace,
   isRecord,
+  parseLineList,
+  readRecordArray,
   readString,
+  readStringArray,
   readStringField,
+  slugify,
+  stringifyLineList,
+  stringifyUnknown,
   truncateOptionalText,
   truncateText,
 } from './string'

package/src/utils/string.ts

@@ -29,7 +29,7 @@ export function readStringField(record: Record<string, unknown>, key: string): s
  * Returns the original string when it fits within maxChars.
  */
 export function truncateText(value: string, maxChars: number): string {
-  return value.length <= maxChars ? value : `${value.slice(0, maxChars).trimEnd()}...`
+  return value.length <= maxChars ? value : `${value.slice(0, maxChars - 3).trimEnd()}...`
 }
 
 /**
@@ -59,7 +59,120 @@ export function readRecord(value: unknown): Record<string, unknown> | null {
   return value as Record<string, unknown>
 }
 
+/**
+ * Strips null and undefined values from a record, returning a new object with only defined entries.
+ */
+export function compactRecord(value: Record<string, unknown>): Record<string, unknown> {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== null && entry !== undefined))
+}
+
+/**
+ * Converts a string into a URL-safe slug: lowercase, non-alphanumeric runs
+ * replaced with hyphens, leading/trailing hyphens stripped, capped at 80 chars.
+ */
+export function slugify(value: string): string {
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/(^-|-$)/g, '')
+    .slice(0, 80)
+}
+
 /**
  * Rough character-to-token estimate used for context budget calculations.
  */
 export const CHARS_PER_TOKEN_ESTIMATE = 3
+
+/**
+ * Converts an unknown value to a trimmed, non-empty string representation.
+ * Returns null for null, undefined, empty, or whitespace-only results.
+ *
+ * When maxChars is provided, the result is compacted and truncated.
+ * Without maxChars, strings are trimmed and objects are JSON-serialized.
+ */
+export function stringifyUnknown(value: unknown, maxChars?: number): string | null {
+  if (value === null || value === undefined) return null
+
+  const raw = (() => {
+    if (typeof value === 'string') return value
+    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
+      return String(value)
+    }
+    if (typeof value === 'symbol') return value.description ? `Symbol(${value.description})` : 'Symbol()'
+    if (typeof value === 'function') return value.name ? `[function ${value.name}]` : '[function anonymous]'
+    if (Array.isArray(value)) {
+      try {
+        return JSON.stringify(value)
+      } catch {
+        return `[array(${value.length})]`
+      }
+    }
+
+    try {
+      return JSON.stringify(value)
+    } catch {
+      const maybeName =
+        isRecord(value) && typeof (value as { constructor?: { name?: unknown } }).constructor?.name === 'string'
+          ? (value as { constructor?: { name?: string } }).constructor?.name
+          : 'Object'
+      return `[object ${maybeName}]`
+    }
+  })()
+
+  if (maxChars !== undefined) {
+    const normalized = compactWhitespace(raw)
+    if (!normalized) return null
+    return truncateText(normalized, maxChars)
+  }
+
+  const trimmed = raw.trim()
+  return trimmed.length > 0 ? trimmed : null
+}
+
+/**
+ * Clamps a numeric importance/confidence value to [0, 1].
+ * Returns 0 for non-finite values.
+ */
+export function clampImportance(value: number): number {
+  if (!Number.isFinite(value)) return 0
+  return Math.max(0, Math.min(1, value))
+}
+
+/**
+ * Splits a string on newlines, trims each line, and filters empties.
+ */
+export function parseLineList(value: string): string[] {
+  return value
+    .split('\n')
+    .map((entry) => entry.trim())
+    .filter((entry) => entry.length > 0)
+}
+
+/**
+ * Joins an array of values into a newline-separated string.
+ * Returns an empty string for non-array inputs.
+ */
+export function stringifyLineList(value: unknown): string {
+  return Array.isArray(value) ? value.map(String).join('\n') : ''
+}
+
+/**
+ * Reads an array of strings from an unknown value.
+ * Returns an empty array when the input is not an array.
+ */
+export function readStringArray(value: unknown): string[] {
+  if (!Array.isArray(value)) return []
+  return value.filter((entry): entry is string => typeof entry === 'string')
+}
+
+/**
+ * Reads an array of plain records from an unknown value.
+ * Returns an empty array when the input is not an array.
+ */
+export function readRecordArray(value: unknown): Array<Record<string, unknown>> {
+  if (!Array.isArray(value)) return []
+  return value.filter(
+    (entry): entry is Record<string, unknown> => typeof entry === 'object' && entry !== null && !Array.isArray(entry),
+  )
+}

package/src/workers/index.ts

@@ -5,3 +5,4 @@ export * from './utils/file-section-chunker'
 export * from './utils/repomix-file-sections'
 export * from './utils/repo-structure-extractor'
 export * from './utils/repomix-process-concurrency'
+export * from './utils/sandbox-error'

package/src/workers/regular-chat-memory-digest.runner.ts

@@ -130,7 +130,7 @@ async function hasNewEligibleWorkstreamMessages(params: {
 }
 
 async function loadExistingOrganizationMemories(orgId: string): Promise<Array<{ content: string }>> {
-  return await databaseService.queryMany(
+  return databaseService.queryMany(
     new BoundQuery(
       `SELECT content, createdAt, id FROM ${TABLES.MEMORY}
        WHERE metadata.orgId = $orgId
@@ -155,7 +155,7 @@ export async function runRegularChatMemoryDigest(
     return { skipped: true, processedWorkstreamMessages: 0, followUpScheduled: false }
   }
 
-  return await withConfiguredWorkspaceMemoryLock(orgId, async () => {
+  return withConfiguredWorkspaceMemoryLock(orgId, async () => {
     if (
       !workspaceProvider.getBackgroundCursor ||
       !workspaceProvider.setBackgroundCursor ||

package/src/workers/skill-extraction.runner.ts

@@ -86,7 +86,7 @@ export async function runSkillExtraction(data: SkillExtractionJob): Promise<Skil
     return { skipped: true, processedMessages: 0, extractedSkills: 0 }
   }
 
-  return await withConfiguredWorkspaceMemoryLock(orgId, async () => {
+  return withConfiguredWorkspaceMemoryLock(orgId, async () => {
     const workspace = await cursorAwareWorkspaceProvider.getWorkspace(orgRef)
     const lifecycleState = await cursorAwareWorkspaceProvider.getLifecycleState?.(workspace)
     if (lifecycleState?.bootstrapActive ?? false) {

package/src/workers/utils/file-section-chunker.ts

@@ -1,8 +1,9 @@
+import { CHARS_PER_TOKEN_ESTIMATE } from '../../utils/string'
+
 export const DEFAULT_FILE_SECTION_CHUNK_MAX_CHARS = 250_000
 export const MIN_FILE_SECTION_CHUNK_MAX_CHARS = 4_000
 export const DEFAULT_FILE_SECTION_CHUNK_MIN_CHARS = 10_000
 const SECTION_SEPARATOR_LENGTH = 2
-const CHARS_PER_TOKEN_ESTIMATE = 3
 const MIN_CHUNK_CHARS_FLOOR = 512
 
 export interface FileSection {

package/src/workers/utils/repomix-file-sections.ts

@@ -27,7 +27,7 @@ export function parseRepomixFileSections(repomixOutput: string): FileSection[] {
     const nextStart = matches[index + 1]?.index ?? source.length
     const content = source.slice(start, nextStart).trim()
     if (!content) continue
-    const filePath = (match[1] ?? '').trim()
+    const filePath = match[1].trim()
     sections.push({ kind: 'file', content, filePath: filePath || undefined })
   }
 
@@ -38,5 +38,5 @@ export async function chunkRepomixFileSections(
   repomixOutput: string,
   options: FileSectionChunkOptions = {},
 ): Promise<FileSectionChunk[]> {
-  return await chunkFileSections(parseRepomixFileSections(repomixOutput), options)
+  return chunkFileSections(parseRepomixFileSections(repomixOutput), options)
 }

package/src/workers/utils/sandbox-error.ts

@@ -1,5 +1,14 @@
-export function toSandboxedWorkerError(error: unknown, context?: string): Error {
-  const base = error instanceof Error ? error : new Error(String(error))
+export interface SandboxedWorkerError {
+  name: string
+  message: string
+  stack?: string
+}
+
+export function toSandboxedWorkerError(error: unknown, context?: string): SandboxedWorkerError {
+  const base =
+    error instanceof Error
+      ? { name: error.name || 'Error', message: error.message, stack: error.stack }
+      : { name: 'Error', message: String(error) }
   if (context) base.message = `${context}: ${base.message}`
   return base
 }

package/src/workers/utils/workstream-message-query.ts

@@ -1,27 +1,15 @@
-import { toTimestamp } from '@lota-sdk/shared'
+import { requireTimestamp } from '@lota-sdk/shared'
 import { BoundQuery } from 'surrealdb'
 import { z } from 'zod'
 
-import { ensureRecordId } from '../../db/record-id'
+import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import type { RecordIdRef } from '../../db/record-id'
 import { databaseService } from '../../db/service'
 import { TABLES } from '../../db/tables'
+import { WorkstreamMessageRowSchema } from '../../db/workstream-message-row'
+import type { WorkstreamMessageRow } from '../../db/workstream-message-row'
 import { normalizeTextBody } from '../../document/parsing'
 
-const RecordTimestampSchema = z.union([z.date(), z.string(), z.number()])
-const MessageRoleSchema = z.enum(['system', 'user', 'assistant'])
-const MessagePartSchema = z.record(z.string(), z.unknown())
-const MessageMetadataSchema = z.record(z.string(), z.unknown()).nullish()
-
-const WorkstreamMessageRowSchema = z.object({
-  id: z.string(),
-  workstreamId: z.string(),
-  role: MessageRoleSchema,
-  parts: z.array(MessagePartSchema).optional(),
-  metadata: MessageMetadataSchema,
-  createdAt: RecordTimestampSchema,
-})
-
 export interface DigestCursor {
   createdAt: Date
   id: string
@@ -36,14 +24,17 @@ export interface DigestMessage {
   cursor: DigestCursor
 }
 
-function mapWorkstreamRow(row: z.infer<typeof WorkstreamMessageRowSchema>): DigestMessage {
+function mapWorkstreamRow(row: WorkstreamMessageRow): DigestMessage {
   return {
     source: 'workstream',
-    sourceId: row.workstreamId,
+    sourceId: recordIdToString(row.workstreamId, TABLES.WORKSTREAM),
     role: row.role,
-    parts: row.parts ?? [],
+    parts: row.parts as Array<Record<string, unknown>>,
     metadata: row.metadata ?? undefined,
-    cursor: { createdAt: new Date(toTimestamp(row.createdAt) ?? Date.now()), id: row.id },
+    cursor: {
+      createdAt: new Date(requireTimestamp(row.createdAt)),
+      id: recordIdToString(row.id, TABLES.WORKSTREAM_MESSAGE),
+    },
   }
 }
 

package/src/workers/worker-utils.ts

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'node:url'
 import type { Job, Worker } from 'bullmq'
 
 import { chatLogger } from '../config/logger'
+import { truncateText } from '../utils/string'
 
 export const DEFAULT_JOB_RETENTION = { removeOnComplete: 200, removeOnFail: 200 }
 export const LOW_JOB_RETENTION = { removeOnComplete: 50, removeOnFail: 50 }
@@ -32,8 +33,7 @@ interface TracedWorkerJobLike {
 }
 
 function truncateTraceString(value: string, maxChars = MAX_TRACE_STRING_CHARS): string {
-  if (value.length <= maxChars) return value
-  return `${value.slice(0, maxChars - 3)}...`
+  return truncateText(value, maxChars)
 }
 
 function normalizeTraceValue(value: unknown, depth = 0): unknown {

package/src/tools/log-hello-world.tool.ts

@@ -1,17 +0,0 @@
-import { tool } from 'ai'
-import { z } from 'zod'
-
-export function createLogHelloWorldTool() {
-  return tool({
-    description: 'Logs "Hello World" to the server console. Requires user approval before running.',
-    inputSchema: z.object({
-      message: z.string().optional().describe('Optional custom message to log alongside Hello World'),
-    }),
-    needsApproval: true,
-    execute: async ({ message }: { message?: string }) => {
-      const output = message ? `Hello World: ${message}` : 'Hello World'
-      console.log('[logHelloWorld]', output)
-      return { logged: output, timestamp: new Date().toISOString() }
-    },
-  })
-}