Function handleConvertFrom

packages/mcp/src/tools/conversion.ts:255–306

(args: Record<string, unknown>)

}

async function handleConvertFrom(args: Record<string, unknown>) {
  const parsedArgs = convertFromArgsSchema.safeParse(args)
  if (!parsedArgs.success) {
    return toError(`Invalid arguments for deepnote_convert_from: ${formatFirstIssue(parsedArgs.error)}`)
  }
  const { inputPath, outputDir } = parsedArgs.data
  const format = parsedArgs.data.format ?? 'jupyter'

  const absoluteInput = path.resolve(inputPath)

  let inputStat: Awaited<ReturnType<typeof fs.stat>>
  try {
    inputStat = await fs.stat(absoluteInput)
  } catch (error) {
    const message = error instanceof Error ? error.message : String(error)
    return toError(`Invalid inputPath: ${message}`)
  }

  if (!inputStat.isFile()) {
    return toError('inputPath for deepnote_convert_from must point to a file')
  }

  const finalOutputDir = outputDir ? path.resolve(outputDir) : path.dirname(absoluteInput)

  try {
    await runFromDeepnoteConversion(format, absoluteInput, { outputDir: finalOutputDir })

    return {
      content: [
        {
          type: 'text',
          text: JSON.stringify(
            {
              success: true,
              inputPath: absoluteInput,
              outputFormat: format,
              outputDir: finalOutputDir,
            },
            null,
            2
          ),
        },
      ],
    }
  } catch (error) {
    const message = error instanceof Error ? error.message : String(error)
    return {
      content: [{ type: 'text', text: `Conversion failed: ${message}` }],
      isError: true,
    }
  }
}

export async function handleConversionTool(name: string, args: Record<string, unknown> | undefined) {
  const safeArgs = args || {}