simstudioai--sim/apps/sim/tools/knowledge/upload_chunk.ts

import type { KnowledgeUploadChunkResponse } from '@/tools/knowledge/types'
import type { ToolConfig } from '@/tools/types'

export const knowledgeUploadChunkTool: ToolConfig<any, KnowledgeUploadChunkResponse> = {
  id: 'knowledge_upload_chunk',
  name: 'Knowledge Upload Chunk',
  description: 'Upload a new chunk to a document in a knowledge base',
  version: '1.0.0',

  params: {
    knowledgeBaseId: {
      type: 'string',
      required: true,
      visibility: 'user-or-llm',
      description: 'ID of the knowledge base containing the document',
    },
    documentId: {
      type: 'string',
      required: true,
      visibility: 'user-or-llm',
      description: 'ID of the document to upload the chunk to',
    },
    content: {
      type: 'string',
      required: true,
      visibility: 'user-or-llm',
      description: 'Content of the chunk to upload',
    },
  },

  request: {
    url: (params) =>
      `/api/knowledge/${params.knowledgeBaseId}/documents/${params.documentId}/chunks`,
    method: 'POST',
    secretProvenance: {
      request: () => [{ key: 'chunk-content', inputPaths: [['content']] }],
      response: { incomplete: 'reject' },
    },
    headers: () => ({
      'Content-Type': 'application/json',
    }),
    body: (params) => {
      const workflowId = params._context?.workflowId

      const requestBody = {
        content: params.content,
        enabled: true,
        ...(workflowId && { workflowId }),
      }

      return requestBody
    },
  },

  transformResponse: async (response): Promise<KnowledgeUploadChunkResponse> => {
    const result = await response.json()
    const data = result.data || result

    // Restructure cost: extract tokens/model to top level for logging
    let costFields: Record<string, unknown> = {}
    if (data.cost && typeof data.cost === 'object') {
      const { tokens, model, input, output: outputCost, total } = data.cost
      costFields = {
        cost: { input, output: outputCost, total },
        ...(tokens && { tokens }),
        ...(model && { model }),
      }
    }

    return {
      success: true,
      output: {
        message: `Successfully uploaded chunk to document`,
        data: {
          chunkId: data.id,
          chunkIndex: data.chunkIndex || 0,
          content: data.content,
          contentLength: data.contentLength || data.content?.length || 0,
          tokenCount: data.tokenCount || 0,
          enabled: data.enabled !== undefined ? data.enabled : true,
          createdAt: data.createdAt,
          updatedAt: data.updatedAt,
        },
        documentId: data.documentId,
        documentName: data.documentName,
        ...costFields,
      },
    }
  },

  outputs: {
    data: {
      type: 'object',
      description: 'Information about the uploaded chunk',
      properties: {
        chunkId: { type: 'string', description: 'Chunk ID' },
        chunkIndex: { type: 'number', description: 'Index of the chunk within the document' },
        content: { type: 'string', description: 'Content of the chunk' },
        contentLength: { type: 'number', description: 'Length of the content in characters' },
        tokenCount: { type: 'number', description: 'Number of tokens in the chunk' },
        enabled: { type: 'boolean', description: 'Whether the chunk is enabled' },
        createdAt: { type: 'string', description: 'Creation timestamp' },
        updatedAt: { type: 'string', description: 'Last update timestamp' },
      },
    },
    message: {
      type: 'string',
      description: 'Success or error message describing the operation result',
    },
    documentId: {
      type: 'string',
      description: 'ID of the document the chunk was added to',
    },
    documentName: {
      type: 'string',
      description: 'Name of the document the chunk was added to',
    },
    cost: {
      type: 'object',
      description: 'Cost information for the upload operation',
      optional: true,
    },
  },
}